Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b46df356 authored by Joe Perches's avatar Joe Perches Committed by Linus Torvalds
Browse files

drivers/block/floppy.c: use pr_<level> 



Convert bare printk to pr_info and pr_cont
Convert printk(KERN_ERR to pr_err

Signed-off-by: default avatarJoe Perches <joe@perches.com>
Cc: Stephen Hemminger <shemminger@vyatta.com>
Cc: Jens Axboe <jens.axboe@oracle.com>
Cc: Marcin Slusarz <marcin.slusarz@gmail.com>
Cc: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 48c8cee6

drivers/block/floppy.c

+175 −178
Original line number Diff line number Diff line
@@ -273,7 +273,7 @@ static inline void fallback_on_nodma_alloc(char **addr, size_t l) 
		return;		/* we have the memory */

	if (can_use_virtual_dma != 2)

		return;		/* no fallback allowed */

	printk("DMA memory shortage. Temporarily falling back on virtual DMA\n");

	pr_info("DMA memory shortage. Temporarily falling back on virtual DMA\n");

	*addr = (char *)nodma_mem_alloc(l);

#else

	return;
@@ -309,7 +309,7 @@ static int initialising = 1; 
#define UTESTF(x)	test_bit(x##_BIT, &UDRS->flags)



#define DPRINT(format, args...) \

	printk(DEVICE_NAME "%d: " format, current_drive, ##args)

	pr_info(DEVICE_NAME "%d: " format, current_drive, ##args)



#define PH_HEAD(floppy, head) (((((floppy)->stretch & 2) >> 1) ^ head) << 2)

#define STRETCH(floppy)	((floppy)->stretch & FD_STRETCH)
@@ -628,7 +628,7 @@ static inline void set_debugt(void) 
static inline void debugt(const char *message)

{

	if (DP->flags & DEBUGT)

		printk("%s dtime=%lu\n", message, jiffies - debugtimer);

		pr_info("%s dtime=%lu\n", message, jiffies - debugtimer);

}

#else

static inline void set_debugt(void) { }
@@ -687,9 +687,7 @@ static void __reschedule_timeout(int drive, const char *message, int marg) 
		fd_timeout.expires = jiffies + UDP->timeout;

	add_timer(&fd_timeout);

	if (UDP->flags & FD_DEBUG) {

		DPRINT("reschedule timeout ");

		printk(message, marg);

		printk("\n");

		DPRINT("reschedule timeout %s %d\n", message, marg);

	}

	timeout_message = message;

}
@@ -861,7 +859,7 @@ static void set_fdc(int drive) 
		current_drive = drive;

	}

	if (fdc != 1 && fdc != 0) {

		printk("bad fdc value\n");

		pr_info("bad fdc value\n");

		return;

	}

	set_dor(fdc, ~0, 8);
@@ -878,8 +876,7 @@ static void set_fdc(int drive) 
static int _lock_fdc(int drive, int interruptible, int line)

{

	if (!usage_count) {

		printk(KERN_ERR

		       "Trying to lock fdc while usage count=0 at line %d\n",

		pr_err("Trying to lock fdc while usage count=0 at line %d\n",

		       line);

		return -1;

	}
@@ -1115,16 +1112,16 @@ static void setup_DMA(void) 
	if (raw_cmd->length == 0) {

		int i;



		printk("zero dma transfer size:");

		pr_info("zero dma transfer size:");

		for (i = 0; i < raw_cmd->cmd_count; i++)

			printk("%x,", raw_cmd->cmd[i]);

		printk("\n");

			pr_cont("%x,", raw_cmd->cmd[i]);

		pr_cont("\n");

		cont->done(0);

		FDCS->reset = 1;

		return;

	}

	if (((unsigned long)raw_cmd->kernel_data) % 512) {

		printk("non aligned address: %p\n", raw_cmd->kernel_data);

		pr_info("non aligned address: %p\n", raw_cmd->kernel_data);

		cont->done(0);

		FDCS->reset = 1;

		return;
@@ -1427,10 +1424,40 @@ static int fdc_dtr(void) 


static void tell_sector(void)

{

	printk(": track %d, head %d, sector %d, size %d",

	pr_cont(": track %d, head %d, sector %d, size %d",

		R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);

}				/* tell_sector */



static void print_errors(void)

{

	DPRINT("");

	if (ST0 & ST0_ECE) {

		pr_cont("Recalibrate failed!");

	} else if (ST2 & ST2_CRC) {

		pr_cont("data CRC error");

		tell_sector();

	} else if (ST1 & ST1_CRC) {

		pr_cont("CRC error");

		tell_sector();

	} else if ((ST1 & (ST1_MAM | ST1_ND)) ||

		   (ST2 & ST2_MAM)) {

		if (!probing) {

			pr_cont("sector not found");

			tell_sector();

		} else

			pr_cont("probe failed...");

	} else if (ST2 & ST2_WC) {	/* seek error */

		pr_cont("wrong cylinder");

	} else if (ST2 & ST2_BC) {	/* cylinder marked as bad */

		pr_cont("bad cylinder");

	} else {

		pr_cont("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",

			ST0, ST1, ST2);

		tell_sector();

	}

	pr_cont("\n");

}



/*

 * OK, this error interpreting routine is called after a

 * DMA read/write has succeeded
@@ -1466,33 +1493,7 @@ static int interpret_errors(void) 
				DPRINT("Over/Underrun - retrying\n");

			bad = 0;

		} else if (*errors >= DP->max_errors.reporting) {

			DPRINT("");

			if (ST0 & ST0_ECE) {

				printk("Recalibrate failed!");

			} else if (ST2 & ST2_CRC) {

				printk("data CRC error");

				tell_sector();

			} else if (ST1 & ST1_CRC) {

				printk("CRC error");

				tell_sector();

			} else if ((ST1 & (ST1_MAM | ST1_ND))

				   || (ST2 & ST2_MAM)) {

				if (!probing) {

					printk("sector not found");

					tell_sector();

				} else

					printk("probe failed...");

			} else if (ST2 & ST2_WC) {	/* seek error */

				printk("wrong cylinder");

			} else if (ST2 & ST2_BC) {	/* cylinder marked as bad */

				printk("bad cylinder");

			} else {

				printk

				    ("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",

				     ST0, ST1, ST2);

				tell_sector();

			}

			printk("\n");

			print_errors();

		}

		if (ST2 & ST2_WC || ST2 & ST2_BC)

			/* wrong cylinder => recal */
@@ -1591,8 +1592,7 @@ static void seek_interrupt(void) 
	if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {

#ifdef DCL_DEBUG

		if (DP->flags & FD_DEBUG) {

			DPRINT

			    ("clearing NEWCHANGE flag because of effective seek\n");

			DPRINT("clearing NEWCHANGE flag because of effective seek\n");

			DPRINT("jiffies=%lu\n", jiffies);

		}

#endif
@@ -1712,10 +1712,8 @@ static void recal_interrupt(void) 
			 * be already at track 0.) Clear the

			 * new change flag */

#ifdef DCL_DEBUG

			if (DP->flags & FD_DEBUG) {

				DPRINT

				    ("clearing NEWCHANGE flag because of second recalibrate\n");

			}

			if (DP->flags & FD_DEBUG)

				DPRINT("clearing NEWCHANGE flag because of second recalibrate\n");

#endif



			CLEARF(FD_DISK_NEWCHANGE);
@@ -1744,8 +1742,8 @@ static void print_result(char *message, int inr) 
	DPRINT("%s ", message);

	if (inr >= 0)

		for (i = 0; i < inr; i++)

			printk("repl[%d]=%x ", i, reply_buffer[i]);

	printk("\n");

			pr_cont("repl[%d]=%x ", i, reply_buffer[i]);

	pr_cont("\n");

}



/* interrupt handler. Note that this can be called externally on the Sparc */
@@ -1766,9 +1764,9 @@ irqreturn_t floppy_interrupt(int irq, void *dev_id) 
	do_floppy = NULL;

	if (fdc >= N_FDC || FDCS->address == -1) {

		/* we don't even know which FDC is the culprit */

		printk("DOR0=%x\n", fdc_state[0].dor);

		printk("floppy interrupt on bizarre fdc %d\n", fdc);

		printk("handler=%p\n", handler);

		pr_info("DOR0=%x\n", fdc_state[0].dor);

		pr_info("floppy interrupt on bizarre fdc %d\n", fdc);

		pr_info("handler=%p\n", handler);

		is_alive("bizarre fdc");

		return IRQ_NONE;

	}
@@ -1826,7 +1824,7 @@ static void reset_interrupt(void) 
	debugt("reset interrupt:");

	result();		/* get the status ready for set_fdc */

	if (FDCS->reset) {

		printk("reset set in interrupt, calling %p\n", cont->error);

		pr_info("reset set in interrupt, calling %p\n", cont->error);

		cont->error();	/* a reset just after a reset. BAD! */

	}

	cont->redo();
@@ -1864,46 +1862,44 @@ static void show_floppy(void) 
{

	int i;



	printk("\n");

	printk("floppy driver state\n");

	printk("-------------------\n");

	printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",

	pr_info("\n");

	pr_info("floppy driver state\n");

	pr_info("-------------------\n");

	pr_info("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",

		jiffies, interruptjiffies, jiffies - interruptjiffies,

		lasthandler);



#ifdef FLOPPY_SANITY_CHECK

	printk("timeout_message=%s\n", timeout_message);

	printk("last output bytes:\n");

	pr_info("timeout_message=%s\n", timeout_message);

	pr_info("last output bytes:\n");

	for (i = 0; i < OLOGSIZE; i++)

		printk("%2x %2x %lu\n",

		pr_info("%2x %2x %lu\n",

			output_log[(i + output_log_pos) % OLOGSIZE].data,

			output_log[(i + output_log_pos) % OLOGSIZE].status,

			output_log[(i + output_log_pos) % OLOGSIZE].jiffies);

	printk("last result at %lu\n", resultjiffies);

	printk("last redo_fd_request at %lu\n", lastredo);

	for (i = 0; i < resultsize; i++) {

		printk("%2x ", reply_buffer[i]);

	}

	printk("\n");

	pr_info("last result at %lu\n", resultjiffies);

	pr_info("last redo_fd_request at %lu\n", lastredo);

	print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1,

		       reply_buffer, resultsize, true);

#endif



	printk("status=%x\n", fd_inb(FD_STATUS));

	printk("fdc_busy=%lu\n", fdc_busy);

	pr_info("status=%x\n", fd_inb(FD_STATUS));

	pr_info("fdc_busy=%lu\n", fdc_busy);

	if (do_floppy)

		printk("do_floppy=%p\n", do_floppy);

		pr_info("do_floppy=%p\n", do_floppy);

	if (work_pending(&floppy_work))

		printk("floppy_work.func=%p\n", floppy_work.func);

		pr_info("floppy_work.func=%p\n", floppy_work.func);

	if (timer_pending(&fd_timer))

		printk("fd_timer.function=%p\n", fd_timer.function);

		pr_info("fd_timer.function=%p\n", fd_timer.function);

	if (timer_pending(&fd_timeout)) {

		printk("timer_function=%p\n", fd_timeout.function);

		printk("expires=%lu\n", fd_timeout.expires - jiffies);

		printk("now=%lu\n", jiffies);

		pr_info("timer_function=%p\n", fd_timeout.function);

		pr_info("expires=%lu\n", fd_timeout.expires - jiffies);

		pr_info("now=%lu\n", jiffies);

	}

	printk("cont=%p\n", cont);

	printk("current_req=%p\n", current_req);

	printk("command_status=%d\n", command_status);

	printk("\n");

	pr_info("cont=%p\n", cont);

	pr_info("current_req=%p\n", current_req);

	pr_info("command_status=%d\n", command_status);

	pr_info("\n");

}



static void floppy_shutdown(unsigned long data)
@@ -1929,7 +1925,7 @@ static void floppy_shutdown(unsigned long data) 
		cont->done(0);

		cont->redo();	/* this will recall reset when needed */

	} else {

		printk("no cont in shutdown!\n");

		pr_info("no cont in shutdown!\n");

		process_fd_request();

	}

	is_alive("floppy shutdown");
@@ -2329,10 +2325,10 @@ static void request_done(int uptodate) 
	int block;



	probing = 0;

	reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);

	reschedule_timeout(MAXTIMEOUT, "request done", uptodate);



	if (!req) {

		printk("floppy.c: no request in request_done\n");

		pr_info("floppy.c: no request in request_done\n");

		return;

	}
@@ -2405,13 +2401,13 @@ static void rw_interrupt(void) 
	    DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {

		DPRINT("long rw: %x instead of %lx\n",

		       nr_sectors, current_count_sectors);

		printk("rs=%d s=%d\n", R_SECTOR, SECTOR);

		printk("rh=%d h=%d\n", R_HEAD, HEAD);

		printk("rt=%d t=%d\n", R_TRACK, TRACK);

		printk("heads=%d eoc=%d\n", heads, eoc);

		printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,

		       fsector_t, ssize);

		printk("in_sector_offset=%d\n", in_sector_offset);

		pr_info("rs=%d s=%d\n", R_SECTOR, SECTOR);

		pr_info("rh=%d h=%d\n", R_HEAD, HEAD);

		pr_info("rt=%d t=%d\n", R_TRACK, TRACK);

		pr_info("heads=%d eoc=%d\n", heads, eoc);

		pr_info("spt=%d st=%d ss=%d\n",

			SECT_PER_TRACK, fsector_t, ssize);

		pr_info("in_sector_offset=%d\n", in_sector_offset);

	}

#endif
@@ -2521,14 +2517,14 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2) 
#ifdef FLOPPY_SANITY_CHECK

	if (remaining > blk_rq_bytes(current_req) && CT(COMMAND) == FD_WRITE) {

		DPRINT("in copy buffer\n");

		printk("current_count_sectors=%ld\n", current_count_sectors);

		printk("remaining=%d\n", remaining >> 9);

		printk("current_req->nr_sectors=%u\n",

		pr_info("current_count_sectors=%ld\n", current_count_sectors);

		pr_info("remaining=%d\n", remaining >> 9);

		pr_info("current_req->nr_sectors=%u\n",

			blk_rq_sectors(current_req));

		printk("current_req->current_nr_sectors=%u\n",

		pr_info("current_req->current_nr_sectors=%u\n",

			blk_rq_cur_sectors(current_req));

		printk("max_sector=%d\n", max_sector);

		printk("ssize=%d\n", ssize);

		pr_info("max_sector=%d\n", max_sector);

		pr_info("ssize=%d\n", ssize);

	}

#endif
@@ -2551,16 +2547,15 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2) 
		    floppy_track_buffer + (max_buffer_sectors << 10) ||

		    dma_buffer < floppy_track_buffer) {

			DPRINT("buffer overrun in copy buffer %d\n",

			       (int)((floppy_track_buffer -

				      dma_buffer) >> 9));

			printk("fsector_t=%d buffer_min=%d\n",

			       (int)((floppy_track_buffer - dma_buffer) >> 9));

			pr_info("fsector_t=%d buffer_min=%d\n",

				fsector_t, buffer_min);

			printk("current_count_sectors=%ld\n",

			pr_info("current_count_sectors=%ld\n",

				current_count_sectors);

			if (CT(COMMAND) == FD_READ)

				printk("read\n");

				pr_info("read\n");

			if (CT(COMMAND) == FD_WRITE)

				printk("write\n");

				pr_info("write\n");

			break;

		}

		if (((unsigned long)buffer) % 512)
@@ -2602,7 +2597,7 @@ static void virtualdmabug_workaround(void) 
		end_sector = SECTOR + hard_sectors - 1;

#ifdef FLOPPY_SANITY_CHECK

		if (end_sector > SECT_PER_TRACK) {

			printk("too many sectors %d > %d\n",

			pr_info("too many sectors %d > %d\n",

				end_sector, SECT_PER_TRACK);

			return;

		}
@@ -2632,7 +2627,7 @@ static int make_raw_rw_request(void) 
	int ssize;



	if (max_buffer_sectors == 0) {

		printk("VFS: Block I/O scheduled on unopened device\n");

		pr_info("VFS: Block I/O scheduled on unopened device\n");

		return 0;

	}
@@ -2853,19 +2848,19 @@ static int make_raw_rw_request(void) 
		DPRINT("fractionary current count b=%lx s=%lx\n",

		       raw_cmd->length, current_count_sectors);

		if (raw_cmd->kernel_data != current_req->buffer)

			printk("addr=%d, length=%ld\n",

			pr_info("addr=%d, length=%ld\n",

				(int)((raw_cmd->kernel_data -

				       floppy_track_buffer) >> 9),

				current_count_sectors);

		printk("st=%d ast=%d mse=%d msi=%d\n",

		pr_info("st=%d ast=%d mse=%d msi=%d\n",

			fsector_t, aligned_sector_t, max_sector, max_size);

		printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);

		printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",

		pr_info("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);

		pr_info("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",

			COMMAND, SECTOR, HEAD, TRACK);

		printk("buffer drive=%d\n", buffer_drive);

		printk("buffer track=%d\n", buffer_track);

		printk("buffer_min=%d\n", buffer_min);

		printk("buffer_max=%d\n", buffer_max);

		pr_info("buffer drive=%d\n", buffer_drive);

		pr_info("buffer track=%d\n", buffer_track);

		pr_info("buffer_min=%d\n", buffer_min);

		pr_info("buffer_max=%d\n", buffer_max);

		return 0;

	}
@@ -2876,14 +2871,14 @@ static int make_raw_rw_request(void) 
		    raw_cmd->kernel_data + raw_cmd->length >

		    floppy_track_buffer + (max_buffer_sectors << 10)) {

			DPRINT("buffer overrun in schedule dma\n");

			printk("fsector_t=%d buffer_min=%d current_count=%ld\n",

			pr_info("fsector_t=%d buffer_min=%d current_count=%ld\n",

				fsector_t, buffer_min, raw_cmd->length >> 9);

			printk("current_count_sectors=%ld\n",

			pr_info("current_count_sectors=%ld\n",

				current_count_sectors);

			if (CT(COMMAND) == FD_READ)

				printk("read\n");

				pr_info("read\n");

			if (CT(COMMAND) == FD_WRITE)

				printk("write\n");

				pr_info("write\n");

			return 0;

		}

	} else if (raw_cmd->length > blk_rq_bytes(current_req) ||
@@ -2892,8 +2887,8 @@ static int make_raw_rw_request(void) 
		return 0;

	} else if (raw_cmd->length < current_count_sectors << 9) {

		DPRINT("more sectors than bytes\n");

		printk("bytes=%ld\n", raw_cmd->length >> 9);

		printk("sectors=%ld\n", current_count_sectors);

		pr_info("bytes=%ld\n", raw_cmd->length >> 9);

		pr_info("sectors=%ld\n", current_count_sectors);

	}

	if (raw_cmd->length == 0) {

		DPRINT("zero dma transfer attempted from make_raw_request\n");
@@ -2990,14 +2985,14 @@ static void process_fd_request(void) 
static void do_fd_request(struct request_queue * q)

{

	if (max_buffer_sectors == 0) {

		printk("VFS: do_fd_request called on non-open device\n");

		pr_info("VFS: do_fd_request called on non-open device\n");

		return;

	}



	if (usage_count == 0) {

		printk("warning: usage count=0, current_req=%p exiting\n",

		pr_info("warning: usage count=0, current_req=%p exiting\n",

			current_req);

		printk("sect=%ld type=%x flags=%x\n",

		pr_info("sect=%ld type=%x flags=%x\n",

			(long)blk_rq_pos(current_req), current_req->cmd_type,

			current_req->cmd_flags);

		return;
@@ -3047,7 +3042,7 @@ static int poll_drive(int interruptible, int flag) 


static void reset_intr(void)

{

	printk("weird, reset interrupt called\n");

	pr_info("weird, reset interrupt called\n");

}



static struct cont_t reset_cont = {
@@ -3426,7 +3421,7 @@ static inline int normalize_ioctl(int *cmd, int *size) 
			*size = _IOC_SIZE(*cmd);

			*cmd = ioctl_table[i];

			if (*size > _IOC_SIZE(*cmd)) {

				printk("ioctl not yet supported\n");

				pr_info("ioctl not yet supported\n");

				return -EFAULT;

			}

			return 0;
@@ -3634,7 +3629,7 @@ static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, 


static void __init config_types(void)

{

	int first = 1;

	bool has_drive = false;

	int drive;



	/* read drive info out of physical CMOS */
@@ -3666,17 +3661,22 @@ static void __init config_types(void) 
			name = temparea;

		}

		if (name) {

			const char *prepend = ",";

			if (first) {

				prepend = KERN_INFO "Floppy drive(s):";

				first = 0;

			const char *prepend;

			if (!has_drive) {

				prepend = "";

				has_drive = true;

				pr_info("Floppy drive(s):");

			} else {

				prepend = ",";

			}

			printk("%s fd%d is %s", prepend, drive, name);



			pr_cont("%s fd%d is %s", prepend, drive, name);

		}

		*UDP = *params;

	}

	if (!first)

		printk("\n");



	if (has_drive)

		pr_cont("\n");

}



static int floppy_release(struct gendisk *disk, fmode_t mode)
@@ -3891,7 +3891,7 @@ static int floppy_revalidate(struct gendisk *disk) 
	if (UTESTF(FD_DISK_CHANGED) ||

	    UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {

		if (usage_count == 0) {

			printk("VFS: revalidate called on non-open device.\n");

			pr_info("VFS: revalidate called on non-open device.\n");

			return -EFAULT;

		}

		lock_fdc(drive, 0);
@@ -3948,18 +3948,17 @@ static char __init get_fdc_version(void) 
	if ((r = result()) <= 0x00)

		return FDC_NONE;	/* No FDC present ??? */

	if ((r == 1) && (reply_buffer[0] == 0x80)) {

		printk(KERN_INFO "FDC %d is an 8272A\n", fdc);

		pr_info("FDC %d is an 8272A\n", fdc);

		return FDC_8272A;	/* 8272a/765 don't know DUMPREGS */

	}

	if (r != 10) {

		printk

		    ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",

		pr_info("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",

			fdc, r);

		return FDC_UNKNOWN;

	}



	if (!fdc_configure()) {

		printk(KERN_INFO "FDC %d is an 82072\n", fdc);

		pr_info("FDC %d is an 82072\n", fdc);

		return FDC_82072;	/* 82072 doesn't know CONFIGURE */

	}
@@ -3967,51 +3966,49 @@ static char __init get_fdc_version(void) 
	if (need_more_output() == MORE_OUTPUT) {

		output_byte(0);

	} else {

		printk(KERN_INFO "FDC %d is an 82072A\n", fdc);

		pr_info("FDC %d is an 82072A\n", fdc);

		return FDC_82072A;	/* 82072A as found on Sparcs. */

	}



	output_byte(FD_UNLOCK);

	r = result();

	if ((r == 1) && (reply_buffer[0] == 0x80)) {

		printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);

		pr_info("FDC %d is a pre-1991 82077\n", fdc);

		return FDC_82077_ORIG;	/* Pre-1991 82077, doesn't know 

					 * LOCK/UNLOCK */

	}

	if ((r != 1) || (reply_buffer[0] != 0x00)) {

		printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",

		pr_info("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",

			fdc, r);

		return FDC_UNKNOWN;

	}

	output_byte(FD_PARTID);

	r = result();

	if (r != 1) {

		printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",

		pr_info("FDC %d init: PARTID: unexpected return of %d bytes.\n",

			fdc, r);

		return FDC_UNKNOWN;

	}

	if (reply_buffer[0] == 0x80) {

		printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);

		pr_info("FDC %d is a post-1991 82077\n", fdc);

		return FDC_82077;	/* Revised 82077AA passes all the tests */

	}

	switch (reply_buffer[0] >> 5) {

	case 0x0:

		/* Either a 82078-1 or a 82078SL running at 5Volt */

		printk(KERN_INFO "FDC %d is an 82078.\n", fdc);

		pr_info("FDC %d is an 82078.\n", fdc);

		return FDC_82078;

	case 0x1:

		printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);

		pr_info("FDC %d is a 44pin 82078\n", fdc);

		return FDC_82078;

	case 0x2:

		printk(KERN_INFO "FDC %d is a S82078B\n", fdc);

		pr_info("FDC %d is a S82078B\n", fdc);

		return FDC_S82078B;

	case 0x3:

		printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",

		       fdc);

		pr_info("FDC %d is a National Semiconductor PC87306\n", fdc);

		return FDC_87306;

	default:

		printk(KERN_INFO

		       "FDC %d init: 82078 variant with unknown PARTID=%d.\n",

		pr_info("FDC %d init: 82078 variant with unknown PARTID=%d.\n",

			fdc, reply_buffer[0] >> 5);

		return FDC_82078_UNKN;

	}
@@ -4140,8 +4137,8 @@ static int __init floppy_setup(char *str) 


		DPRINT("allowed options are:");

		for (i = 0; i < ARRAY_SIZE(config_params); i++)

			printk(" %s", config_params[i].name);

		printk("\n");

			pr_cont(" %s", config_params[i].name);

		pr_cont("\n");

	} else

		DPRINT("botched floppy option\n");

	DPRINT("Read Documentation/blockdev/floppy.txt\n");
@@ -4563,15 +4560,15 @@ static void floppy_release_irq_and_dma(void) 
#ifndef __sparc__

	for (drive = 0; drive < N_FDC * 4; drive++)

		if (timer_pending(motor_off_timer + drive))

			printk("motor off timer %d still active\n", drive);

			pr_info("motor off timer %d still active\n", drive);

#endif



	if (timer_pending(&fd_timeout))

		printk("floppy timer still active:%s\n", timeout_message);

		pr_info("floppy timer still active:%s\n", timeout_message);

	if (timer_pending(&fd_timer))

		printk("auxiliary floppy timer still active\n");

		pr_info("auxiliary floppy timer still active\n");

	if (work_pending(&floppy_work))

		printk("work still pending\n");

		pr_info("work still pending\n");

#endif

	old_fdc = fdc;

	for (fdc = 0; fdc < N_FDC; fdc++)