xref: /openbmc/linux/drivers/block/floppy.c (revision 9ac8d3fb)
1 /*
2  *  linux/drivers/block/floppy.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *  Copyright (C) 1993, 1994  Alain Knaff
6  *  Copyright (C) 1998 Alan Cox
7  */
8 
9 /*
10  * 02.12.91 - Changed to static variables to indicate need for reset
11  * and recalibrate. This makes some things easier (output_byte reset
12  * checking etc), and means less interrupt jumping in case of errors,
13  * so the code is hopefully easier to understand.
14  */
15 
16 /*
17  * This file is certainly a mess. I've tried my best to get it working,
18  * but I don't like programming floppies, and I have only one anyway.
19  * Urgel. I should check for more errors, and do more graceful error
20  * recovery. Seems there are problems with several drives. I've tried to
21  * correct them. No promises.
22  */
23 
24 /*
25  * As with hd.c, all routines within this file can (and will) be called
26  * by interrupts, so extreme caution is needed. A hardware interrupt
27  * handler may not sleep, or a kernel panic will happen. Thus I cannot
28  * call "floppy-on" directly, but have to set a special timer interrupt
29  * etc.
30  */
31 
32 /*
33  * 28.02.92 - made track-buffering routines, based on the routines written
34  * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
35  */
36 
37 /*
38  * Automatic floppy-detection and formatting written by Werner Almesberger
39  * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with
40  * the floppy-change signal detection.
41  */
42 
43 /*
44  * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
45  * FDC data overrun bug, added some preliminary stuff for vertical
46  * recording support.
47  *
48  * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
49  *
50  * TODO: Errors are still not counted properly.
51  */
52 
53 /* 1992/9/20
54  * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl)
55  * modeled after the freeware MS-DOS program fdformat/88 V1.8 by
56  * Christoph H. Hochst\"atter.
57  * I have fixed the shift values to the ones I always use. Maybe a new
58  * ioctl() should be created to be able to modify them.
59  * There is a bug in the driver that makes it impossible to format a
60  * floppy as the first thing after bootup.
61  */
62 
63 /*
64  * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
65  * this helped the floppy driver as well. Much cleaner, and still seems to
66  * work.
67  */
68 
69 /* 1994/6/24 --bbroad-- added the floppy table entries and made
70  * minor modifications to allow 2.88 floppies to be run.
71  */
72 
73 /* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
74  * disk types.
75  */
76 
77 /*
78  * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
79  * format bug fixes, but unfortunately some new bugs too...
80  */
81 
82 /* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
83  * errors to allow safe writing by specialized programs.
84  */
85 
86 /* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
87  * by defining bit 1 of the "stretch" parameter to mean put sectors on the
88  * opposite side of the disk, leaving the sector IDs alone (i.e. Commodore's
89  * drives are "upside-down").
90  */
91 
92 /*
93  * 1995/8/26 -- Andreas Busse -- added Mips support.
94  */
95 
96 /*
97  * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
98  * features to asm/floppy.h.
99  */
100 
101 /*
102  * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
103  */
104 
105 /*
106  * 1998/05/07 -- Russell King -- More portability cleanups; moved definition of
107  * interrupt and dma channel to asm/floppy.h. Cleaned up some formatting &
108  * use of '0' for NULL.
109  */
110 
111 /*
112  * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
113  * failures.
114  */
115 
116 /*
117  * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
118  */
119 
120 /*
121  * 1999/08/13 -- Paul Slootman -- floppy stopped working on Alpha after 24
122  * days, 6 hours, 32 minutes and 32 seconds (i.e. MAXINT jiffies; ints were
123  * being used to store jiffies, which are unsigned longs).
124  */
125 
126 /*
127  * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
128  * - get rid of check_region
129  * - s/suser/capable/
130  */
131 
132 /*
133  * 2001/08/26 -- Paul Gortmaker - fix insmod oops on machines with no
134  * floppy controller (lingering task on list after module is gone... boom.)
135  */
136 
137 /*
138  * 2002/02/07 -- Anton Altaparmakov - Fix io ports reservation to correct range
139  * (0x3f2-0x3f5, 0x3f7). This fix is a bit of a hack but the proper fix
140  * requires many non-obvious changes in arch dependent code.
141  */
142 
143 /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
144  * Better audit of register_blkdev.
145  */
146 
147 #define FLOPPY_SANITY_CHECK
148 #undef  FLOPPY_SILENT_DCL_CLEAR
149 
150 #define REALLY_SLOW_IO
151 
152 #define DEBUGT 2
153 #define DCL_DEBUG	/* debug disk change line */
154 
155 /* do print messages for unexpected interrupts */
156 static int print_unex = 1;
157 #include <linux/module.h>
158 #include <linux/sched.h>
159 #include <linux/fs.h>
160 #include <linux/kernel.h>
161 #include <linux/timer.h>
162 #include <linux/workqueue.h>
163 #define FDPATCHES
164 #include <linux/fdreg.h>
165 #include <linux/fd.h>
166 #include <linux/hdreg.h>
167 #include <linux/errno.h>
168 #include <linux/slab.h>
169 #include <linux/mm.h>
170 #include <linux/bio.h>
171 #include <linux/string.h>
172 #include <linux/jiffies.h>
173 #include <linux/fcntl.h>
174 #include <linux/delay.h>
175 #include <linux/mc146818rtc.h>	/* CMOS defines */
176 #include <linux/ioport.h>
177 #include <linux/interrupt.h>
178 #include <linux/init.h>
179 #include <linux/platform_device.h>
180 #include <linux/buffer_head.h>	/* for invalidate_buffers() */
181 #include <linux/mutex.h>
182 
183 /*
184  * PS/2 floppies have much slower step rates than regular floppies.
185  * It's been recommended that take about 1/4 of the default speed
186  * in some more extreme cases.
187  */
188 static int slow_floppy;
189 
190 #include <asm/dma.h>
191 #include <asm/irq.h>
192 #include <asm/system.h>
193 #include <asm/io.h>
194 #include <asm/uaccess.h>
195 
196 static int FLOPPY_IRQ = 6;
197 static int FLOPPY_DMA = 2;
198 static int can_use_virtual_dma = 2;
199 /* =======
200  * can use virtual DMA:
201  * 0 = use of virtual DMA disallowed by config
202  * 1 = use of virtual DMA prescribed by config
203  * 2 = no virtual DMA preference configured.  By default try hard DMA,
204  * but fall back on virtual DMA when not enough memory available
205  */
206 
207 static int use_virtual_dma;
208 /* =======
209  * use virtual DMA
210  * 0 using hard DMA
211  * 1 using virtual DMA
212  * This variable is set to virtual when a DMA mem problem arises, and
213  * reset back in floppy_grab_irq_and_dma.
214  * It is not safe to reset it in other circumstances, because the floppy
215  * driver may have several buffers in use at once, and we do currently not
216  * record each buffers capabilities
217  */
218 
219 static DEFINE_SPINLOCK(floppy_lock);
220 
221 static unsigned short virtual_dma_port = 0x3f0;
222 irqreturn_t floppy_interrupt(int irq, void *dev_id);
223 static int set_dor(int fdc, char mask, char data);
224 
225 #define K_64	0x10000		/* 64KB */
226 
227 /* the following is the mask of allowed drives. By default units 2 and
228  * 3 of both floppy controllers are disabled, because switching on the
229  * motor of these drives causes system hangs on some PCI computers. drive
230  * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
231  * a drive is allowed.
232  *
233  * NOTE: This must come before we include the arch floppy header because
234  *       some ports reference this variable from there. -DaveM
235  */
236 
237 static int allowed_drive_mask = 0x33;
238 
239 #include <asm/floppy.h>
240 
241 static int irqdma_allocated;
242 
243 #define DEVICE_NAME "floppy"
244 
245 #include <linux/blkdev.h>
246 #include <linux/blkpg.h>
247 #include <linux/cdrom.h>	/* for the compatibility eject ioctl */
248 #include <linux/completion.h>
249 
250 static struct request *current_req;
251 static struct request_queue *floppy_queue;
252 static void do_fd_request(struct request_queue * q);
253 
254 #ifndef fd_get_dma_residue
255 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
256 #endif
257 
258 /* Dma Memory related stuff */
259 
260 #ifndef fd_dma_mem_free
261 #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
262 #endif
263 
264 #ifndef fd_dma_mem_alloc
265 #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
266 #endif
267 
268 static inline void fallback_on_nodma_alloc(char **addr, size_t l)
269 {
270 #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
271 	if (*addr)
272 		return;		/* we have the memory */
273 	if (can_use_virtual_dma != 2)
274 		return;		/* no fallback allowed */
275 	printk("DMA memory shortage. Temporarily falling back on virtual DMA\n");
276 	*addr = (char *)nodma_mem_alloc(l);
277 #else
278 	return;
279 #endif
280 }
281 
282 /* End dma memory related stuff */
283 
284 static unsigned long fake_change;
285 static int initialising = 1;
286 
287 #define ITYPE(x) (((x)>>2) & 0x1f)
288 #define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
289 #define UNIT(x) ((x) & 0x03)	/* drive on fdc */
290 #define FDC(x) (((x) & 0x04) >> 2)	/* fdc of drive */
291 	/* reverse mapping from unit and fdc to drive */
292 #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
293 #define DP (&drive_params[current_drive])
294 #define DRS (&drive_state[current_drive])
295 #define DRWE (&write_errors[current_drive])
296 #define FDCS (&fdc_state[fdc])
297 #define CLEARF(x) clear_bit(x##_BIT, &DRS->flags)
298 #define SETF(x) set_bit(x##_BIT, &DRS->flags)
299 #define TESTF(x) test_bit(x##_BIT, &DRS->flags)
300 
301 #define UDP (&drive_params[drive])
302 #define UDRS (&drive_state[drive])
303 #define UDRWE (&write_errors[drive])
304 #define UFDCS (&fdc_state[FDC(drive)])
305 #define UCLEARF(x) clear_bit(x##_BIT, &UDRS->flags)
306 #define USETF(x) set_bit(x##_BIT, &UDRS->flags)
307 #define UTESTF(x) test_bit(x##_BIT, &UDRS->flags)
308 
309 #define DPRINT(format, args...) printk(DEVICE_NAME "%d: " format, current_drive , ## args)
310 
311 #define PH_HEAD(floppy,head) (((((floppy)->stretch & 2) >>1) ^ head) << 2)
312 #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
313 
314 #define CLEARSTRUCT(x) memset((x), 0, sizeof(*(x)))
315 
316 /* read/write */
317 #define COMMAND raw_cmd->cmd[0]
318 #define DR_SELECT raw_cmd->cmd[1]
319 #define TRACK raw_cmd->cmd[2]
320 #define HEAD raw_cmd->cmd[3]
321 #define SECTOR raw_cmd->cmd[4]
322 #define SIZECODE raw_cmd->cmd[5]
323 #define SECT_PER_TRACK raw_cmd->cmd[6]
324 #define GAP raw_cmd->cmd[7]
325 #define SIZECODE2 raw_cmd->cmd[8]
326 #define NR_RW 9
327 
328 /* format */
329 #define F_SIZECODE raw_cmd->cmd[2]
330 #define F_SECT_PER_TRACK raw_cmd->cmd[3]
331 #define F_GAP raw_cmd->cmd[4]
332 #define F_FILL raw_cmd->cmd[5]
333 #define NR_F 6
334 
335 /*
336  * Maximum disk size (in kilobytes). This default is used whenever the
337  * current disk size is unknown.
338  * [Now it is rather a minimum]
339  */
340 #define MAX_DISK_SIZE 4		/* 3984 */
341 
342 /*
343  * globals used by 'result()'
344  */
345 #define MAX_REPLIES 16
346 static unsigned char reply_buffer[MAX_REPLIES];
347 static int inr;			/* size of reply buffer, when called from interrupt */
348 #define ST0 (reply_buffer[0])
349 #define ST1 (reply_buffer[1])
350 #define ST2 (reply_buffer[2])
351 #define ST3 (reply_buffer[0])	/* result of GETSTATUS */
352 #define R_TRACK (reply_buffer[3])
353 #define R_HEAD (reply_buffer[4])
354 #define R_SECTOR (reply_buffer[5])
355 #define R_SIZECODE (reply_buffer[6])
356 #define SEL_DLY (2*HZ/100)
357 
358 /*
359  * this struct defines the different floppy drive types.
360  */
361 static struct {
362 	struct floppy_drive_params params;
363 	const char *name;	/* name printed while booting */
364 } default_drive_params[] = {
365 /* NOTE: the time values in jiffies should be in msec!
366  CMOS drive type
367   |     Maximum data rate supported by drive type
368   |     |   Head load time, msec
369   |     |   |   Head unload time, msec (not used)
370   |     |   |   |     Step rate interval, usec
371   |     |   |   |     |       Time needed for spinup time (jiffies)
372   |     |   |   |     |       |      Timeout for spinning down (jiffies)
373   |     |   |   |     |       |      |   Spindown offset (where disk stops)
374   |     |   |   |     |       |      |   |     Select delay
375   |     |   |   |     |       |      |   |     |     RPS
376   |     |   |   |     |       |      |   |     |     |    Max number of tracks
377   |     |   |   |     |       |      |   |     |     |    |     Interrupt timeout
378   |     |   |   |     |       |      |   |     |     |    |     |   Max nonintlv. sectors
379   |     |   |   |     |       |      |   |     |     |    |     |   | -Max Errors- flags */
380 {{0,  500, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  80, 3*HZ, 20, {3,1,2,0,2}, 0,
381       0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
382 
383 {{1,  300, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  40, 3*HZ, 17, {3,1,2,0,2}, 0,
384       0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
385 
386 {{2,  500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6,  83, 3*HZ, 17, {3,1,2,0,2}, 0,
387       0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
388 
389 {{3,  250, 16, 16, 3000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
390       0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
391 
392 {{4,  500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
393       0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
394 
395 {{5, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
396       0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
397 
398 {{6, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
399       0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
400 /*    |  --autodetected formats---    |      |      |
401  *    read_track                      |      |    Name printed when booting
402  *				      |     Native format
403  *	            Frequency of disk change checks */
404 };
405 
406 static struct floppy_drive_params drive_params[N_DRIVE];
407 static struct floppy_drive_struct drive_state[N_DRIVE];
408 static struct floppy_write_errors write_errors[N_DRIVE];
409 static struct timer_list motor_off_timer[N_DRIVE];
410 static struct gendisk *disks[N_DRIVE];
411 static struct block_device *opened_bdev[N_DRIVE];
412 static DEFINE_MUTEX(open_lock);
413 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
414 
415 /*
416  * This struct defines the different floppy types.
417  *
418  * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
419  * types (e.g. 360kB diskette in 1.2MB drive, etc.).  Bit 1 of 'stretch'
420  * tells if the disk is in Commodore 1581 format, which means side 0 sectors
421  * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
422  * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
423  * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
424  * side 0 is on physical side 0 (but with the misnamed sector IDs).
425  * 'stretch' should probably be renamed to something more general, like
426  * 'options'.
427  *
428  * Bits 2 through 9 of 'stretch' tell the number of the first sector.
429  * The LSB (bit 2) is flipped. For most disks, the first sector
430  * is 1 (represented by 0x00<<2).  For some CP/M and music sampler
431  * disks (such as Ensoniq EPS 16plus) it is 0 (represented as 0x01<<2).
432  * For Amstrad CPC disks it is 0xC1 (represented as 0xC0<<2).
433  *
434  * Other parameters should be self-explanatory (see also setfdprm(8)).
435  */
436 /*
437 	    Size
438 	     |  Sectors per track
439 	     |  | Head
440 	     |  | |  Tracks
441 	     |  | |  | Stretch
442 	     |  | |  | |  Gap 1 size
443 	     |  | |  | |    |  Data rate, | 0x40 for perp
444 	     |  | |  | |    |    |  Spec1 (stepping rate, head unload
445 	     |  | |  | |    |    |    |    /fmt gap (gap2) */
446 static struct floppy_struct floppy_type[32] = {
447 	{    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL    },	/*  0 no testing    */
448 	{  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360"  }, /*  1 360KB PC      */
449 	{ 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" },	/*  2 1.2MB AT      */
450 	{  720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360"  },	/*  3 360KB SS 3.5" */
451 	{ 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720"  },	/*  4 720KB 3.5"    */
452 	{  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360"  },	/*  5 360KB AT      */
453 	{ 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720"  },	/*  6 720KB AT      */
454 	{ 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" },	/*  7 1.44MB 3.5"   */
455 	{ 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" },	/*  8 2.88MB 3.5"   */
456 	{ 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" },	/*  9 3.12MB 3.5"   */
457 
458 	{ 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25"  */
459 	{ 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5"   */
460 	{  820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410"  },	/* 12 410KB 5.25"   */
461 	{ 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820"  },	/* 13 820KB 3.5"    */
462 	{ 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" },	/* 14 1.48MB 5.25"  */
463 	{ 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" },	/* 15 1.72MB 3.5"   */
464 	{  840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420"  },	/* 16 420KB 5.25"   */
465 	{ 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830"  },	/* 17 830KB 3.5"    */
466 	{ 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" },	/* 18 1.49MB 5.25"  */
467 	{ 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5"  */
468 
469 	{ 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880"  }, /* 20 880KB 5.25"   */
470 	{ 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5"   */
471 	{ 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5"   */
472 	{ 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25"   */
473 	{ 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5"   */
474 	{ 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5"   */
475 	{ 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5"   */
476 	{ 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5"   */
477 	{ 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5"   */
478 	{ 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5"   */
479 
480 	{ 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800"  },	/* 30 800KB 3.5"    */
481 	{ 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5"    */
482 };
483 
484 #define SECTSIZE (_FD_SECTSIZE(*floppy))
485 
486 /* Auto-detection: Disk type used until the next media change occurs. */
487 static struct floppy_struct *current_type[N_DRIVE];
488 
489 /*
490  * User-provided type information. current_type points to
491  * the respective entry of this array.
492  */
493 static struct floppy_struct user_params[N_DRIVE];
494 
495 static sector_t floppy_sizes[256];
496 
497 static char floppy_device_name[] = "floppy";
498 
499 /*
500  * The driver is trying to determine the correct media format
501  * while probing is set. rw_interrupt() clears it after a
502  * successful access.
503  */
504 static int probing;
505 
506 /* Synchronization of FDC access. */
507 #define FD_COMMAND_NONE -1
508 #define FD_COMMAND_ERROR 2
509 #define FD_COMMAND_OKAY 3
510 
511 static volatile int command_status = FD_COMMAND_NONE;
512 static unsigned long fdc_busy;
513 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
514 static DECLARE_WAIT_QUEUE_HEAD(command_done);
515 
516 #define NO_SIGNAL (!interruptible || !signal_pending(current))
517 #define CALL(x) if ((x) == -EINTR) return -EINTR
518 #define ECALL(x) if ((ret = (x))) return ret;
519 #define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
520 #define WAIT(x) _WAIT((x),interruptible)
521 #define IWAIT(x) _WAIT((x),1)
522 
523 /* Errors during formatting are counted here. */
524 static int format_errors;
525 
526 /* Format request descriptor. */
527 static struct format_descr format_req;
528 
529 /*
530  * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
531  * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
532  * H is head unload time (1=16ms, 2=32ms, etc)
533  */
534 
535 /*
536  * Track buffer
537  * Because these are written to by the DMA controller, they must
538  * not contain a 64k byte boundary crossing, or data will be
539  * corrupted/lost.
540  */
541 static char *floppy_track_buffer;
542 static int max_buffer_sectors;
543 
544 static int *errors;
545 typedef void (*done_f)(int);
546 static struct cont_t {
547 	void (*interrupt)(void);	/* this is called after the interrupt of the
548 					 * main command */
549 	void (*redo)(void);	/* this is called to retry the operation */
550 	void (*error)(void);	/* this is called to tally an error */
551 	done_f done;		/* this is called to say if the operation has
552 				 * succeeded/failed */
553 } *cont;
554 
555 static void floppy_ready(void);
556 static void floppy_start(void);
557 static void process_fd_request(void);
558 static void recalibrate_floppy(void);
559 static void floppy_shutdown(unsigned long);
560 
561 static int floppy_grab_irq_and_dma(void);
562 static void floppy_release_irq_and_dma(void);
563 
564 /*
565  * The "reset" variable should be tested whenever an interrupt is scheduled,
566  * after the commands have been sent. This is to ensure that the driver doesn't
567  * get wedged when the interrupt doesn't come because of a failed command.
568  * reset doesn't need to be tested before sending commands, because
569  * output_byte is automatically disabled when reset is set.
570  */
571 #define CHECK_RESET { if (FDCS->reset){ reset_fdc(); return; } }
572 static void reset_fdc(void);
573 
574 /*
575  * These are global variables, as that's the easiest way to give
576  * information to interrupts. They are the data used for the current
577  * request.
578  */
579 #define NO_TRACK -1
580 #define NEED_1_RECAL -2
581 #define NEED_2_RECAL -3
582 
583 static int usage_count;
584 
585 /* buffer related variables */
586 static int buffer_track = -1;
587 static int buffer_drive = -1;
588 static int buffer_min = -1;
589 static int buffer_max = -1;
590 
591 /* fdc related variables, should end up in a struct */
592 static struct floppy_fdc_state fdc_state[N_FDC];
593 static int fdc;			/* current fdc */
594 
595 static struct floppy_struct *_floppy = floppy_type;
596 static unsigned char current_drive;
597 static long current_count_sectors;
598 static unsigned char fsector_t;	/* sector in track */
599 static unsigned char in_sector_offset;	/* offset within physical sector,
600 					 * expressed in units of 512 bytes */
601 
602 #ifndef fd_eject
603 static inline int fd_eject(int drive)
604 {
605 	return -EINVAL;
606 }
607 #endif
608 
609 /*
610  * Debugging
611  * =========
612  */
613 #ifdef DEBUGT
614 static long unsigned debugtimer;
615 
616 static inline void set_debugt(void)
617 {
618 	debugtimer = jiffies;
619 }
620 
621 static inline void debugt(const char *message)
622 {
623 	if (DP->flags & DEBUGT)
624 		printk("%s dtime=%lu\n", message, jiffies - debugtimer);
625 }
626 #else
627 static inline void set_debugt(void) { }
628 static inline void debugt(const char *message) { }
629 #endif /* DEBUGT */
630 
631 typedef void (*timeout_fn) (unsigned long);
632 static DEFINE_TIMER(fd_timeout, floppy_shutdown, 0, 0);
633 
634 static const char *timeout_message;
635 
636 #ifdef FLOPPY_SANITY_CHECK
637 static void is_alive(const char *message)
638 {
639 	/* this routine checks whether the floppy driver is "alive" */
640 	if (test_bit(0, &fdc_busy) && command_status < 2
641 	    && !timer_pending(&fd_timeout)) {
642 		DPRINT("timeout handler died: %s\n", message);
643 	}
644 }
645 #endif
646 
647 static void (*do_floppy) (void) = NULL;
648 
649 #ifdef FLOPPY_SANITY_CHECK
650 
651 #define OLOGSIZE 20
652 
653 static void (*lasthandler) (void);
654 static unsigned long interruptjiffies;
655 static unsigned long resultjiffies;
656 static int resultsize;
657 static unsigned long lastredo;
658 
659 static struct output_log {
660 	unsigned char data;
661 	unsigned char status;
662 	unsigned long jiffies;
663 } output_log[OLOGSIZE];
664 
665 static int output_log_pos;
666 #endif
667 
668 #define current_reqD -1
669 #define MAXTIMEOUT -2
670 
671 static void __reschedule_timeout(int drive, const char *message, int marg)
672 {
673 	if (drive == current_reqD)
674 		drive = current_drive;
675 	del_timer(&fd_timeout);
676 	if (drive < 0 || drive >= N_DRIVE) {
677 		fd_timeout.expires = jiffies + 20UL * HZ;
678 		drive = 0;
679 	} else
680 		fd_timeout.expires = jiffies + UDP->timeout;
681 	add_timer(&fd_timeout);
682 	if (UDP->flags & FD_DEBUG) {
683 		DPRINT("reschedule timeout ");
684 		printk(message, marg);
685 		printk("\n");
686 	}
687 	timeout_message = message;
688 }
689 
690 static void reschedule_timeout(int drive, const char *message, int marg)
691 {
692 	unsigned long flags;
693 
694 	spin_lock_irqsave(&floppy_lock, flags);
695 	__reschedule_timeout(drive, message, marg);
696 	spin_unlock_irqrestore(&floppy_lock, flags);
697 }
698 
699 #define INFBOUND(a,b) (a)=max_t(int, a, b)
700 #define SUPBOUND(a,b) (a)=min_t(int, a, b)
701 
702 /*
703  * Bottom half floppy driver.
704  * ==========================
705  *
706  * This part of the file contains the code talking directly to the hardware,
707  * and also the main service loop (seek-configure-spinup-command)
708  */
709 
710 /*
711  * disk change.
712  * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
713  * and the last_checked date.
714  *
715  * last_checked is the date of the last check which showed 'no disk change'
716  * FD_DISK_CHANGE is set under two conditions:
717  * 1. The floppy has been changed after some i/o to that floppy already
718  *    took place.
719  * 2. No floppy disk is in the drive. This is done in order to ensure that
720  *    requests are quickly flushed in case there is no disk in the drive. It
721  *    follows that FD_DISK_CHANGE can only be cleared if there is a disk in
722  *    the drive.
723  *
724  * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
725  * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
726  *  each seek. If a disk is present, the disk change line should also be
727  *  cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
728  *  change line is set, this means either that no disk is in the drive, or
729  *  that it has been removed since the last seek.
730  *
731  * This means that we really have a third possibility too:
732  *  The floppy has been changed after the last seek.
733  */
734 
735 static int disk_change(int drive)
736 {
737 	int fdc = FDC(drive);
738 
739 #ifdef FLOPPY_SANITY_CHECK
740 	if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
741 		DPRINT("WARNING disk change called early\n");
742 	if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
743 	    (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
744 		DPRINT("probing disk change on unselected drive\n");
745 		DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
746 		       (unsigned int)FDCS->dor);
747 	}
748 #endif
749 
750 #ifdef DCL_DEBUG
751 	if (UDP->flags & FD_DEBUG) {
752 		DPRINT("checking disk change line for drive %d\n", drive);
753 		DPRINT("jiffies=%lu\n", jiffies);
754 		DPRINT("disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
755 		DPRINT("flags=%lx\n", UDRS->flags);
756 	}
757 #endif
758 	if (UDP->flags & FD_BROKEN_DCL)
759 		return UTESTF(FD_DISK_CHANGED);
760 	if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
761 		USETF(FD_VERIFY);	/* verify write protection */
762 		if (UDRS->maxblock) {
763 			/* mark it changed */
764 			USETF(FD_DISK_CHANGED);
765 		}
766 
767 		/* invalidate its geometry */
768 		if (UDRS->keep_data >= 0) {
769 			if ((UDP->flags & FTD_MSG) &&
770 			    current_type[drive] != NULL)
771 				DPRINT("Disk type is undefined after "
772 				       "disk change\n");
773 			current_type[drive] = NULL;
774 			floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
775 		}
776 
777 		return 1;
778 	} else {
779 		UDRS->last_checked = jiffies;
780 		UCLEARF(FD_DISK_NEWCHANGE);
781 	}
782 	return 0;
783 }
784 
785 static inline int is_selected(int dor, int unit)
786 {
787 	return ((dor & (0x10 << unit)) && (dor & 3) == unit);
788 }
789 
790 static int set_dor(int fdc, char mask, char data)
791 {
792 	unsigned char unit;
793 	unsigned char drive;
794 	unsigned char newdor;
795 	unsigned char olddor;
796 
797 	if (FDCS->address == -1)
798 		return -1;
799 
800 	olddor = FDCS->dor;
801 	newdor = (olddor & mask) | data;
802 	if (newdor != olddor) {
803 		unit = olddor & 0x3;
804 		if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
805 			drive = REVDRIVE(fdc, unit);
806 #ifdef DCL_DEBUG
807 			if (UDP->flags & FD_DEBUG) {
808 				DPRINT("calling disk change from set_dor\n");
809 			}
810 #endif
811 			disk_change(drive);
812 		}
813 		FDCS->dor = newdor;
814 		fd_outb(newdor, FD_DOR);
815 
816 		unit = newdor & 0x3;
817 		if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
818 			drive = REVDRIVE(fdc, unit);
819 			UDRS->select_date = jiffies;
820 		}
821 	}
822 	return olddor;
823 }
824 
825 static void twaddle(void)
826 {
827 	if (DP->select_delay)
828 		return;
829 	fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
830 	fd_outb(FDCS->dor, FD_DOR);
831 	DRS->select_date = jiffies;
832 }
833 
834 /* reset all driver information about the current fdc. This is needed after
835  * a reset, and after a raw command. */
836 static void reset_fdc_info(int mode)
837 {
838 	int drive;
839 
840 	FDCS->spec1 = FDCS->spec2 = -1;
841 	FDCS->need_configure = 1;
842 	FDCS->perp_mode = 1;
843 	FDCS->rawcmd = 0;
844 	for (drive = 0; drive < N_DRIVE; drive++)
845 		if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
846 			UDRS->track = NEED_2_RECAL;
847 }
848 
849 /* selects the fdc and drive, and enables the fdc's input/dma. */
850 static void set_fdc(int drive)
851 {
852 	if (drive >= 0 && drive < N_DRIVE) {
853 		fdc = FDC(drive);
854 		current_drive = drive;
855 	}
856 	if (fdc != 1 && fdc != 0) {
857 		printk("bad fdc value\n");
858 		return;
859 	}
860 	set_dor(fdc, ~0, 8);
861 #if N_FDC > 1
862 	set_dor(1 - fdc, ~8, 0);
863 #endif
864 	if (FDCS->rawcmd == 2)
865 		reset_fdc_info(1);
866 	if (fd_inb(FD_STATUS) != STATUS_READY)
867 		FDCS->reset = 1;
868 }
869 
870 /* locks the driver */
871 static int _lock_fdc(int drive, int interruptible, int line)
872 {
873 	if (!usage_count) {
874 		printk(KERN_ERR
875 		       "Trying to lock fdc while usage count=0 at line %d\n",
876 		       line);
877 		return -1;
878 	}
879 
880 	if (test_and_set_bit(0, &fdc_busy)) {
881 		DECLARE_WAITQUEUE(wait, current);
882 		add_wait_queue(&fdc_wait, &wait);
883 
884 		for (;;) {
885 			set_current_state(TASK_INTERRUPTIBLE);
886 
887 			if (!test_and_set_bit(0, &fdc_busy))
888 				break;
889 
890 			schedule();
891 
892 			if (!NO_SIGNAL) {
893 				remove_wait_queue(&fdc_wait, &wait);
894 				return -EINTR;
895 			}
896 		}
897 
898 		set_current_state(TASK_RUNNING);
899 		remove_wait_queue(&fdc_wait, &wait);
900 		flush_scheduled_work();
901 	}
902 	command_status = FD_COMMAND_NONE;
903 
904 	__reschedule_timeout(drive, "lock fdc", 0);
905 	set_fdc(drive);
906 	return 0;
907 }
908 
909 #define lock_fdc(drive,interruptible) _lock_fdc(drive,interruptible, __LINE__)
910 
911 #define LOCK_FDC(drive,interruptible) \
912 if (lock_fdc(drive,interruptible)) return -EINTR;
913 
914 /* unlocks the driver */
915 static inline void unlock_fdc(void)
916 {
917 	unsigned long flags;
918 
919 	raw_cmd = NULL;
920 	if (!test_bit(0, &fdc_busy))
921 		DPRINT("FDC access conflict!\n");
922 
923 	if (do_floppy)
924 		DPRINT("device interrupt still active at FDC release: %p!\n",
925 		       do_floppy);
926 	command_status = FD_COMMAND_NONE;
927 	spin_lock_irqsave(&floppy_lock, flags);
928 	del_timer(&fd_timeout);
929 	cont = NULL;
930 	clear_bit(0, &fdc_busy);
931 	if (elv_next_request(floppy_queue))
932 		do_fd_request(floppy_queue);
933 	spin_unlock_irqrestore(&floppy_lock, flags);
934 	wake_up(&fdc_wait);
935 }
936 
937 /* switches the motor off after a given timeout */
938 static void motor_off_callback(unsigned long nr)
939 {
940 	unsigned char mask = ~(0x10 << UNIT(nr));
941 
942 	set_dor(FDC(nr), mask, 0);
943 }
944 
945 /* schedules motor off */
946 static void floppy_off(unsigned int drive)
947 {
948 	unsigned long volatile delta;
949 	int fdc = FDC(drive);
950 
951 	if (!(FDCS->dor & (0x10 << UNIT(drive))))
952 		return;
953 
954 	del_timer(motor_off_timer + drive);
955 
956 	/* make spindle stop in a position which minimizes spinup time
957 	 * next time */
958 	if (UDP->rps) {
959 		delta = jiffies - UDRS->first_read_date + HZ -
960 		    UDP->spindown_offset;
961 		delta = ((delta * UDP->rps) % HZ) / UDP->rps;
962 		motor_off_timer[drive].expires =
963 		    jiffies + UDP->spindown - delta;
964 	}
965 	add_timer(motor_off_timer + drive);
966 }
967 
968 /*
969  * cycle through all N_DRIVE floppy drives, for disk change testing.
970  * stopping at current drive. This is done before any long operation, to
971  * be sure to have up to date disk change information.
972  */
973 static void scandrives(void)
974 {
975 	int i;
976 	int drive;
977 	int saved_drive;
978 
979 	if (DP->select_delay)
980 		return;
981 
982 	saved_drive = current_drive;
983 	for (i = 0; i < N_DRIVE; i++) {
984 		drive = (saved_drive + i + 1) % N_DRIVE;
985 		if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
986 			continue;	/* skip closed drives */
987 		set_fdc(drive);
988 		if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
989 		      (0x10 << UNIT(drive))))
990 			/* switch the motor off again, if it was off to
991 			 * begin with */
992 			set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
993 	}
994 	set_fdc(saved_drive);
995 }
996 
997 static void empty(void)
998 {
999 }
1000 
1001 static DECLARE_WORK(floppy_work, NULL);
1002 
1003 static void schedule_bh(void (*handler) (void))
1004 {
1005 	PREPARE_WORK(&floppy_work, (work_func_t)handler);
1006 	schedule_work(&floppy_work);
1007 }
1008 
1009 static DEFINE_TIMER(fd_timer, NULL, 0, 0);
1010 
1011 static void cancel_activity(void)
1012 {
1013 	unsigned long flags;
1014 
1015 	spin_lock_irqsave(&floppy_lock, flags);
1016 	do_floppy = NULL;
1017 	PREPARE_WORK(&floppy_work, (work_func_t)empty);
1018 	del_timer(&fd_timer);
1019 	spin_unlock_irqrestore(&floppy_lock, flags);
1020 }
1021 
1022 /* this function makes sure that the disk stays in the drive during the
1023  * transfer */
1024 static void fd_watchdog(void)
1025 {
1026 #ifdef DCL_DEBUG
1027 	if (DP->flags & FD_DEBUG) {
1028 		DPRINT("calling disk change from watchdog\n");
1029 	}
1030 #endif
1031 
1032 	if (disk_change(current_drive)) {
1033 		DPRINT("disk removed during i/o\n");
1034 		cancel_activity();
1035 		cont->done(0);
1036 		reset_fdc();
1037 	} else {
1038 		del_timer(&fd_timer);
1039 		fd_timer.function = (timeout_fn) fd_watchdog;
1040 		fd_timer.expires = jiffies + HZ / 10;
1041 		add_timer(&fd_timer);
1042 	}
1043 }
1044 
1045 static void main_command_interrupt(void)
1046 {
1047 	del_timer(&fd_timer);
1048 	cont->interrupt();
1049 }
1050 
1051 /* waits for a delay (spinup or select) to pass */
1052 static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
1053 {
1054 	if (FDCS->reset) {
1055 		reset_fdc();	/* do the reset during sleep to win time
1056 				 * if we don't need to sleep, it's a good
1057 				 * occasion anyways */
1058 		return 1;
1059 	}
1060 
1061 	if (time_before(jiffies, delay)) {
1062 		del_timer(&fd_timer);
1063 		fd_timer.function = function;
1064 		fd_timer.expires = delay;
1065 		add_timer(&fd_timer);
1066 		return 1;
1067 	}
1068 	return 0;
1069 }
1070 
1071 static DEFINE_SPINLOCK(floppy_hlt_lock);
1072 static int hlt_disabled;
1073 static void floppy_disable_hlt(void)
1074 {
1075 	unsigned long flags;
1076 
1077 	spin_lock_irqsave(&floppy_hlt_lock, flags);
1078 	if (!hlt_disabled) {
1079 		hlt_disabled = 1;
1080 #ifdef HAVE_DISABLE_HLT
1081 		disable_hlt();
1082 #endif
1083 	}
1084 	spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1085 }
1086 
1087 static void floppy_enable_hlt(void)
1088 {
1089 	unsigned long flags;
1090 
1091 	spin_lock_irqsave(&floppy_hlt_lock, flags);
1092 	if (hlt_disabled) {
1093 		hlt_disabled = 0;
1094 #ifdef HAVE_DISABLE_HLT
1095 		enable_hlt();
1096 #endif
1097 	}
1098 	spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1099 }
1100 
1101 static void setup_DMA(void)
1102 {
1103 	unsigned long f;
1104 
1105 #ifdef FLOPPY_SANITY_CHECK
1106 	if (raw_cmd->length == 0) {
1107 		int i;
1108 
1109 		printk("zero dma transfer size:");
1110 		for (i = 0; i < raw_cmd->cmd_count; i++)
1111 			printk("%x,", raw_cmd->cmd[i]);
1112 		printk("\n");
1113 		cont->done(0);
1114 		FDCS->reset = 1;
1115 		return;
1116 	}
1117 	if (((unsigned long)raw_cmd->kernel_data) % 512) {
1118 		printk("non aligned address: %p\n", raw_cmd->kernel_data);
1119 		cont->done(0);
1120 		FDCS->reset = 1;
1121 		return;
1122 	}
1123 #endif
1124 	f = claim_dma_lock();
1125 	fd_disable_dma();
1126 #ifdef fd_dma_setup
1127 	if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1128 			 (raw_cmd->flags & FD_RAW_READ) ?
1129 			 DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
1130 		release_dma_lock(f);
1131 		cont->done(0);
1132 		FDCS->reset = 1;
1133 		return;
1134 	}
1135 	release_dma_lock(f);
1136 #else
1137 	fd_clear_dma_ff();
1138 	fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1139 	fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
1140 			DMA_MODE_READ : DMA_MODE_WRITE);
1141 	fd_set_dma_addr(raw_cmd->kernel_data);
1142 	fd_set_dma_count(raw_cmd->length);
1143 	virtual_dma_port = FDCS->address;
1144 	fd_enable_dma();
1145 	release_dma_lock(f);
1146 #endif
1147 	floppy_disable_hlt();
1148 }
1149 
1150 static void show_floppy(void);
1151 
1152 /* waits until the fdc becomes ready */
1153 static int wait_til_ready(void)
1154 {
1155 	int status;
1156 	int counter;
1157 
1158 	if (FDCS->reset)
1159 		return -1;
1160 	for (counter = 0; counter < 10000; counter++) {
1161 		status = fd_inb(FD_STATUS);
1162 		if (status & STATUS_READY)
1163 			return status;
1164 	}
1165 	if (!initialising) {
1166 		DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
1167 		show_floppy();
1168 	}
1169 	FDCS->reset = 1;
1170 	return -1;
1171 }
1172 
1173 /* sends a command byte to the fdc */
1174 static int output_byte(char byte)
1175 {
1176 	int status;
1177 
1178 	if ((status = wait_til_ready()) < 0)
1179 		return -1;
1180 	if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY) {
1181 		fd_outb(byte, FD_DATA);
1182 #ifdef FLOPPY_SANITY_CHECK
1183 		output_log[output_log_pos].data = byte;
1184 		output_log[output_log_pos].status = status;
1185 		output_log[output_log_pos].jiffies = jiffies;
1186 		output_log_pos = (output_log_pos + 1) % OLOGSIZE;
1187 #endif
1188 		return 0;
1189 	}
1190 	FDCS->reset = 1;
1191 	if (!initialising) {
1192 		DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
1193 		       byte, fdc, status);
1194 		show_floppy();
1195 	}
1196 	return -1;
1197 }
1198 
1199 #define LAST_OUT(x) if (output_byte(x)<0){ reset_fdc();return;}
1200 
1201 /* gets the response from the fdc */
1202 static int result(void)
1203 {
1204 	int i;
1205 	int status = 0;
1206 
1207 	for (i = 0; i < MAX_REPLIES; i++) {
1208 		if ((status = wait_til_ready()) < 0)
1209 			break;
1210 		status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
1211 		if ((status & ~STATUS_BUSY) == STATUS_READY) {
1212 #ifdef FLOPPY_SANITY_CHECK
1213 			resultjiffies = jiffies;
1214 			resultsize = i;
1215 #endif
1216 			return i;
1217 		}
1218 		if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
1219 			reply_buffer[i] = fd_inb(FD_DATA);
1220 		else
1221 			break;
1222 	}
1223 	if (!initialising) {
1224 		DPRINT
1225 		    ("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
1226 		     fdc, status, i);
1227 		show_floppy();
1228 	}
1229 	FDCS->reset = 1;
1230 	return -1;
1231 }
1232 
1233 #define MORE_OUTPUT -2
1234 /* does the fdc need more output? */
1235 static int need_more_output(void)
1236 {
1237 	int status;
1238 
1239 	if ((status = wait_til_ready()) < 0)
1240 		return -1;
1241 	if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY)
1242 		return MORE_OUTPUT;
1243 	return result();
1244 }
1245 
1246 /* Set perpendicular mode as required, based on data rate, if supported.
1247  * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
1248  */
1249 static inline void perpendicular_mode(void)
1250 {
1251 	unsigned char perp_mode;
1252 
1253 	if (raw_cmd->rate & 0x40) {
1254 		switch (raw_cmd->rate & 3) {
1255 		case 0:
1256 			perp_mode = 2;
1257 			break;
1258 		case 3:
1259 			perp_mode = 3;
1260 			break;
1261 		default:
1262 			DPRINT("Invalid data rate for perpendicular mode!\n");
1263 			cont->done(0);
1264 			FDCS->reset = 1;	/* convenient way to return to
1265 						 * redo without to much hassle (deep
1266 						 * stack et al. */
1267 			return;
1268 		}
1269 	} else
1270 		perp_mode = 0;
1271 
1272 	if (FDCS->perp_mode == perp_mode)
1273 		return;
1274 	if (FDCS->version >= FDC_82077_ORIG) {
1275 		output_byte(FD_PERPENDICULAR);
1276 		output_byte(perp_mode);
1277 		FDCS->perp_mode = perp_mode;
1278 	} else if (perp_mode) {
1279 		DPRINT("perpendicular mode not supported by this FDC.\n");
1280 	}
1281 }				/* perpendicular_mode */
1282 
1283 static int fifo_depth = 0xa;
1284 static int no_fifo;
1285 
1286 static int fdc_configure(void)
1287 {
1288 	/* Turn on FIFO */
1289 	output_byte(FD_CONFIGURE);
1290 	if (need_more_output() != MORE_OUTPUT)
1291 		return 0;
1292 	output_byte(0);
1293 	output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1294 	output_byte(0);		/* pre-compensation from track
1295 				   0 upwards */
1296 	return 1;
1297 }
1298 
1299 #define NOMINAL_DTR 500
1300 
1301 /* Issue a "SPECIFY" command to set the step rate time, head unload time,
1302  * head load time, and DMA disable flag to values needed by floppy.
1303  *
1304  * The value "dtr" is the data transfer rate in Kbps.  It is needed
1305  * to account for the data rate-based scaling done by the 82072 and 82077
1306  * FDC types.  This parameter is ignored for other types of FDCs (i.e.
1307  * 8272a).
1308  *
1309  * Note that changing the data transfer rate has a (probably deleterious)
1310  * effect on the parameters subject to scaling for 82072/82077 FDCs, so
1311  * fdc_specify is called again after each data transfer rate
1312  * change.
1313  *
1314  * srt: 1000 to 16000 in microseconds
1315  * hut: 16 to 240 milliseconds
1316  * hlt: 2 to 254 milliseconds
1317  *
1318  * These values are rounded up to the next highest available delay time.
1319  */
1320 static void fdc_specify(void)
1321 {
1322 	unsigned char spec1;
1323 	unsigned char spec2;
1324 	unsigned long srt;
1325 	unsigned long hlt;
1326 	unsigned long hut;
1327 	unsigned long dtr = NOMINAL_DTR;
1328 	unsigned long scale_dtr = NOMINAL_DTR;
1329 	int hlt_max_code = 0x7f;
1330 	int hut_max_code = 0xf;
1331 
1332 	if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
1333 		fdc_configure();
1334 		FDCS->need_configure = 0;
1335 	}
1336 
1337 	switch (raw_cmd->rate & 0x03) {
1338 	case 3:
1339 		dtr = 1000;
1340 		break;
1341 	case 1:
1342 		dtr = 300;
1343 		if (FDCS->version >= FDC_82078) {
1344 			/* chose the default rate table, not the one
1345 			 * where 1 = 2 Mbps */
1346 			output_byte(FD_DRIVESPEC);
1347 			if (need_more_output() == MORE_OUTPUT) {
1348 				output_byte(UNIT(current_drive));
1349 				output_byte(0xc0);
1350 			}
1351 		}
1352 		break;
1353 	case 2:
1354 		dtr = 250;
1355 		break;
1356 	}
1357 
1358 	if (FDCS->version >= FDC_82072) {
1359 		scale_dtr = dtr;
1360 		hlt_max_code = 0x00;	/* 0==256msec*dtr0/dtr (not linear!) */
1361 		hut_max_code = 0x0;	/* 0==256msec*dtr0/dtr (not linear!) */
1362 	}
1363 
1364 	/* Convert step rate from microseconds to milliseconds and 4 bits */
1365 	srt = 16 - DIV_ROUND_UP(DP->srt * scale_dtr / 1000, NOMINAL_DTR);
1366 	if (slow_floppy) {
1367 		srt = srt / 4;
1368 	}
1369 	SUPBOUND(srt, 0xf);
1370 	INFBOUND(srt, 0);
1371 
1372 	hlt = DIV_ROUND_UP(DP->hlt * scale_dtr / 2, NOMINAL_DTR);
1373 	if (hlt < 0x01)
1374 		hlt = 0x01;
1375 	else if (hlt > 0x7f)
1376 		hlt = hlt_max_code;
1377 
1378 	hut = DIV_ROUND_UP(DP->hut * scale_dtr / 16, NOMINAL_DTR);
1379 	if (hut < 0x1)
1380 		hut = 0x1;
1381 	else if (hut > 0xf)
1382 		hut = hut_max_code;
1383 
1384 	spec1 = (srt << 4) | hut;
1385 	spec2 = (hlt << 1) | (use_virtual_dma & 1);
1386 
1387 	/* If these parameters did not change, just return with success */
1388 	if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
1389 		/* Go ahead and set spec1 and spec2 */
1390 		output_byte(FD_SPECIFY);
1391 		output_byte(FDCS->spec1 = spec1);
1392 		output_byte(FDCS->spec2 = spec2);
1393 	}
1394 }				/* fdc_specify */
1395 
1396 /* Set the FDC's data transfer rate on behalf of the specified drive.
1397  * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
1398  * of the specify command (i.e. using the fdc_specify function).
1399  */
1400 static int fdc_dtr(void)
1401 {
1402 	/* If data rate not already set to desired value, set it. */
1403 	if ((raw_cmd->rate & 3) == FDCS->dtr)
1404 		return 0;
1405 
1406 	/* Set dtr */
1407 	fd_outb(raw_cmd->rate & 3, FD_DCR);
1408 
1409 	/* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1410 	 * need a stabilization period of several milliseconds to be
1411 	 * enforced after data rate changes before R/W operations.
1412 	 * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
1413 	 */
1414 	FDCS->dtr = raw_cmd->rate & 3;
1415 	return (fd_wait_for_completion(jiffies + 2UL * HZ / 100,
1416 				       (timeout_fn) floppy_ready));
1417 }				/* fdc_dtr */
1418 
1419 static void tell_sector(void)
1420 {
1421 	printk(": track %d, head %d, sector %d, size %d",
1422 	       R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
1423 }				/* tell_sector */
1424 
1425 /*
1426  * OK, this error interpreting routine is called after a
1427  * DMA read/write has succeeded
1428  * or failed, so we check the results, and copy any buffers.
1429  * hhb: Added better error reporting.
1430  * ak: Made this into a separate routine.
1431  */
1432 static int interpret_errors(void)
1433 {
1434 	char bad;
1435 
1436 	if (inr != 7) {
1437 		DPRINT("-- FDC reply error");
1438 		FDCS->reset = 1;
1439 		return 1;
1440 	}
1441 
1442 	/* check IC to find cause of interrupt */
1443 	switch (ST0 & ST0_INTR) {
1444 	case 0x40:		/* error occurred during command execution */
1445 		if (ST1 & ST1_EOC)
1446 			return 0;	/* occurs with pseudo-DMA */
1447 		bad = 1;
1448 		if (ST1 & ST1_WP) {
1449 			DPRINT("Drive is write protected\n");
1450 			CLEARF(FD_DISK_WRITABLE);
1451 			cont->done(0);
1452 			bad = 2;
1453 		} else if (ST1 & ST1_ND) {
1454 			SETF(FD_NEED_TWADDLE);
1455 		} else if (ST1 & ST1_OR) {
1456 			if (DP->flags & FTD_MSG)
1457 				DPRINT("Over/Underrun - retrying\n");
1458 			bad = 0;
1459 		} else if (*errors >= DP->max_errors.reporting) {
1460 			DPRINT("");
1461 			if (ST0 & ST0_ECE) {
1462 				printk("Recalibrate failed!");
1463 			} else if (ST2 & ST2_CRC) {
1464 				printk("data CRC error");
1465 				tell_sector();
1466 			} else if (ST1 & ST1_CRC) {
1467 				printk("CRC error");
1468 				tell_sector();
1469 			} else if ((ST1 & (ST1_MAM | ST1_ND))
1470 				   || (ST2 & ST2_MAM)) {
1471 				if (!probing) {
1472 					printk("sector not found");
1473 					tell_sector();
1474 				} else
1475 					printk("probe failed...");
1476 			} else if (ST2 & ST2_WC) {	/* seek error */
1477 				printk("wrong cylinder");
1478 			} else if (ST2 & ST2_BC) {	/* cylinder marked as bad */
1479 				printk("bad cylinder");
1480 			} else {
1481 				printk
1482 				    ("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
1483 				     ST0, ST1, ST2);
1484 				tell_sector();
1485 			}
1486 			printk("\n");
1487 		}
1488 		if (ST2 & ST2_WC || ST2 & ST2_BC)
1489 			/* wrong cylinder => recal */
1490 			DRS->track = NEED_2_RECAL;
1491 		return bad;
1492 	case 0x80:		/* invalid command given */
1493 		DPRINT("Invalid FDC command given!\n");
1494 		cont->done(0);
1495 		return 2;
1496 	case 0xc0:
1497 		DPRINT("Abnormal termination caused by polling\n");
1498 		cont->error();
1499 		return 2;
1500 	default:		/* (0) Normal command termination */
1501 		return 0;
1502 	}
1503 }
1504 
1505 /*
1506  * This routine is called when everything should be correctly set up
1507  * for the transfer (i.e. floppy motor is on, the correct floppy is
1508  * selected, and the head is sitting on the right track).
1509  */
1510 static void setup_rw_floppy(void)
1511 {
1512 	int i;
1513 	int r;
1514 	int flags;
1515 	int dflags;
1516 	unsigned long ready_date;
1517 	timeout_fn function;
1518 
1519 	flags = raw_cmd->flags;
1520 	if (flags & (FD_RAW_READ | FD_RAW_WRITE))
1521 		flags |= FD_RAW_INTR;
1522 
1523 	if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
1524 		ready_date = DRS->spinup_date + DP->spinup;
1525 		/* If spinup will take a long time, rerun scandrives
1526 		 * again just before spinup completion. Beware that
1527 		 * after scandrives, we must again wait for selection.
1528 		 */
1529 		if (time_after(ready_date, jiffies + DP->select_delay)) {
1530 			ready_date -= DP->select_delay;
1531 			function = (timeout_fn) floppy_start;
1532 		} else
1533 			function = (timeout_fn) setup_rw_floppy;
1534 
1535 		/* wait until the floppy is spinning fast enough */
1536 		if (fd_wait_for_completion(ready_date, function))
1537 			return;
1538 	}
1539 	dflags = DRS->flags;
1540 
1541 	if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
1542 		setup_DMA();
1543 
1544 	if (flags & FD_RAW_INTR)
1545 		do_floppy = main_command_interrupt;
1546 
1547 	r = 0;
1548 	for (i = 0; i < raw_cmd->cmd_count; i++)
1549 		r |= output_byte(raw_cmd->cmd[i]);
1550 
1551 	debugt("rw_command: ");
1552 
1553 	if (r) {
1554 		cont->error();
1555 		reset_fdc();
1556 		return;
1557 	}
1558 
1559 	if (!(flags & FD_RAW_INTR)) {
1560 		inr = result();
1561 		cont->interrupt();
1562 	} else if (flags & FD_RAW_NEED_DISK)
1563 		fd_watchdog();
1564 }
1565 
1566 static int blind_seek;
1567 
1568 /*
1569  * This is the routine called after every seek (or recalibrate) interrupt
1570  * from the floppy controller.
1571  */
1572 static void seek_interrupt(void)
1573 {
1574 	debugt("seek interrupt:");
1575 	if (inr != 2 || (ST0 & 0xF8) != 0x20) {
1576 		DPRINT("seek failed\n");
1577 		DRS->track = NEED_2_RECAL;
1578 		cont->error();
1579 		cont->redo();
1580 		return;
1581 	}
1582 	if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
1583 #ifdef DCL_DEBUG
1584 		if (DP->flags & FD_DEBUG) {
1585 			DPRINT
1586 			    ("clearing NEWCHANGE flag because of effective seek\n");
1587 			DPRINT("jiffies=%lu\n", jiffies);
1588 		}
1589 #endif
1590 		CLEARF(FD_DISK_NEWCHANGE);	/* effective seek */
1591 		DRS->select_date = jiffies;
1592 	}
1593 	DRS->track = ST1;
1594 	floppy_ready();
1595 }
1596 
1597 static void check_wp(void)
1598 {
1599 	if (TESTF(FD_VERIFY)) {
1600 		/* check write protection */
1601 		output_byte(FD_GETSTATUS);
1602 		output_byte(UNIT(current_drive));
1603 		if (result() != 1) {
1604 			FDCS->reset = 1;
1605 			return;
1606 		}
1607 		CLEARF(FD_VERIFY);
1608 		CLEARF(FD_NEED_TWADDLE);
1609 #ifdef DCL_DEBUG
1610 		if (DP->flags & FD_DEBUG) {
1611 			DPRINT("checking whether disk is write protected\n");
1612 			DPRINT("wp=%x\n", ST3 & 0x40);
1613 		}
1614 #endif
1615 		if (!(ST3 & 0x40))
1616 			SETF(FD_DISK_WRITABLE);
1617 		else
1618 			CLEARF(FD_DISK_WRITABLE);
1619 	}
1620 }
1621 
1622 static void seek_floppy(void)
1623 {
1624 	int track;
1625 
1626 	blind_seek = 0;
1627 
1628 #ifdef DCL_DEBUG
1629 	if (DP->flags & FD_DEBUG) {
1630 		DPRINT("calling disk change from seek\n");
1631 	}
1632 #endif
1633 
1634 	if (!TESTF(FD_DISK_NEWCHANGE) &&
1635 	    disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1636 		/* the media changed flag should be cleared after the seek.
1637 		 * If it isn't, this means that there is really no disk in
1638 		 * the drive.
1639 		 */
1640 		SETF(FD_DISK_CHANGED);
1641 		cont->done(0);
1642 		cont->redo();
1643 		return;
1644 	}
1645 	if (DRS->track <= NEED_1_RECAL) {
1646 		recalibrate_floppy();
1647 		return;
1648 	} else if (TESTF(FD_DISK_NEWCHANGE) &&
1649 		   (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1650 		   (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
1651 		/* we seek to clear the media-changed condition. Does anybody
1652 		 * know a more elegant way, which works on all drives? */
1653 		if (raw_cmd->track)
1654 			track = raw_cmd->track - 1;
1655 		else {
1656 			if (DP->flags & FD_SILENT_DCL_CLEAR) {
1657 				set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
1658 				blind_seek = 1;
1659 				raw_cmd->flags |= FD_RAW_NEED_SEEK;
1660 			}
1661 			track = 1;
1662 		}
1663 	} else {
1664 		check_wp();
1665 		if (raw_cmd->track != DRS->track &&
1666 		    (raw_cmd->flags & FD_RAW_NEED_SEEK))
1667 			track = raw_cmd->track;
1668 		else {
1669 			setup_rw_floppy();
1670 			return;
1671 		}
1672 	}
1673 
1674 	do_floppy = seek_interrupt;
1675 	output_byte(FD_SEEK);
1676 	output_byte(UNIT(current_drive));
1677 	LAST_OUT(track);
1678 	debugt("seek command:");
1679 }
1680 
1681 static void recal_interrupt(void)
1682 {
1683 	debugt("recal interrupt:");
1684 	if (inr != 2)
1685 		FDCS->reset = 1;
1686 	else if (ST0 & ST0_ECE) {
1687 		switch (DRS->track) {
1688 		case NEED_1_RECAL:
1689 			debugt("recal interrupt need 1 recal:");
1690 			/* after a second recalibrate, we still haven't
1691 			 * reached track 0. Probably no drive. Raise an
1692 			 * error, as failing immediately might upset
1693 			 * computers possessed by the Devil :-) */
1694 			cont->error();
1695 			cont->redo();
1696 			return;
1697 		case NEED_2_RECAL:
1698 			debugt("recal interrupt need 2 recal:");
1699 			/* If we already did a recalibrate,
1700 			 * and we are not at track 0, this
1701 			 * means we have moved. (The only way
1702 			 * not to move at recalibration is to
1703 			 * be already at track 0.) Clear the
1704 			 * new change flag */
1705 #ifdef DCL_DEBUG
1706 			if (DP->flags & FD_DEBUG) {
1707 				DPRINT
1708 				    ("clearing NEWCHANGE flag because of second recalibrate\n");
1709 			}
1710 #endif
1711 
1712 			CLEARF(FD_DISK_NEWCHANGE);
1713 			DRS->select_date = jiffies;
1714 			/* fall through */
1715 		default:
1716 			debugt("recal interrupt default:");
1717 			/* Recalibrate moves the head by at
1718 			 * most 80 steps. If after one
1719 			 * recalibrate we don't have reached
1720 			 * track 0, this might mean that we
1721 			 * started beyond track 80.  Try
1722 			 * again.  */
1723 			DRS->track = NEED_1_RECAL;
1724 			break;
1725 		}
1726 	} else
1727 		DRS->track = ST1;
1728 	floppy_ready();
1729 }
1730 
1731 static void print_result(char *message, int inr)
1732 {
1733 	int i;
1734 
1735 	DPRINT("%s ", message);
1736 	if (inr >= 0)
1737 		for (i = 0; i < inr; i++)
1738 			printk("repl[%d]=%x ", i, reply_buffer[i]);
1739 	printk("\n");
1740 }
1741 
1742 /* interrupt handler. Note that this can be called externally on the Sparc */
1743 irqreturn_t floppy_interrupt(int irq, void *dev_id)
1744 {
1745 	int do_print;
1746 	unsigned long f;
1747 	void (*handler)(void) = do_floppy;
1748 
1749 	lasthandler = handler;
1750 	interruptjiffies = jiffies;
1751 
1752 	f = claim_dma_lock();
1753 	fd_disable_dma();
1754 	release_dma_lock(f);
1755 
1756 	floppy_enable_hlt();
1757 	do_floppy = NULL;
1758 	if (fdc >= N_FDC || FDCS->address == -1) {
1759 		/* we don't even know which FDC is the culprit */
1760 		printk("DOR0=%x\n", fdc_state[0].dor);
1761 		printk("floppy interrupt on bizarre fdc %d\n", fdc);
1762 		printk("handler=%p\n", handler);
1763 		is_alive("bizarre fdc");
1764 		return IRQ_NONE;
1765 	}
1766 
1767 	FDCS->reset = 0;
1768 	/* We have to clear the reset flag here, because apparently on boxes
1769 	 * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
1770 	 * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
1771 	 * emission of the SENSEI's.
1772 	 * It is OK to emit floppy commands because we are in an interrupt
1773 	 * handler here, and thus we have to fear no interference of other
1774 	 * activity.
1775 	 */
1776 
1777 	do_print = !handler && print_unex && !initialising;
1778 
1779 	inr = result();
1780 	if (do_print)
1781 		print_result("unexpected interrupt", inr);
1782 	if (inr == 0) {
1783 		int max_sensei = 4;
1784 		do {
1785 			output_byte(FD_SENSEI);
1786 			inr = result();
1787 			if (do_print)
1788 				print_result("sensei", inr);
1789 			max_sensei--;
1790 		} while ((ST0 & 0x83) != UNIT(current_drive) && inr == 2
1791 			 && max_sensei);
1792 	}
1793 	if (!handler) {
1794 		FDCS->reset = 1;
1795 		return IRQ_NONE;
1796 	}
1797 	schedule_bh(handler);
1798 	is_alive("normal interrupt end");
1799 
1800 	/* FIXME! Was it really for us? */
1801 	return IRQ_HANDLED;
1802 }
1803 
1804 static void recalibrate_floppy(void)
1805 {
1806 	debugt("recalibrate floppy:");
1807 	do_floppy = recal_interrupt;
1808 	output_byte(FD_RECALIBRATE);
1809 	LAST_OUT(UNIT(current_drive));
1810 }
1811 
1812 /*
1813  * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1814  */
1815 static void reset_interrupt(void)
1816 {
1817 	debugt("reset interrupt:");
1818 	result();		/* get the status ready for set_fdc */
1819 	if (FDCS->reset) {
1820 		printk("reset set in interrupt, calling %p\n", cont->error);
1821 		cont->error();	/* a reset just after a reset. BAD! */
1822 	}
1823 	cont->redo();
1824 }
1825 
1826 /*
1827  * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1828  * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1829  */
1830 static void reset_fdc(void)
1831 {
1832 	unsigned long flags;
1833 
1834 	do_floppy = reset_interrupt;
1835 	FDCS->reset = 0;
1836 	reset_fdc_info(0);
1837 
1838 	/* Pseudo-DMA may intercept 'reset finished' interrupt.  */
1839 	/* Irrelevant for systems with true DMA (i386).          */
1840 
1841 	flags = claim_dma_lock();
1842 	fd_disable_dma();
1843 	release_dma_lock(flags);
1844 
1845 	if (FDCS->version >= FDC_82072A)
1846 		fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
1847 	else {
1848 		fd_outb(FDCS->dor & ~0x04, FD_DOR);
1849 		udelay(FD_RESET_DELAY);
1850 		fd_outb(FDCS->dor, FD_DOR);
1851 	}
1852 }
1853 
1854 static void show_floppy(void)
1855 {
1856 	int i;
1857 
1858 	printk("\n");
1859 	printk("floppy driver state\n");
1860 	printk("-------------------\n");
1861 	printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",
1862 	       jiffies, interruptjiffies, jiffies - interruptjiffies,
1863 	       lasthandler);
1864 
1865 #ifdef FLOPPY_SANITY_CHECK
1866 	printk("timeout_message=%s\n", timeout_message);
1867 	printk("last output bytes:\n");
1868 	for (i = 0; i < OLOGSIZE; i++)
1869 		printk("%2x %2x %lu\n",
1870 		       output_log[(i + output_log_pos) % OLOGSIZE].data,
1871 		       output_log[(i + output_log_pos) % OLOGSIZE].status,
1872 		       output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1873 	printk("last result at %lu\n", resultjiffies);
1874 	printk("last redo_fd_request at %lu\n", lastredo);
1875 	for (i = 0; i < resultsize; i++) {
1876 		printk("%2x ", reply_buffer[i]);
1877 	}
1878 	printk("\n");
1879 #endif
1880 
1881 	printk("status=%x\n", fd_inb(FD_STATUS));
1882 	printk("fdc_busy=%lu\n", fdc_busy);
1883 	if (do_floppy)
1884 		printk("do_floppy=%p\n", do_floppy);
1885 	if (work_pending(&floppy_work))
1886 		printk("floppy_work.func=%p\n", floppy_work.func);
1887 	if (timer_pending(&fd_timer))
1888 		printk("fd_timer.function=%p\n", fd_timer.function);
1889 	if (timer_pending(&fd_timeout)) {
1890 		printk("timer_function=%p\n", fd_timeout.function);
1891 		printk("expires=%lu\n", fd_timeout.expires - jiffies);
1892 		printk("now=%lu\n", jiffies);
1893 	}
1894 	printk("cont=%p\n", cont);
1895 	printk("current_req=%p\n", current_req);
1896 	printk("command_status=%d\n", command_status);
1897 	printk("\n");
1898 }
1899 
1900 static void floppy_shutdown(unsigned long data)
1901 {
1902 	unsigned long flags;
1903 
1904 	if (!initialising)
1905 		show_floppy();
1906 	cancel_activity();
1907 
1908 	floppy_enable_hlt();
1909 
1910 	flags = claim_dma_lock();
1911 	fd_disable_dma();
1912 	release_dma_lock(flags);
1913 
1914 	/* avoid dma going to a random drive after shutdown */
1915 
1916 	if (!initialising)
1917 		DPRINT("floppy timeout called\n");
1918 	FDCS->reset = 1;
1919 	if (cont) {
1920 		cont->done(0);
1921 		cont->redo();	/* this will recall reset when needed */
1922 	} else {
1923 		printk("no cont in shutdown!\n");
1924 		process_fd_request();
1925 	}
1926 	is_alive("floppy shutdown");
1927 }
1928 
1929 /* start motor, check media-changed condition and write protection */
1930 static int start_motor(void (*function)(void))
1931 {
1932 	int mask;
1933 	int data;
1934 
1935 	mask = 0xfc;
1936 	data = UNIT(current_drive);
1937 	if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1938 		if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
1939 			set_debugt();
1940 			/* no read since this drive is running */
1941 			DRS->first_read_date = 0;
1942 			/* note motor start time if motor is not yet running */
1943 			DRS->spinup_date = jiffies;
1944 			data |= (0x10 << UNIT(current_drive));
1945 		}
1946 	} else if (FDCS->dor & (0x10 << UNIT(current_drive)))
1947 		mask &= ~(0x10 << UNIT(current_drive));
1948 
1949 	/* starts motor and selects floppy */
1950 	del_timer(motor_off_timer + current_drive);
1951 	set_dor(fdc, mask, data);
1952 
1953 	/* wait_for_completion also schedules reset if needed. */
1954 	return (fd_wait_for_completion(DRS->select_date + DP->select_delay,
1955 				       (timeout_fn) function));
1956 }
1957 
1958 static void floppy_ready(void)
1959 {
1960 	CHECK_RESET;
1961 	if (start_motor(floppy_ready))
1962 		return;
1963 	if (fdc_dtr())
1964 		return;
1965 
1966 #ifdef DCL_DEBUG
1967 	if (DP->flags & FD_DEBUG) {
1968 		DPRINT("calling disk change from floppy_ready\n");
1969 	}
1970 #endif
1971 	if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1972 	    disk_change(current_drive) && !DP->select_delay)
1973 		twaddle();	/* this clears the dcl on certain drive/controller
1974 				 * combinations */
1975 
1976 #ifdef fd_chose_dma_mode
1977 	if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1978 		unsigned long flags = claim_dma_lock();
1979 		fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1980 		release_dma_lock(flags);
1981 	}
1982 #endif
1983 
1984 	if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1985 		perpendicular_mode();
1986 		fdc_specify();	/* must be done here because of hut, hlt ... */
1987 		seek_floppy();
1988 	} else {
1989 		if ((raw_cmd->flags & FD_RAW_READ) ||
1990 		    (raw_cmd->flags & FD_RAW_WRITE))
1991 			fdc_specify();
1992 		setup_rw_floppy();
1993 	}
1994 }
1995 
1996 static void floppy_start(void)
1997 {
1998 	reschedule_timeout(current_reqD, "floppy start", 0);
1999 
2000 	scandrives();
2001 #ifdef DCL_DEBUG
2002 	if (DP->flags & FD_DEBUG) {
2003 		DPRINT("setting NEWCHANGE in floppy_start\n");
2004 	}
2005 #endif
2006 	SETF(FD_DISK_NEWCHANGE);
2007 	floppy_ready();
2008 }
2009 
2010 /*
2011  * ========================================================================
2012  * here ends the bottom half. Exported routines are:
2013  * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
2014  * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
2015  * Initialization also uses output_byte, result, set_dor, floppy_interrupt
2016  * and set_dor.
2017  * ========================================================================
2018  */
2019 /*
2020  * General purpose continuations.
2021  * ==============================
2022  */
2023 
2024 static void do_wakeup(void)
2025 {
2026 	reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
2027 	cont = NULL;
2028 	command_status += 2;
2029 	wake_up(&command_done);
2030 }
2031 
2032 static struct cont_t wakeup_cont = {
2033 	.interrupt	= empty,
2034 	.redo		= do_wakeup,
2035 	.error		= empty,
2036 	.done		= (done_f)empty
2037 };
2038 
2039 static struct cont_t intr_cont = {
2040 	.interrupt	= empty,
2041 	.redo		= process_fd_request,
2042 	.error		= empty,
2043 	.done		= (done_f)empty
2044 };
2045 
2046 static int wait_til_done(void (*handler)(void), int interruptible)
2047 {
2048 	int ret;
2049 
2050 	schedule_bh(handler);
2051 
2052 	if (command_status < 2 && NO_SIGNAL) {
2053 		DECLARE_WAITQUEUE(wait, current);
2054 
2055 		add_wait_queue(&command_done, &wait);
2056 		for (;;) {
2057 			set_current_state(interruptible ?
2058 					  TASK_INTERRUPTIBLE :
2059 					  TASK_UNINTERRUPTIBLE);
2060 
2061 			if (command_status >= 2 || !NO_SIGNAL)
2062 				break;
2063 
2064 			is_alive("wait_til_done");
2065 			schedule();
2066 		}
2067 
2068 		set_current_state(TASK_RUNNING);
2069 		remove_wait_queue(&command_done, &wait);
2070 	}
2071 
2072 	if (command_status < 2) {
2073 		cancel_activity();
2074 		cont = &intr_cont;
2075 		reset_fdc();
2076 		return -EINTR;
2077 	}
2078 
2079 	if (FDCS->reset)
2080 		command_status = FD_COMMAND_ERROR;
2081 	if (command_status == FD_COMMAND_OKAY)
2082 		ret = 0;
2083 	else
2084 		ret = -EIO;
2085 	command_status = FD_COMMAND_NONE;
2086 	return ret;
2087 }
2088 
2089 static void generic_done(int result)
2090 {
2091 	command_status = result;
2092 	cont = &wakeup_cont;
2093 }
2094 
2095 static void generic_success(void)
2096 {
2097 	cont->done(1);
2098 }
2099 
2100 static void generic_failure(void)
2101 {
2102 	cont->done(0);
2103 }
2104 
2105 static void success_and_wakeup(void)
2106 {
2107 	generic_success();
2108 	cont->redo();
2109 }
2110 
2111 /*
2112  * formatting and rw support.
2113  * ==========================
2114  */
2115 
2116 static int next_valid_format(void)
2117 {
2118 	int probed_format;
2119 
2120 	probed_format = DRS->probed_format;
2121 	while (1) {
2122 		if (probed_format >= 8 || !DP->autodetect[probed_format]) {
2123 			DRS->probed_format = 0;
2124 			return 1;
2125 		}
2126 		if (floppy_type[DP->autodetect[probed_format]].sect) {
2127 			DRS->probed_format = probed_format;
2128 			return 0;
2129 		}
2130 		probed_format++;
2131 	}
2132 }
2133 
2134 static void bad_flp_intr(void)
2135 {
2136 	int err_count;
2137 
2138 	if (probing) {
2139 		DRS->probed_format++;
2140 		if (!next_valid_format())
2141 			return;
2142 	}
2143 	err_count = ++(*errors);
2144 	INFBOUND(DRWE->badness, err_count);
2145 	if (err_count > DP->max_errors.abort)
2146 		cont->done(0);
2147 	if (err_count > DP->max_errors.reset)
2148 		FDCS->reset = 1;
2149 	else if (err_count > DP->max_errors.recal)
2150 		DRS->track = NEED_2_RECAL;
2151 }
2152 
2153 static void set_floppy(int drive)
2154 {
2155 	int type = ITYPE(UDRS->fd_device);
2156 
2157 	if (type)
2158 		_floppy = floppy_type + type;
2159 	else
2160 		_floppy = current_type[drive];
2161 }
2162 
2163 /*
2164  * formatting support.
2165  * ===================
2166  */
2167 static void format_interrupt(void)
2168 {
2169 	switch (interpret_errors()) {
2170 	case 1:
2171 		cont->error();
2172 	case 2:
2173 		break;
2174 	case 0:
2175 		cont->done(1);
2176 	}
2177 	cont->redo();
2178 }
2179 
2180 #define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
2181 #define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80) >>1))
2182 #define CT(x) ((x) | 0xc0)
2183 static void setup_format_params(int track)
2184 {
2185 	int n;
2186 	int il;
2187 	int count;
2188 	int head_shift;
2189 	int track_shift;
2190 	struct fparm {
2191 		unsigned char track, head, sect, size;
2192 	} *here = (struct fparm *)floppy_track_buffer;
2193 
2194 	raw_cmd = &default_raw_cmd;
2195 	raw_cmd->track = track;
2196 
2197 	raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2198 	    FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2199 	raw_cmd->rate = _floppy->rate & 0x43;
2200 	raw_cmd->cmd_count = NR_F;
2201 	COMMAND = FM_MODE(_floppy, FD_FORMAT);
2202 	DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2203 	F_SIZECODE = FD_SIZECODE(_floppy);
2204 	F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2205 	F_GAP = _floppy->fmt_gap;
2206 	F_FILL = FD_FILL_BYTE;
2207 
2208 	raw_cmd->kernel_data = floppy_track_buffer;
2209 	raw_cmd->length = 4 * F_SECT_PER_TRACK;
2210 
2211 	/* allow for about 30ms for data transport per track */
2212 	head_shift = (F_SECT_PER_TRACK + 5) / 6;
2213 
2214 	/* a ``cylinder'' is two tracks plus a little stepping time */
2215 	track_shift = 2 * head_shift + 3;
2216 
2217 	/* position of logical sector 1 on this track */
2218 	n = (track_shift * format_req.track + head_shift * format_req.head)
2219 	    % F_SECT_PER_TRACK;
2220 
2221 	/* determine interleave */
2222 	il = 1;
2223 	if (_floppy->fmt_gap < 0x22)
2224 		il++;
2225 
2226 	/* initialize field */
2227 	for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2228 		here[count].track = format_req.track;
2229 		here[count].head = format_req.head;
2230 		here[count].sect = 0;
2231 		here[count].size = F_SIZECODE;
2232 	}
2233 	/* place logical sectors */
2234 	for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2235 		here[n].sect = count;
2236 		n = (n + il) % F_SECT_PER_TRACK;
2237 		if (here[n].sect) {	/* sector busy, find next free sector */
2238 			++n;
2239 			if (n >= F_SECT_PER_TRACK) {
2240 				n -= F_SECT_PER_TRACK;
2241 				while (here[n].sect)
2242 					++n;
2243 			}
2244 		}
2245 	}
2246 	if (_floppy->stretch & FD_SECTBASEMASK) {
2247 		for (count = 0; count < F_SECT_PER_TRACK; count++)
2248 			here[count].sect += FD_SECTBASE(_floppy) - 1;
2249 	}
2250 }
2251 
2252 static void redo_format(void)
2253 {
2254 	buffer_track = -1;
2255 	setup_format_params(format_req.track << STRETCH(_floppy));
2256 	floppy_start();
2257 	debugt("queue format request");
2258 }
2259 
2260 static struct cont_t format_cont = {
2261 	.interrupt	= format_interrupt,
2262 	.redo		= redo_format,
2263 	.error		= bad_flp_intr,
2264 	.done		= generic_done
2265 };
2266 
2267 static int do_format(int drive, struct format_descr *tmp_format_req)
2268 {
2269 	int ret;
2270 
2271 	LOCK_FDC(drive, 1);
2272 	set_floppy(drive);
2273 	if (!_floppy ||
2274 	    _floppy->track > DP->tracks ||
2275 	    tmp_format_req->track >= _floppy->track ||
2276 	    tmp_format_req->head >= _floppy->head ||
2277 	    (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2278 	    !_floppy->fmt_gap) {
2279 		process_fd_request();
2280 		return -EINVAL;
2281 	}
2282 	format_req = *tmp_format_req;
2283 	format_errors = 0;
2284 	cont = &format_cont;
2285 	errors = &format_errors;
2286 	IWAIT(redo_format);
2287 	process_fd_request();
2288 	return ret;
2289 }
2290 
2291 /*
2292  * Buffer read/write and support
2293  * =============================
2294  */
2295 
2296 static void floppy_end_request(struct request *req, int error)
2297 {
2298 	unsigned int nr_sectors = current_count_sectors;
2299 	unsigned int drive = (unsigned long)req->rq_disk->private_data;
2300 
2301 	/* current_count_sectors can be zero if transfer failed */
2302 	if (error)
2303 		nr_sectors = req->current_nr_sectors;
2304 	if (__blk_end_request(req, error, nr_sectors << 9))
2305 		return;
2306 
2307 	/* We're done with the request */
2308 	floppy_off(drive);
2309 	current_req = NULL;
2310 }
2311 
2312 /* new request_done. Can handle physical sectors which are smaller than a
2313  * logical buffer */
2314 static void request_done(int uptodate)
2315 {
2316 	struct request_queue *q = floppy_queue;
2317 	struct request *req = current_req;
2318 	unsigned long flags;
2319 	int block;
2320 
2321 	probing = 0;
2322 	reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
2323 
2324 	if (!req) {
2325 		printk("floppy.c: no request in request_done\n");
2326 		return;
2327 	}
2328 
2329 	if (uptodate) {
2330 		/* maintain values for invalidation on geometry
2331 		 * change */
2332 		block = current_count_sectors + req->sector;
2333 		INFBOUND(DRS->maxblock, block);
2334 		if (block > _floppy->sect)
2335 			DRS->maxtrack = 1;
2336 
2337 		/* unlock chained buffers */
2338 		spin_lock_irqsave(q->queue_lock, flags);
2339 		floppy_end_request(req, 0);
2340 		spin_unlock_irqrestore(q->queue_lock, flags);
2341 	} else {
2342 		if (rq_data_dir(req) == WRITE) {
2343 			/* record write error information */
2344 			DRWE->write_errors++;
2345 			if (DRWE->write_errors == 1) {
2346 				DRWE->first_error_sector = req->sector;
2347 				DRWE->first_error_generation = DRS->generation;
2348 			}
2349 			DRWE->last_error_sector = req->sector;
2350 			DRWE->last_error_generation = DRS->generation;
2351 		}
2352 		spin_lock_irqsave(q->queue_lock, flags);
2353 		floppy_end_request(req, -EIO);
2354 		spin_unlock_irqrestore(q->queue_lock, flags);
2355 	}
2356 }
2357 
2358 /* Interrupt handler evaluating the result of the r/w operation */
2359 static void rw_interrupt(void)
2360 {
2361 	int eoc;
2362 	int ssize;
2363 	int heads;
2364 	int nr_sectors;
2365 
2366 	if (R_HEAD >= 2) {
2367 		/* some Toshiba floppy controllers occasionnally seem to
2368 		 * return bogus interrupts after read/write operations, which
2369 		 * can be recognized by a bad head number (>= 2) */
2370 		return;
2371 	}
2372 
2373 	if (!DRS->first_read_date)
2374 		DRS->first_read_date = jiffies;
2375 
2376 	nr_sectors = 0;
2377 	CODE2SIZE;
2378 
2379 	if (ST1 & ST1_EOC)
2380 		eoc = 1;
2381 	else
2382 		eoc = 0;
2383 
2384 	if (COMMAND & 0x80)
2385 		heads = 2;
2386 	else
2387 		heads = 1;
2388 
2389 	nr_sectors = (((R_TRACK - TRACK) * heads +
2390 		       R_HEAD - HEAD) * SECT_PER_TRACK +
2391 		      R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2392 
2393 #ifdef FLOPPY_SANITY_CHECK
2394 	if (nr_sectors / ssize >
2395 	    DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {
2396 		DPRINT("long rw: %x instead of %lx\n",
2397 		       nr_sectors, current_count_sectors);
2398 		printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
2399 		printk("rh=%d h=%d\n", R_HEAD, HEAD);
2400 		printk("rt=%d t=%d\n", R_TRACK, TRACK);
2401 		printk("heads=%d eoc=%d\n", heads, eoc);
2402 		printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
2403 		       fsector_t, ssize);
2404 		printk("in_sector_offset=%d\n", in_sector_offset);
2405 	}
2406 #endif
2407 
2408 	nr_sectors -= in_sector_offset;
2409 	INFBOUND(nr_sectors, 0);
2410 	SUPBOUND(current_count_sectors, nr_sectors);
2411 
2412 	switch (interpret_errors()) {
2413 	case 2:
2414 		cont->redo();
2415 		return;
2416 	case 1:
2417 		if (!current_count_sectors) {
2418 			cont->error();
2419 			cont->redo();
2420 			return;
2421 		}
2422 		break;
2423 	case 0:
2424 		if (!current_count_sectors) {
2425 			cont->redo();
2426 			return;
2427 		}
2428 		current_type[current_drive] = _floppy;
2429 		floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2430 		break;
2431 	}
2432 
2433 	if (probing) {
2434 		if (DP->flags & FTD_MSG)
2435 			DPRINT("Auto-detected floppy type %s in fd%d\n",
2436 			       _floppy->name, current_drive);
2437 		current_type[current_drive] = _floppy;
2438 		floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2439 		probing = 0;
2440 	}
2441 
2442 	if (CT(COMMAND) != FD_READ ||
2443 	    raw_cmd->kernel_data == current_req->buffer) {
2444 		/* transfer directly from buffer */
2445 		cont->done(1);
2446 	} else if (CT(COMMAND) == FD_READ) {
2447 		buffer_track = raw_cmd->track;
2448 		buffer_drive = current_drive;
2449 		INFBOUND(buffer_max, nr_sectors + fsector_t);
2450 	}
2451 	cont->redo();
2452 }
2453 
2454 /* Compute maximal contiguous buffer size. */
2455 static int buffer_chain_size(void)
2456 {
2457 	struct bio_vec *bv;
2458 	int size;
2459 	struct req_iterator iter;
2460 	char *base;
2461 
2462 	base = bio_data(current_req->bio);
2463 	size = 0;
2464 
2465 	rq_for_each_segment(bv, current_req, iter) {
2466 		if (page_address(bv->bv_page) + bv->bv_offset != base + size)
2467 			break;
2468 
2469 		size += bv->bv_len;
2470 	}
2471 
2472 	return size >> 9;
2473 }
2474 
2475 /* Compute the maximal transfer size */
2476 static int transfer_size(int ssize, int max_sector, int max_size)
2477 {
2478 	SUPBOUND(max_sector, fsector_t + max_size);
2479 
2480 	/* alignment */
2481 	max_sector -= (max_sector % _floppy->sect) % ssize;
2482 
2483 	/* transfer size, beginning not aligned */
2484 	current_count_sectors = max_sector - fsector_t;
2485 
2486 	return max_sector;
2487 }
2488 
2489 /*
2490  * Move data from/to the track buffer to/from the buffer cache.
2491  */
2492 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2493 {
2494 	int remaining;		/* number of transferred 512-byte sectors */
2495 	struct bio_vec *bv;
2496 	char *buffer;
2497 	char *dma_buffer;
2498 	int size;
2499 	struct req_iterator iter;
2500 
2501 	max_sector = transfer_size(ssize,
2502 				   min(max_sector, max_sector_2),
2503 				   current_req->nr_sectors);
2504 
2505 	if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2506 	    buffer_max > fsector_t + current_req->nr_sectors)
2507 		current_count_sectors = min_t(int, buffer_max - fsector_t,
2508 					      current_req->nr_sectors);
2509 
2510 	remaining = current_count_sectors << 9;
2511 #ifdef FLOPPY_SANITY_CHECK
2512 	if ((remaining >> 9) > current_req->nr_sectors &&
2513 	    CT(COMMAND) == FD_WRITE) {
2514 		DPRINT("in copy buffer\n");
2515 		printk("current_count_sectors=%ld\n", current_count_sectors);
2516 		printk("remaining=%d\n", remaining >> 9);
2517 		printk("current_req->nr_sectors=%ld\n",
2518 		       current_req->nr_sectors);
2519 		printk("current_req->current_nr_sectors=%u\n",
2520 		       current_req->current_nr_sectors);
2521 		printk("max_sector=%d\n", max_sector);
2522 		printk("ssize=%d\n", ssize);
2523 	}
2524 #endif
2525 
2526 	buffer_max = max(max_sector, buffer_max);
2527 
2528 	dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2529 
2530 	size = current_req->current_nr_sectors << 9;
2531 
2532 	rq_for_each_segment(bv, current_req, iter) {
2533 		if (!remaining)
2534 			break;
2535 
2536 		size = bv->bv_len;
2537 		SUPBOUND(size, remaining);
2538 
2539 		buffer = page_address(bv->bv_page) + bv->bv_offset;
2540 #ifdef FLOPPY_SANITY_CHECK
2541 		if (dma_buffer + size >
2542 		    floppy_track_buffer + (max_buffer_sectors << 10) ||
2543 		    dma_buffer < floppy_track_buffer) {
2544 			DPRINT("buffer overrun in copy buffer %d\n",
2545 			       (int)((floppy_track_buffer -
2546 				      dma_buffer) >> 9));
2547 			printk("fsector_t=%d buffer_min=%d\n",
2548 			       fsector_t, buffer_min);
2549 			printk("current_count_sectors=%ld\n",
2550 			       current_count_sectors);
2551 			if (CT(COMMAND) == FD_READ)
2552 				printk("read\n");
2553 			if (CT(COMMAND) == FD_WRITE)
2554 				printk("write\n");
2555 			break;
2556 		}
2557 		if (((unsigned long)buffer) % 512)
2558 			DPRINT("%p buffer not aligned\n", buffer);
2559 #endif
2560 		if (CT(COMMAND) == FD_READ)
2561 			memcpy(buffer, dma_buffer, size);
2562 		else
2563 			memcpy(dma_buffer, buffer, size);
2564 
2565 		remaining -= size;
2566 		dma_buffer += size;
2567 	}
2568 #ifdef FLOPPY_SANITY_CHECK
2569 	if (remaining) {
2570 		if (remaining > 0)
2571 			max_sector -= remaining >> 9;
2572 		DPRINT("weirdness: remaining %d\n", remaining >> 9);
2573 	}
2574 #endif
2575 }
2576 
2577 /* work around a bug in pseudo DMA
2578  * (on some FDCs) pseudo DMA does not stop when the CPU stops
2579  * sending data.  Hence we need a different way to signal the
2580  * transfer length:  We use SECT_PER_TRACK.  Unfortunately, this
2581  * does not work with MT, hence we can only transfer one head at
2582  * a time
2583  */
2584 static void virtualdmabug_workaround(void)
2585 {
2586 	int hard_sectors;
2587 	int end_sector;
2588 
2589 	if (CT(COMMAND) == FD_WRITE) {
2590 		COMMAND &= ~0x80;	/* switch off multiple track mode */
2591 
2592 		hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2593 		end_sector = SECTOR + hard_sectors - 1;
2594 #ifdef FLOPPY_SANITY_CHECK
2595 		if (end_sector > SECT_PER_TRACK) {
2596 			printk("too many sectors %d > %d\n",
2597 			       end_sector, SECT_PER_TRACK);
2598 			return;
2599 		}
2600 #endif
2601 		SECT_PER_TRACK = end_sector;	/* make sure SECT_PER_TRACK points
2602 						 * to end of transfer */
2603 	}
2604 }
2605 
2606 /*
2607  * Formulate a read/write request.
2608  * this routine decides where to load the data (directly to buffer, or to
2609  * tmp floppy area), how much data to load (the size of the buffer, the whole
2610  * track, or a single sector)
2611  * All floppy_track_buffer handling goes in here. If we ever add track buffer
2612  * allocation on the fly, it should be done here. No other part should need
2613  * modification.
2614  */
2615 
2616 static int make_raw_rw_request(void)
2617 {
2618 	int aligned_sector_t;
2619 	int max_sector;
2620 	int max_size;
2621 	int tracksize;
2622 	int ssize;
2623 
2624 	if (max_buffer_sectors == 0) {
2625 		printk("VFS: Block I/O scheduled on unopened device\n");
2626 		return 0;
2627 	}
2628 
2629 	set_fdc((long)current_req->rq_disk->private_data);
2630 
2631 	raw_cmd = &default_raw_cmd;
2632 	raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2633 	    FD_RAW_NEED_SEEK;
2634 	raw_cmd->cmd_count = NR_RW;
2635 	if (rq_data_dir(current_req) == READ) {
2636 		raw_cmd->flags |= FD_RAW_READ;
2637 		COMMAND = FM_MODE(_floppy, FD_READ);
2638 	} else if (rq_data_dir(current_req) == WRITE) {
2639 		raw_cmd->flags |= FD_RAW_WRITE;
2640 		COMMAND = FM_MODE(_floppy, FD_WRITE);
2641 	} else {
2642 		DPRINT("make_raw_rw_request: unknown command\n");
2643 		return 0;
2644 	}
2645 
2646 	max_sector = _floppy->sect * _floppy->head;
2647 
2648 	TRACK = (int)current_req->sector / max_sector;
2649 	fsector_t = (int)current_req->sector % max_sector;
2650 	if (_floppy->track && TRACK >= _floppy->track) {
2651 		if (current_req->current_nr_sectors & 1) {
2652 			current_count_sectors = 1;
2653 			return 1;
2654 		} else
2655 			return 0;
2656 	}
2657 	HEAD = fsector_t / _floppy->sect;
2658 
2659 	if (((_floppy->stretch & (FD_SWAPSIDES | FD_SECTBASEMASK)) ||
2660 	     TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
2661 		max_sector = _floppy->sect;
2662 
2663 	/* 2M disks have phantom sectors on the first track */
2664 	if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2665 		max_sector = 2 * _floppy->sect / 3;
2666 		if (fsector_t >= max_sector) {
2667 			current_count_sectors =
2668 			    min_t(int, _floppy->sect - fsector_t,
2669 				  current_req->nr_sectors);
2670 			return 1;
2671 		}
2672 		SIZECODE = 2;
2673 	} else
2674 		SIZECODE = FD_SIZECODE(_floppy);
2675 	raw_cmd->rate = _floppy->rate & 0x43;
2676 	if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2677 		raw_cmd->rate = 1;
2678 
2679 	if (SIZECODE)
2680 		SIZECODE2 = 0xff;
2681 	else
2682 		SIZECODE2 = 0x80;
2683 	raw_cmd->track = TRACK << STRETCH(_floppy);
2684 	DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2685 	GAP = _floppy->gap;
2686 	CODE2SIZE;
2687 	SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2688 	SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
2689 	    FD_SECTBASE(_floppy);
2690 
2691 	/* tracksize describes the size which can be filled up with sectors
2692 	 * of size ssize.
2693 	 */
2694 	tracksize = _floppy->sect - _floppy->sect % ssize;
2695 	if (tracksize < _floppy->sect) {
2696 		SECT_PER_TRACK++;
2697 		if (tracksize <= fsector_t % _floppy->sect)
2698 			SECTOR--;
2699 
2700 		/* if we are beyond tracksize, fill up using smaller sectors */
2701 		while (tracksize <= fsector_t % _floppy->sect) {
2702 			while (tracksize + ssize > _floppy->sect) {
2703 				SIZECODE--;
2704 				ssize >>= 1;
2705 			}
2706 			SECTOR++;
2707 			SECT_PER_TRACK++;
2708 			tracksize += ssize;
2709 		}
2710 		max_sector = HEAD * _floppy->sect + tracksize;
2711 	} else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2712 		max_sector = _floppy->sect;
2713 	} else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2714 		/* for virtual DMA bug workaround */
2715 		max_sector = _floppy->sect;
2716 	}
2717 
2718 	in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2719 	aligned_sector_t = fsector_t - in_sector_offset;
2720 	max_size = current_req->nr_sectors;
2721 	if ((raw_cmd->track == buffer_track) &&
2722 	    (current_drive == buffer_drive) &&
2723 	    (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2724 		/* data already in track buffer */
2725 		if (CT(COMMAND) == FD_READ) {
2726 			copy_buffer(1, max_sector, buffer_max);
2727 			return 1;
2728 		}
2729 	} else if (in_sector_offset || current_req->nr_sectors < ssize) {
2730 		if (CT(COMMAND) == FD_WRITE) {
2731 			if (fsector_t + current_req->nr_sectors > ssize &&
2732 			    fsector_t + current_req->nr_sectors < ssize + ssize)
2733 				max_size = ssize + ssize;
2734 			else
2735 				max_size = ssize;
2736 		}
2737 		raw_cmd->flags &= ~FD_RAW_WRITE;
2738 		raw_cmd->flags |= FD_RAW_READ;
2739 		COMMAND = FM_MODE(_floppy, FD_READ);
2740 	} else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2741 		unsigned long dma_limit;
2742 		int direct, indirect;
2743 
2744 		indirect =
2745 		    transfer_size(ssize, max_sector,
2746 				  max_buffer_sectors * 2) - fsector_t;
2747 
2748 		/*
2749 		 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2750 		 * on a 64 bit machine!
2751 		 */
2752 		max_size = buffer_chain_size();
2753 		dma_limit =
2754 		    (MAX_DMA_ADDRESS -
2755 		     ((unsigned long)current_req->buffer)) >> 9;
2756 		if ((unsigned long)max_size > dma_limit) {
2757 			max_size = dma_limit;
2758 		}
2759 		/* 64 kb boundaries */
2760 		if (CROSS_64KB(current_req->buffer, max_size << 9))
2761 			max_size = (K_64 -
2762 				    ((unsigned long)current_req->buffer) %
2763 				    K_64) >> 9;
2764 		direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2765 		/*
2766 		 * We try to read tracks, but if we get too many errors, we
2767 		 * go back to reading just one sector at a time.
2768 		 *
2769 		 * This means we should be able to read a sector even if there
2770 		 * are other bad sectors on this track.
2771 		 */
2772 		if (!direct ||
2773 		    (indirect * 2 > direct * 3 &&
2774 		     *errors < DP->max_errors.read_track && ((!probing
2775 		       || (DP->read_track & (1 << DRS->probed_format)))))) {
2776 			max_size = current_req->nr_sectors;
2777 		} else {
2778 			raw_cmd->kernel_data = current_req->buffer;
2779 			raw_cmd->length = current_count_sectors << 9;
2780 			if (raw_cmd->length == 0) {
2781 				DPRINT
2782 				    ("zero dma transfer attempted from make_raw_request\n");
2783 				DPRINT("indirect=%d direct=%d fsector_t=%d",
2784 				       indirect, direct, fsector_t);
2785 				return 0;
2786 			}
2787 			virtualdmabug_workaround();
2788 			return 2;
2789 		}
2790 	}
2791 
2792 	if (CT(COMMAND) == FD_READ)
2793 		max_size = max_sector;	/* unbounded */
2794 
2795 	/* claim buffer track if needed */
2796 	if (buffer_track != raw_cmd->track ||	/* bad track */
2797 	    buffer_drive != current_drive ||	/* bad drive */
2798 	    fsector_t > buffer_max ||
2799 	    fsector_t < buffer_min ||
2800 	    ((CT(COMMAND) == FD_READ ||
2801 	      (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
2802 	     max_sector > 2 * max_buffer_sectors + buffer_min &&
2803 	     max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
2804 	    /* not enough space */
2805 	    ) {
2806 		buffer_track = -1;
2807 		buffer_drive = current_drive;
2808 		buffer_max = buffer_min = aligned_sector_t;
2809 	}
2810 	raw_cmd->kernel_data = floppy_track_buffer +
2811 	    ((aligned_sector_t - buffer_min) << 9);
2812 
2813 	if (CT(COMMAND) == FD_WRITE) {
2814 		/* copy write buffer to track buffer.
2815 		 * if we get here, we know that the write
2816 		 * is either aligned or the data already in the buffer
2817 		 * (buffer will be overwritten) */
2818 #ifdef FLOPPY_SANITY_CHECK
2819 		if (in_sector_offset && buffer_track == -1)
2820 			DPRINT("internal error offset !=0 on write\n");
2821 #endif
2822 		buffer_track = raw_cmd->track;
2823 		buffer_drive = current_drive;
2824 		copy_buffer(ssize, max_sector,
2825 			    2 * max_buffer_sectors + buffer_min);
2826 	} else
2827 		transfer_size(ssize, max_sector,
2828 			      2 * max_buffer_sectors + buffer_min -
2829 			      aligned_sector_t);
2830 
2831 	/* round up current_count_sectors to get dma xfer size */
2832 	raw_cmd->length = in_sector_offset + current_count_sectors;
2833 	raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2834 	raw_cmd->length <<= 9;
2835 #ifdef FLOPPY_SANITY_CHECK
2836 	if ((raw_cmd->length < current_count_sectors << 9) ||
2837 	    (raw_cmd->kernel_data != current_req->buffer &&
2838 	     CT(COMMAND) == FD_WRITE &&
2839 	     (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2840 	      aligned_sector_t < buffer_min)) ||
2841 	    raw_cmd->length % (128 << SIZECODE) ||
2842 	    raw_cmd->length <= 0 || current_count_sectors <= 0) {
2843 		DPRINT("fractionary current count b=%lx s=%lx\n",
2844 		       raw_cmd->length, current_count_sectors);
2845 		if (raw_cmd->kernel_data != current_req->buffer)
2846 			printk("addr=%d, length=%ld\n",
2847 			       (int)((raw_cmd->kernel_data -
2848 				      floppy_track_buffer) >> 9),
2849 			       current_count_sectors);
2850 		printk("st=%d ast=%d mse=%d msi=%d\n",
2851 		       fsector_t, aligned_sector_t, max_sector, max_size);
2852 		printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2853 		printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2854 		       COMMAND, SECTOR, HEAD, TRACK);
2855 		printk("buffer drive=%d\n", buffer_drive);
2856 		printk("buffer track=%d\n", buffer_track);
2857 		printk("buffer_min=%d\n", buffer_min);
2858 		printk("buffer_max=%d\n", buffer_max);
2859 		return 0;
2860 	}
2861 
2862 	if (raw_cmd->kernel_data != current_req->buffer) {
2863 		if (raw_cmd->kernel_data < floppy_track_buffer ||
2864 		    current_count_sectors < 0 ||
2865 		    raw_cmd->length < 0 ||
2866 		    raw_cmd->kernel_data + raw_cmd->length >
2867 		    floppy_track_buffer + (max_buffer_sectors << 10)) {
2868 			DPRINT("buffer overrun in schedule dma\n");
2869 			printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
2870 			       fsector_t, buffer_min, raw_cmd->length >> 9);
2871 			printk("current_count_sectors=%ld\n",
2872 			       current_count_sectors);
2873 			if (CT(COMMAND) == FD_READ)
2874 				printk("read\n");
2875 			if (CT(COMMAND) == FD_WRITE)
2876 				printk("write\n");
2877 			return 0;
2878 		}
2879 	} else if (raw_cmd->length > current_req->nr_sectors << 9 ||
2880 		   current_count_sectors > current_req->nr_sectors) {
2881 		DPRINT("buffer overrun in direct transfer\n");
2882 		return 0;
2883 	} else if (raw_cmd->length < current_count_sectors << 9) {
2884 		DPRINT("more sectors than bytes\n");
2885 		printk("bytes=%ld\n", raw_cmd->length >> 9);
2886 		printk("sectors=%ld\n", current_count_sectors);
2887 	}
2888 	if (raw_cmd->length == 0) {
2889 		DPRINT("zero dma transfer attempted from make_raw_request\n");
2890 		return 0;
2891 	}
2892 #endif
2893 
2894 	virtualdmabug_workaround();
2895 	return 2;
2896 }
2897 
2898 static void redo_fd_request(void)
2899 {
2900 #define REPEAT {request_done(0); continue; }
2901 	int drive;
2902 	int tmp;
2903 
2904 	lastredo = jiffies;
2905 	if (current_drive < N_DRIVE)
2906 		floppy_off(current_drive);
2907 
2908 	for (;;) {
2909 		if (!current_req) {
2910 			struct request *req;
2911 
2912 			spin_lock_irq(floppy_queue->queue_lock);
2913 			req = elv_next_request(floppy_queue);
2914 			spin_unlock_irq(floppy_queue->queue_lock);
2915 			if (!req) {
2916 				do_floppy = NULL;
2917 				unlock_fdc();
2918 				return;
2919 			}
2920 			current_req = req;
2921 		}
2922 		drive = (long)current_req->rq_disk->private_data;
2923 		set_fdc(drive);
2924 		reschedule_timeout(current_reqD, "redo fd request", 0);
2925 
2926 		set_floppy(drive);
2927 		raw_cmd = &default_raw_cmd;
2928 		raw_cmd->flags = 0;
2929 		if (start_motor(redo_fd_request))
2930 			return;
2931 		disk_change(current_drive);
2932 		if (test_bit(current_drive, &fake_change) ||
2933 		    TESTF(FD_DISK_CHANGED)) {
2934 			DPRINT("disk absent or changed during operation\n");
2935 			REPEAT;
2936 		}
2937 		if (!_floppy) {	/* Autodetection */
2938 			if (!probing) {
2939 				DRS->probed_format = 0;
2940 				if (next_valid_format()) {
2941 					DPRINT("no autodetectable formats\n");
2942 					_floppy = NULL;
2943 					REPEAT;
2944 				}
2945 			}
2946 			probing = 1;
2947 			_floppy =
2948 			    floppy_type + DP->autodetect[DRS->probed_format];
2949 		} else
2950 			probing = 0;
2951 		errors = &(current_req->errors);
2952 		tmp = make_raw_rw_request();
2953 		if (tmp < 2) {
2954 			request_done(tmp);
2955 			continue;
2956 		}
2957 
2958 		if (TESTF(FD_NEED_TWADDLE))
2959 			twaddle();
2960 		schedule_bh(floppy_start);
2961 		debugt("queue fd request");
2962 		return;
2963 	}
2964 #undef REPEAT
2965 }
2966 
2967 static struct cont_t rw_cont = {
2968 	.interrupt	= rw_interrupt,
2969 	.redo		= redo_fd_request,
2970 	.error		= bad_flp_intr,
2971 	.done		= request_done
2972 };
2973 
2974 static void process_fd_request(void)
2975 {
2976 	cont = &rw_cont;
2977 	schedule_bh(redo_fd_request);
2978 }
2979 
2980 static void do_fd_request(struct request_queue * q)
2981 {
2982 	if (max_buffer_sectors == 0) {
2983 		printk("VFS: do_fd_request called on non-open device\n");
2984 		return;
2985 	}
2986 
2987 	if (usage_count == 0) {
2988 		printk("warning: usage count=0, current_req=%p exiting\n",
2989 		       current_req);
2990 		printk("sect=%ld type=%x flags=%x\n", (long)current_req->sector,
2991 		       current_req->cmd_type, current_req->cmd_flags);
2992 		return;
2993 	}
2994 	if (test_bit(0, &fdc_busy)) {
2995 		/* fdc busy, this new request will be treated when the
2996 		   current one is done */
2997 		is_alive("do fd request, old request running");
2998 		return;
2999 	}
3000 	lock_fdc(MAXTIMEOUT, 0);
3001 	process_fd_request();
3002 	is_alive("do fd request");
3003 }
3004 
3005 static struct cont_t poll_cont = {
3006 	.interrupt	= success_and_wakeup,
3007 	.redo		= floppy_ready,
3008 	.error		= generic_failure,
3009 	.done		= generic_done
3010 };
3011 
3012 static int poll_drive(int interruptible, int flag)
3013 {
3014 	int ret;
3015 
3016 	/* no auto-sense, just clear dcl */
3017 	raw_cmd = &default_raw_cmd;
3018 	raw_cmd->flags = flag;
3019 	raw_cmd->track = 0;
3020 	raw_cmd->cmd_count = 0;
3021 	cont = &poll_cont;
3022 #ifdef DCL_DEBUG
3023 	if (DP->flags & FD_DEBUG) {
3024 		DPRINT("setting NEWCHANGE in poll_drive\n");
3025 	}
3026 #endif
3027 	SETF(FD_DISK_NEWCHANGE);
3028 	WAIT(floppy_ready);
3029 	return ret;
3030 }
3031 
3032 /*
3033  * User triggered reset
3034  * ====================
3035  */
3036 
3037 static void reset_intr(void)
3038 {
3039 	printk("weird, reset interrupt called\n");
3040 }
3041 
3042 static struct cont_t reset_cont = {
3043 	.interrupt	= reset_intr,
3044 	.redo		= success_and_wakeup,
3045 	.error		= generic_failure,
3046 	.done		= generic_done
3047 };
3048 
3049 static int user_reset_fdc(int drive, int arg, int interruptible)
3050 {
3051 	int ret;
3052 
3053 	ret = 0;
3054 	LOCK_FDC(drive, interruptible);
3055 	if (arg == FD_RESET_ALWAYS)
3056 		FDCS->reset = 1;
3057 	if (FDCS->reset) {
3058 		cont = &reset_cont;
3059 		WAIT(reset_fdc);
3060 	}
3061 	process_fd_request();
3062 	return ret;
3063 }
3064 
3065 /*
3066  * Misc Ioctl's and support
3067  * ========================
3068  */
3069 static inline int fd_copyout(void __user *param, const void *address,
3070 			     unsigned long size)
3071 {
3072 	return copy_to_user(param, address, size) ? -EFAULT : 0;
3073 }
3074 
3075 static inline int fd_copyin(void __user *param, void *address, unsigned long size)
3076 {
3077 	return copy_from_user(address, param, size) ? -EFAULT : 0;
3078 }
3079 
3080 #define _COPYOUT(x) (copy_to_user((void __user *)param, &(x), sizeof(x)) ? -EFAULT : 0)
3081 #define _COPYIN(x) (copy_from_user(&(x), (void __user *)param, sizeof(x)) ? -EFAULT : 0)
3082 
3083 #define COPYOUT(x) ECALL(_COPYOUT(x))
3084 #define COPYIN(x) ECALL(_COPYIN(x))
3085 
3086 static inline const char *drive_name(int type, int drive)
3087 {
3088 	struct floppy_struct *floppy;
3089 
3090 	if (type)
3091 		floppy = floppy_type + type;
3092 	else {
3093 		if (UDP->native_format)
3094 			floppy = floppy_type + UDP->native_format;
3095 		else
3096 			return "(null)";
3097 	}
3098 	if (floppy->name)
3099 		return floppy->name;
3100 	else
3101 		return "(null)";
3102 }
3103 
3104 /* raw commands */
3105 static void raw_cmd_done(int flag)
3106 {
3107 	int i;
3108 
3109 	if (!flag) {
3110 		raw_cmd->flags |= FD_RAW_FAILURE;
3111 		raw_cmd->flags |= FD_RAW_HARDFAILURE;
3112 	} else {
3113 		raw_cmd->reply_count = inr;
3114 		if (raw_cmd->reply_count > MAX_REPLIES)
3115 			raw_cmd->reply_count = 0;
3116 		for (i = 0; i < raw_cmd->reply_count; i++)
3117 			raw_cmd->reply[i] = reply_buffer[i];
3118 
3119 		if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3120 			unsigned long flags;
3121 			flags = claim_dma_lock();
3122 			raw_cmd->length = fd_get_dma_residue();
3123 			release_dma_lock(flags);
3124 		}
3125 
3126 		if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3127 		    (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3128 			raw_cmd->flags |= FD_RAW_FAILURE;
3129 
3130 		if (disk_change(current_drive))
3131 			raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3132 		else
3133 			raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3134 		if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3135 			motor_off_callback(current_drive);
3136 
3137 		if (raw_cmd->next &&
3138 		    (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3139 		     !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3140 		    ((raw_cmd->flags & FD_RAW_FAILURE) ||
3141 		     !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3142 			raw_cmd = raw_cmd->next;
3143 			return;
3144 		}
3145 	}
3146 	generic_done(flag);
3147 }
3148 
3149 static struct cont_t raw_cmd_cont = {
3150 	.interrupt	= success_and_wakeup,
3151 	.redo		= floppy_start,
3152 	.error		= generic_failure,
3153 	.done		= raw_cmd_done
3154 };
3155 
3156 static inline int raw_cmd_copyout(int cmd, char __user *param,
3157 				  struct floppy_raw_cmd *ptr)
3158 {
3159 	int ret;
3160 
3161 	while (ptr) {
3162 		COPYOUT(*ptr);
3163 		param += sizeof(struct floppy_raw_cmd);
3164 		if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3165 			if (ptr->length >= 0
3166 			    && ptr->length <= ptr->buffer_length)
3167 				ECALL(fd_copyout
3168 				      (ptr->data, ptr->kernel_data,
3169 				       ptr->buffer_length - ptr->length));
3170 		}
3171 		ptr = ptr->next;
3172 	}
3173 	return 0;
3174 }
3175 
3176 static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3177 {
3178 	struct floppy_raw_cmd *next;
3179 	struct floppy_raw_cmd *this;
3180 
3181 	this = *ptr;
3182 	*ptr = NULL;
3183 	while (this) {
3184 		if (this->buffer_length) {
3185 			fd_dma_mem_free((unsigned long)this->kernel_data,
3186 					this->buffer_length);
3187 			this->buffer_length = 0;
3188 		}
3189 		next = this->next;
3190 		kfree(this);
3191 		this = next;
3192 	}
3193 }
3194 
3195 static inline int raw_cmd_copyin(int cmd, char __user *param,
3196 				 struct floppy_raw_cmd **rcmd)
3197 {
3198 	struct floppy_raw_cmd *ptr;
3199 	int ret;
3200 	int i;
3201 
3202 	*rcmd = NULL;
3203 	while (1) {
3204 		ptr = (struct floppy_raw_cmd *)
3205 		    kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3206 		if (!ptr)
3207 			return -ENOMEM;
3208 		*rcmd = ptr;
3209 		COPYIN(*ptr);
3210 		ptr->next = NULL;
3211 		ptr->buffer_length = 0;
3212 		param += sizeof(struct floppy_raw_cmd);
3213 		if (ptr->cmd_count > 33)
3214 			/* the command may now also take up the space
3215 			 * initially intended for the reply & the
3216 			 * reply count. Needed for long 82078 commands
3217 			 * such as RESTORE, which takes ... 17 command
3218 			 * bytes. Murphy's law #137: When you reserve
3219 			 * 16 bytes for a structure, you'll one day
3220 			 * discover that you really need 17...
3221 			 */
3222 			return -EINVAL;
3223 
3224 		for (i = 0; i < 16; i++)
3225 			ptr->reply[i] = 0;
3226 		ptr->resultcode = 0;
3227 		ptr->kernel_data = NULL;
3228 
3229 		if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3230 			if (ptr->length <= 0)
3231 				return -EINVAL;
3232 			ptr->kernel_data =
3233 			    (char *)fd_dma_mem_alloc(ptr->length);
3234 			fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3235 			if (!ptr->kernel_data)
3236 				return -ENOMEM;
3237 			ptr->buffer_length = ptr->length;
3238 		}
3239 		if (ptr->flags & FD_RAW_WRITE)
3240 			ECALL(fd_copyin(ptr->data, ptr->kernel_data,
3241 					ptr->length));
3242 		rcmd = &(ptr->next);
3243 		if (!(ptr->flags & FD_RAW_MORE))
3244 			return 0;
3245 		ptr->rate &= 0x43;
3246 	}
3247 }
3248 
3249 static int raw_cmd_ioctl(int cmd, void __user *param)
3250 {
3251 	struct floppy_raw_cmd *my_raw_cmd;
3252 	int drive;
3253 	int ret2;
3254 	int ret;
3255 
3256 	if (FDCS->rawcmd <= 1)
3257 		FDCS->rawcmd = 1;
3258 	for (drive = 0; drive < N_DRIVE; drive++) {
3259 		if (FDC(drive) != fdc)
3260 			continue;
3261 		if (drive == current_drive) {
3262 			if (UDRS->fd_ref > 1) {
3263 				FDCS->rawcmd = 2;
3264 				break;
3265 			}
3266 		} else if (UDRS->fd_ref) {
3267 			FDCS->rawcmd = 2;
3268 			break;
3269 		}
3270 	}
3271 
3272 	if (FDCS->reset)
3273 		return -EIO;
3274 
3275 	ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3276 	if (ret) {
3277 		raw_cmd_free(&my_raw_cmd);
3278 		return ret;
3279 	}
3280 
3281 	raw_cmd = my_raw_cmd;
3282 	cont = &raw_cmd_cont;
3283 	ret = wait_til_done(floppy_start, 1);
3284 #ifdef DCL_DEBUG
3285 	if (DP->flags & FD_DEBUG) {
3286 		DPRINT("calling disk change from raw_cmd ioctl\n");
3287 	}
3288 #endif
3289 
3290 	if (ret != -EINTR && FDCS->reset)
3291 		ret = -EIO;
3292 
3293 	DRS->track = NO_TRACK;
3294 
3295 	ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3296 	if (!ret)
3297 		ret = ret2;
3298 	raw_cmd_free(&my_raw_cmd);
3299 	return ret;
3300 }
3301 
3302 static int invalidate_drive(struct block_device *bdev)
3303 {
3304 	/* invalidate the buffer track to force a reread */
3305 	set_bit((long)bdev->bd_disk->private_data, &fake_change);
3306 	process_fd_request();
3307 	check_disk_change(bdev);
3308 	return 0;
3309 }
3310 
3311 static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
3312 			       int drive, int type, struct block_device *bdev)
3313 {
3314 	int cnt;
3315 
3316 	/* sanity checking for parameters. */
3317 	if (g->sect <= 0 ||
3318 	    g->head <= 0 ||
3319 	    g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3320 	    /* check if reserved bits are set */
3321 	    (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0)
3322 		return -EINVAL;
3323 	if (type) {
3324 		if (!capable(CAP_SYS_ADMIN))
3325 			return -EPERM;
3326 		mutex_lock(&open_lock);
3327 		LOCK_FDC(drive, 1);
3328 		floppy_type[type] = *g;
3329 		floppy_type[type].name = "user format";
3330 		for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3331 			floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3332 			    floppy_type[type].size + 1;
3333 		process_fd_request();
3334 		for (cnt = 0; cnt < N_DRIVE; cnt++) {
3335 			struct block_device *bdev = opened_bdev[cnt];
3336 			if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3337 				continue;
3338 			__invalidate_device(bdev);
3339 		}
3340 		mutex_unlock(&open_lock);
3341 	} else {
3342 		int oldStretch;
3343 		LOCK_FDC(drive, 1);
3344 		if (cmd != FDDEFPRM)
3345 			/* notice a disk change immediately, else
3346 			 * we lose our settings immediately*/
3347 			CALL(poll_drive(1, FD_RAW_NEED_DISK));
3348 		oldStretch = g->stretch;
3349 		user_params[drive] = *g;
3350 		if (buffer_drive == drive)
3351 			SUPBOUND(buffer_max, user_params[drive].sect);
3352 		current_type[drive] = &user_params[drive];
3353 		floppy_sizes[drive] = user_params[drive].size;
3354 		if (cmd == FDDEFPRM)
3355 			DRS->keep_data = -1;
3356 		else
3357 			DRS->keep_data = 1;
3358 		/* invalidation. Invalidate only when needed, i.e.
3359 		 * when there are already sectors in the buffer cache
3360 		 * whose number will change. This is useful, because
3361 		 * mtools often changes the geometry of the disk after
3362 		 * looking at the boot block */
3363 		if (DRS->maxblock > user_params[drive].sect ||
3364 		    DRS->maxtrack ||
3365 		    ((user_params[drive].sect ^ oldStretch) &
3366 		     (FD_SWAPSIDES | FD_SECTBASEMASK)))
3367 			invalidate_drive(bdev);
3368 		else
3369 			process_fd_request();
3370 	}
3371 	return 0;
3372 }
3373 
3374 /* handle obsolete ioctl's */
3375 static int ioctl_table[] = {
3376 	FDCLRPRM,
3377 	FDSETPRM,
3378 	FDDEFPRM,
3379 	FDGETPRM,
3380 	FDMSGON,
3381 	FDMSGOFF,
3382 	FDFMTBEG,
3383 	FDFMTTRK,
3384 	FDFMTEND,
3385 	FDSETEMSGTRESH,
3386 	FDFLUSH,
3387 	FDSETMAXERRS,
3388 	FDGETMAXERRS,
3389 	FDGETDRVTYP,
3390 	FDSETDRVPRM,
3391 	FDGETDRVPRM,
3392 	FDGETDRVSTAT,
3393 	FDPOLLDRVSTAT,
3394 	FDRESET,
3395 	FDGETFDCSTAT,
3396 	FDWERRORCLR,
3397 	FDWERRORGET,
3398 	FDRAWCMD,
3399 	FDEJECT,
3400 	FDTWADDLE
3401 };
3402 
3403 static inline int normalize_ioctl(int *cmd, int *size)
3404 {
3405 	int i;
3406 
3407 	for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3408 		if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3409 			*size = _IOC_SIZE(*cmd);
3410 			*cmd = ioctl_table[i];
3411 			if (*size > _IOC_SIZE(*cmd)) {
3412 				printk("ioctl not yet supported\n");
3413 				return -EFAULT;
3414 			}
3415 			return 0;
3416 		}
3417 	}
3418 	return -EINVAL;
3419 }
3420 
3421 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3422 {
3423 	if (type)
3424 		*g = &floppy_type[type];
3425 	else {
3426 		LOCK_FDC(drive, 0);
3427 		CALL(poll_drive(0, 0));
3428 		process_fd_request();
3429 		*g = current_type[drive];
3430 	}
3431 	if (!*g)
3432 		return -ENODEV;
3433 	return 0;
3434 }
3435 
3436 static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3437 {
3438 	int drive = (long)bdev->bd_disk->private_data;
3439 	int type = ITYPE(drive_state[drive].fd_device);
3440 	struct floppy_struct *g;
3441 	int ret;
3442 
3443 	ret = get_floppy_geometry(drive, type, &g);
3444 	if (ret)
3445 		return ret;
3446 
3447 	geo->heads = g->head;
3448 	geo->sectors = g->sect;
3449 	geo->cylinders = g->track;
3450 	return 0;
3451 }
3452 
3453 static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
3454 		    unsigned long param)
3455 {
3456 #define FD_IOCTL_ALLOWED (mode & (FMODE_WRITE|FMODE_WRITE_IOCTL))
3457 #define OUT(c,x) case c: outparam = (const char *) (x); break
3458 #define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
3459 
3460 	int drive = (long)bdev->bd_disk->private_data;
3461 	int type = ITYPE(UDRS->fd_device);
3462 	int i;
3463 	int ret;
3464 	int size;
3465 	union inparam {
3466 		struct floppy_struct g;	/* geometry */
3467 		struct format_descr f;
3468 		struct floppy_max_errors max_errors;
3469 		struct floppy_drive_params dp;
3470 	} inparam;		/* parameters coming from user space */
3471 	const char *outparam;	/* parameters passed back to user space */
3472 
3473 	/* convert compatibility eject ioctls into floppy eject ioctl.
3474 	 * We do this in order to provide a means to eject floppy disks before
3475 	 * installing the new fdutils package */
3476 	if (cmd == CDROMEJECT ||	/* CD-ROM eject */
3477 	    cmd == 0x6470 /* SunOS floppy eject */ ) {
3478 		DPRINT("obsolete eject ioctl\n");
3479 		DPRINT("please use floppycontrol --eject\n");
3480 		cmd = FDEJECT;
3481 	}
3482 
3483 	/* convert the old style command into a new style command */
3484 	if ((cmd & 0xff00) == 0x0200) {
3485 		ECALL(normalize_ioctl(&cmd, &size));
3486 	} else
3487 		return -EINVAL;
3488 
3489 	/* permission checks */
3490 	if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
3491 	    ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3492 		return -EPERM;
3493 
3494 	/* copyin */
3495 	CLEARSTRUCT(&inparam);
3496 	if (_IOC_DIR(cmd) & _IOC_WRITE)
3497 	    ECALL(fd_copyin((void __user *)param, &inparam, size))
3498 
3499 		switch (cmd) {
3500 		case FDEJECT:
3501 			if (UDRS->fd_ref != 1)
3502 				/* somebody else has this drive open */
3503 				return -EBUSY;
3504 			LOCK_FDC(drive, 1);
3505 
3506 			/* do the actual eject. Fails on
3507 			 * non-Sparc architectures */
3508 			ret = fd_eject(UNIT(drive));
3509 
3510 			USETF(FD_DISK_CHANGED);
3511 			USETF(FD_VERIFY);
3512 			process_fd_request();
3513 			return ret;
3514 		case FDCLRPRM:
3515 			LOCK_FDC(drive, 1);
3516 			current_type[drive] = NULL;
3517 			floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3518 			UDRS->keep_data = 0;
3519 			return invalidate_drive(bdev);
3520 		case FDSETPRM:
3521 		case FDDEFPRM:
3522 			return set_geometry(cmd, &inparam.g,
3523 					    drive, type, bdev);
3524 		case FDGETPRM:
3525 			ECALL(get_floppy_geometry(drive, type,
3526 						  (struct floppy_struct **)
3527 						  &outparam));
3528 			break;
3529 
3530 		case FDMSGON:
3531 			UDP->flags |= FTD_MSG;
3532 			return 0;
3533 		case FDMSGOFF:
3534 			UDP->flags &= ~FTD_MSG;
3535 			return 0;
3536 
3537 		case FDFMTBEG:
3538 			LOCK_FDC(drive, 1);
3539 			CALL(poll_drive(1, FD_RAW_NEED_DISK));
3540 			ret = UDRS->flags;
3541 			process_fd_request();
3542 			if (ret & FD_VERIFY)
3543 				return -ENODEV;
3544 			if (!(ret & FD_DISK_WRITABLE))
3545 				return -EROFS;
3546 			return 0;
3547 		case FDFMTTRK:
3548 			if (UDRS->fd_ref != 1)
3549 				return -EBUSY;
3550 			return do_format(drive, &inparam.f);
3551 		case FDFMTEND:
3552 		case FDFLUSH:
3553 			LOCK_FDC(drive, 1);
3554 			return invalidate_drive(bdev);
3555 
3556 		case FDSETEMSGTRESH:
3557 			UDP->max_errors.reporting =
3558 			    (unsigned short)(param & 0x0f);
3559 			return 0;
3560 			OUT(FDGETMAXERRS, &UDP->max_errors);
3561 			IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
3562 
3563 		case FDGETDRVTYP:
3564 			outparam = drive_name(type, drive);
3565 			SUPBOUND(size, strlen(outparam) + 1);
3566 			break;
3567 
3568 			IN(FDSETDRVPRM, UDP, dp);
3569 			OUT(FDGETDRVPRM, UDP);
3570 
3571 		case FDPOLLDRVSTAT:
3572 			LOCK_FDC(drive, 1);
3573 			CALL(poll_drive(1, FD_RAW_NEED_DISK));
3574 			process_fd_request();
3575 			/* fall through */
3576 			OUT(FDGETDRVSTAT, UDRS);
3577 
3578 		case FDRESET:
3579 			return user_reset_fdc(drive, (int)param, 1);
3580 
3581 			OUT(FDGETFDCSTAT, UFDCS);
3582 
3583 		case FDWERRORCLR:
3584 			CLEARSTRUCT(UDRWE);
3585 			return 0;
3586 			OUT(FDWERRORGET, UDRWE);
3587 
3588 		case FDRAWCMD:
3589 			if (type)
3590 				return -EINVAL;
3591 			LOCK_FDC(drive, 1);
3592 			set_floppy(drive);
3593 			CALL(i = raw_cmd_ioctl(cmd, (void __user *)param));
3594 			process_fd_request();
3595 			return i;
3596 
3597 		case FDTWADDLE:
3598 			LOCK_FDC(drive, 1);
3599 			twaddle();
3600 			process_fd_request();
3601 			return 0;
3602 
3603 		default:
3604 			return -EINVAL;
3605 		}
3606 
3607 	if (_IOC_DIR(cmd) & _IOC_READ)
3608 		return fd_copyout((void __user *)param, outparam, size);
3609 	else
3610 		return 0;
3611 #undef OUT
3612 #undef IN
3613 }
3614 
3615 static void __init config_types(void)
3616 {
3617 	int first = 1;
3618 	int drive;
3619 
3620 	/* read drive info out of physical CMOS */
3621 	drive = 0;
3622 	if (!UDP->cmos)
3623 		UDP->cmos = FLOPPY0_TYPE;
3624 	drive = 1;
3625 	if (!UDP->cmos && FLOPPY1_TYPE)
3626 		UDP->cmos = FLOPPY1_TYPE;
3627 
3628 	/* FIXME: additional physical CMOS drive detection should go here */
3629 
3630 	for (drive = 0; drive < N_DRIVE; drive++) {
3631 		unsigned int type = UDP->cmos;
3632 		struct floppy_drive_params *params;
3633 		const char *name = NULL;
3634 		static char temparea[32];
3635 
3636 		if (type < ARRAY_SIZE(default_drive_params)) {
3637 			params = &default_drive_params[type].params;
3638 			if (type) {
3639 				name = default_drive_params[type].name;
3640 				allowed_drive_mask |= 1 << drive;
3641 			} else
3642 				allowed_drive_mask &= ~(1 << drive);
3643 		} else {
3644 			params = &default_drive_params[0].params;
3645 			sprintf(temparea, "unknown type %d (usb?)", type);
3646 			name = temparea;
3647 		}
3648 		if (name) {
3649 			const char *prepend = ",";
3650 			if (first) {
3651 				prepend = KERN_INFO "Floppy drive(s):";
3652 				first = 0;
3653 			}
3654 			printk("%s fd%d is %s", prepend, drive, name);
3655 		}
3656 		*UDP = *params;
3657 	}
3658 	if (!first)
3659 		printk("\n");
3660 }
3661 
3662 static int floppy_release(struct gendisk *disk, fmode_t mode)
3663 {
3664 	int drive = (long)disk->private_data;
3665 
3666 	mutex_lock(&open_lock);
3667 	if (UDRS->fd_ref < 0)
3668 		UDRS->fd_ref = 0;
3669 	else if (!UDRS->fd_ref--) {
3670 		DPRINT("floppy_release with fd_ref == 0");
3671 		UDRS->fd_ref = 0;
3672 	}
3673 	if (!UDRS->fd_ref)
3674 		opened_bdev[drive] = NULL;
3675 	mutex_unlock(&open_lock);
3676 
3677 	return 0;
3678 }
3679 
3680 /*
3681  * floppy_open check for aliasing (/dev/fd0 can be the same as
3682  * /dev/PS0 etc), and disallows simultaneous access to the same
3683  * drive with different device numbers.
3684  */
3685 static int floppy_open(struct block_device *bdev, fmode_t mode)
3686 {
3687 	int drive = (long)bdev->bd_disk->private_data;
3688 	int old_dev, new_dev;
3689 	int try;
3690 	int res = -EBUSY;
3691 	char *tmp;
3692 
3693 	mutex_lock(&open_lock);
3694 	old_dev = UDRS->fd_device;
3695 	if (opened_bdev[drive] && opened_bdev[drive] != bdev)
3696 		goto out2;
3697 
3698 	if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
3699 		USETF(FD_DISK_CHANGED);
3700 		USETF(FD_VERIFY);
3701 	}
3702 
3703 	if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (mode & FMODE_EXCL)))
3704 		goto out2;
3705 
3706 	if (mode & FMODE_EXCL)
3707 		UDRS->fd_ref = -1;
3708 	else
3709 		UDRS->fd_ref++;
3710 
3711 	opened_bdev[drive] = bdev;
3712 
3713 	res = -ENXIO;
3714 
3715 	if (!floppy_track_buffer) {
3716 		/* if opening an ED drive, reserve a big buffer,
3717 		 * else reserve a small one */
3718 		if ((UDP->cmos == 6) || (UDP->cmos == 5))
3719 			try = 64;	/* Only 48 actually useful */
3720 		else
3721 			try = 32;	/* Only 24 actually useful */
3722 
3723 		tmp = (char *)fd_dma_mem_alloc(1024 * try);
3724 		if (!tmp && !floppy_track_buffer) {
3725 			try >>= 1;	/* buffer only one side */
3726 			INFBOUND(try, 16);
3727 			tmp = (char *)fd_dma_mem_alloc(1024 * try);
3728 		}
3729 		if (!tmp && !floppy_track_buffer) {
3730 			fallback_on_nodma_alloc(&tmp, 2048 * try);
3731 		}
3732 		if (!tmp && !floppy_track_buffer) {
3733 			DPRINT("Unable to allocate DMA memory\n");
3734 			goto out;
3735 		}
3736 		if (floppy_track_buffer) {
3737 			if (tmp)
3738 				fd_dma_mem_free((unsigned long)tmp, try * 1024);
3739 		} else {
3740 			buffer_min = buffer_max = -1;
3741 			floppy_track_buffer = tmp;
3742 			max_buffer_sectors = try;
3743 		}
3744 	}
3745 
3746 	new_dev = MINOR(bdev->bd_dev);
3747 	UDRS->fd_device = new_dev;
3748 	set_capacity(disks[drive], floppy_sizes[new_dev]);
3749 	if (old_dev != -1 && old_dev != new_dev) {
3750 		if (buffer_drive == drive)
3751 			buffer_track = -1;
3752 	}
3753 
3754 	if (UFDCS->rawcmd == 1)
3755 		UFDCS->rawcmd = 2;
3756 
3757 	if (!(mode & FMODE_NDELAY)) {
3758 		if (mode & (FMODE_READ|FMODE_WRITE)) {
3759 			UDRS->last_checked = 0;
3760 			check_disk_change(bdev);
3761 			if (UTESTF(FD_DISK_CHANGED))
3762 				goto out;
3763 		}
3764 		res = -EROFS;
3765 		if ((mode & FMODE_WRITE) && !(UTESTF(FD_DISK_WRITABLE)))
3766 			goto out;
3767 	}
3768 	mutex_unlock(&open_lock);
3769 	return 0;
3770 out:
3771 	if (UDRS->fd_ref < 0)
3772 		UDRS->fd_ref = 0;
3773 	else
3774 		UDRS->fd_ref--;
3775 	if (!UDRS->fd_ref)
3776 		opened_bdev[drive] = NULL;
3777 out2:
3778 	mutex_unlock(&open_lock);
3779 	return res;
3780 }
3781 
3782 /*
3783  * Check if the disk has been changed or if a change has been faked.
3784  */
3785 static int check_floppy_change(struct gendisk *disk)
3786 {
3787 	int drive = (long)disk->private_data;
3788 
3789 	if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
3790 		return 1;
3791 
3792 	if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
3793 		lock_fdc(drive, 0);
3794 		poll_drive(0, 0);
3795 		process_fd_request();
3796 	}
3797 
3798 	if (UTESTF(FD_DISK_CHANGED) ||
3799 	    UTESTF(FD_VERIFY) ||
3800 	    test_bit(drive, &fake_change) ||
3801 	    (!ITYPE(UDRS->fd_device) && !current_type[drive]))
3802 		return 1;
3803 	return 0;
3804 }
3805 
3806 /*
3807  * This implements "read block 0" for floppy_revalidate().
3808  * Needed for format autodetection, checking whether there is
3809  * a disk in the drive, and whether that disk is writable.
3810  */
3811 
3812 static void floppy_rb0_complete(struct bio *bio,
3813 			       int err)
3814 {
3815 	complete((struct completion *)bio->bi_private);
3816 }
3817 
3818 static int __floppy_read_block_0(struct block_device *bdev)
3819 {
3820 	struct bio bio;
3821 	struct bio_vec bio_vec;
3822 	struct completion complete;
3823 	struct page *page;
3824 	size_t size;
3825 
3826 	page = alloc_page(GFP_NOIO);
3827 	if (!page) {
3828 		process_fd_request();
3829 		return -ENOMEM;
3830 	}
3831 
3832 	size = bdev->bd_block_size;
3833 	if (!size)
3834 		size = 1024;
3835 
3836 	bio_init(&bio);
3837 	bio.bi_io_vec = &bio_vec;
3838 	bio_vec.bv_page = page;
3839 	bio_vec.bv_len = size;
3840 	bio_vec.bv_offset = 0;
3841 	bio.bi_vcnt = 1;
3842 	bio.bi_idx = 0;
3843 	bio.bi_size = size;
3844 	bio.bi_bdev = bdev;
3845 	bio.bi_sector = 0;
3846 	init_completion(&complete);
3847 	bio.bi_private = &complete;
3848 	bio.bi_end_io = floppy_rb0_complete;
3849 
3850 	submit_bio(READ, &bio);
3851 	generic_unplug_device(bdev_get_queue(bdev));
3852 	process_fd_request();
3853 	wait_for_completion(&complete);
3854 
3855 	__free_page(page);
3856 
3857 	return 0;
3858 }
3859 
3860 /* revalidate the floppy disk, i.e. trigger format autodetection by reading
3861  * the bootblock (block 0). "Autodetection" is also needed to check whether
3862  * there is a disk in the drive at all... Thus we also do it for fixed
3863  * geometry formats */
3864 static int floppy_revalidate(struct gendisk *disk)
3865 {
3866 	int drive = (long)disk->private_data;
3867 #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
3868 	int cf;
3869 	int res = 0;
3870 
3871 	if (UTESTF(FD_DISK_CHANGED) ||
3872 	    UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
3873 		if (usage_count == 0) {
3874 			printk("VFS: revalidate called on non-open device.\n");
3875 			return -EFAULT;
3876 		}
3877 		lock_fdc(drive, 0);
3878 		cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
3879 		if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
3880 			process_fd_request();	/*already done by another thread */
3881 			return 0;
3882 		}
3883 		UDRS->maxblock = 0;
3884 		UDRS->maxtrack = 0;
3885 		if (buffer_drive == drive)
3886 			buffer_track = -1;
3887 		clear_bit(drive, &fake_change);
3888 		UCLEARF(FD_DISK_CHANGED);
3889 		if (cf)
3890 			UDRS->generation++;
3891 		if (NO_GEOM) {
3892 			/* auto-sensing */
3893 			res = __floppy_read_block_0(opened_bdev[drive]);
3894 		} else {
3895 			if (cf)
3896 				poll_drive(0, FD_RAW_NEED_DISK);
3897 			process_fd_request();
3898 		}
3899 	}
3900 	set_capacity(disk, floppy_sizes[UDRS->fd_device]);
3901 	return res;
3902 }
3903 
3904 static struct block_device_operations floppy_fops = {
3905 	.owner			= THIS_MODULE,
3906 	.open			= floppy_open,
3907 	.release		= floppy_release,
3908 	.locked_ioctl		= fd_ioctl,
3909 	.getgeo			= fd_getgeo,
3910 	.media_changed		= check_floppy_change,
3911 	.revalidate_disk	= floppy_revalidate,
3912 };
3913 
3914 /*
3915  * Floppy Driver initialization
3916  * =============================
3917  */
3918 
3919 /* Determine the floppy disk controller type */
3920 /* This routine was written by David C. Niemi */
3921 static char __init get_fdc_version(void)
3922 {
3923 	int r;
3924 
3925 	output_byte(FD_DUMPREGS);	/* 82072 and better know DUMPREGS */
3926 	if (FDCS->reset)
3927 		return FDC_NONE;
3928 	if ((r = result()) <= 0x00)
3929 		return FDC_NONE;	/* No FDC present ??? */
3930 	if ((r == 1) && (reply_buffer[0] == 0x80)) {
3931 		printk(KERN_INFO "FDC %d is an 8272A\n", fdc);
3932 		return FDC_8272A;	/* 8272a/765 don't know DUMPREGS */
3933 	}
3934 	if (r != 10) {
3935 		printk
3936 		    ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
3937 		     fdc, r);
3938 		return FDC_UNKNOWN;
3939 	}
3940 
3941 	if (!fdc_configure()) {
3942 		printk(KERN_INFO "FDC %d is an 82072\n", fdc);
3943 		return FDC_82072;	/* 82072 doesn't know CONFIGURE */
3944 	}
3945 
3946 	output_byte(FD_PERPENDICULAR);
3947 	if (need_more_output() == MORE_OUTPUT) {
3948 		output_byte(0);
3949 	} else {
3950 		printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
3951 		return FDC_82072A;	/* 82072A as found on Sparcs. */
3952 	}
3953 
3954 	output_byte(FD_UNLOCK);
3955 	r = result();
3956 	if ((r == 1) && (reply_buffer[0] == 0x80)) {
3957 		printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
3958 		return FDC_82077_ORIG;	/* Pre-1991 82077, doesn't know
3959 					 * LOCK/UNLOCK */
3960 	}
3961 	if ((r != 1) || (reply_buffer[0] != 0x00)) {
3962 		printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
3963 		       fdc, r);
3964 		return FDC_UNKNOWN;
3965 	}
3966 	output_byte(FD_PARTID);
3967 	r = result();
3968 	if (r != 1) {
3969 		printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
3970 		       fdc, r);
3971 		return FDC_UNKNOWN;
3972 	}
3973 	if (reply_buffer[0] == 0x80) {
3974 		printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);
3975 		return FDC_82077;	/* Revised 82077AA passes all the tests */
3976 	}
3977 	switch (reply_buffer[0] >> 5) {
3978 	case 0x0:
3979 		/* Either a 82078-1 or a 82078SL running at 5Volt */
3980 		printk(KERN_INFO "FDC %d is an 82078.\n", fdc);
3981 		return FDC_82078;
3982 	case 0x1:
3983 		printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);
3984 		return FDC_82078;
3985 	case 0x2:
3986 		printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
3987 		return FDC_S82078B;
3988 	case 0x3:
3989 		printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",
3990 		       fdc);
3991 		return FDC_87306;
3992 	default:
3993 		printk(KERN_INFO
3994 		       "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
3995 		       fdc, reply_buffer[0] >> 5);
3996 		return FDC_82078_UNKN;
3997 	}
3998 }				/* get_fdc_version */
3999 
4000 /* lilo configuration */
4001 
4002 static void __init floppy_set_flags(int *ints, int param, int param2)
4003 {
4004 	int i;
4005 
4006 	for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4007 		if (param)
4008 			default_drive_params[i].params.flags |= param2;
4009 		else
4010 			default_drive_params[i].params.flags &= ~param2;
4011 	}
4012 	DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4013 }
4014 
4015 static void __init daring(int *ints, int param, int param2)
4016 {
4017 	int i;
4018 
4019 	for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4020 		if (param) {
4021 			default_drive_params[i].params.select_delay = 0;
4022 			default_drive_params[i].params.flags |=
4023 			    FD_SILENT_DCL_CLEAR;
4024 		} else {
4025 			default_drive_params[i].params.select_delay =
4026 			    2 * HZ / 100;
4027 			default_drive_params[i].params.flags &=
4028 			    ~FD_SILENT_DCL_CLEAR;
4029 		}
4030 	}
4031 	DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4032 }
4033 
4034 static void __init set_cmos(int *ints, int dummy, int dummy2)
4035 {
4036 	int current_drive = 0;
4037 
4038 	if (ints[0] != 2) {
4039 		DPRINT("wrong number of parameters for CMOS\n");
4040 		return;
4041 	}
4042 	current_drive = ints[1];
4043 	if (current_drive < 0 || current_drive >= 8) {
4044 		DPRINT("bad drive for set_cmos\n");
4045 		return;
4046 	}
4047 #if N_FDC > 1
4048 	if (current_drive >= 4 && !FDC2)
4049 		FDC2 = 0x370;
4050 #endif
4051 	DP->cmos = ints[2];
4052 	DPRINT("setting CMOS code to %d\n", ints[2]);
4053 }
4054 
4055 static struct param_table {
4056 	const char *name;
4057 	void (*fn) (int *ints, int param, int param2);
4058 	int *var;
4059 	int def_param;
4060 	int param2;
4061 } config_params[] __initdata = {
4062 	{"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4063 	{"all_drives", NULL, &allowed_drive_mask, 0xff, 0},	/* obsolete */
4064 	{"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
4065 	{"irq", NULL, &FLOPPY_IRQ, 6, 0},
4066 	{"dma", NULL, &FLOPPY_DMA, 2, 0},
4067 	{"daring", daring, NULL, 1, 0},
4068 #if N_FDC > 1
4069 	{"two_fdc", NULL, &FDC2, 0x370, 0},
4070 	{"one_fdc", NULL, &FDC2, 0, 0},
4071 #endif
4072 	{"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
4073 	{"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
4074 	{"messages", floppy_set_flags, NULL, 1, FTD_MSG},
4075 	{"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
4076 	{"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
4077 	{"nodma", NULL, &can_use_virtual_dma, 1, 0},
4078 	{"omnibook", NULL, &can_use_virtual_dma, 1, 0},
4079 	{"yesdma", NULL, &can_use_virtual_dma, 0, 0},
4080 	{"fifo_depth", NULL, &fifo_depth, 0xa, 0},
4081 	{"nofifo", NULL, &no_fifo, 0x20, 0},
4082 	{"usefifo", NULL, &no_fifo, 0, 0},
4083 	{"cmos", set_cmos, NULL, 0, 0},
4084 	{"slow", NULL, &slow_floppy, 1, 0},
4085 	{"unexpected_interrupts", NULL, &print_unex, 1, 0},
4086 	{"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
4087 	{"L40SX", NULL, &print_unex, 0, 0}
4088 
4089 	EXTRA_FLOPPY_PARAMS
4090 };
4091 
4092 static int __init floppy_setup(char *str)
4093 {
4094 	int i;
4095 	int param;
4096 	int ints[11];
4097 
4098 	str = get_options(str, ARRAY_SIZE(ints), ints);
4099 	if (str) {
4100 		for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4101 			if (strcmp(str, config_params[i].name) == 0) {
4102 				if (ints[0])
4103 					param = ints[1];
4104 				else
4105 					param = config_params[i].def_param;
4106 				if (config_params[i].fn)
4107 					config_params[i].
4108 					    fn(ints, param,
4109 					       config_params[i].param2);
4110 				if (config_params[i].var) {
4111 					DPRINT("%s=%d\n", str, param);
4112 					*config_params[i].var = param;
4113 				}
4114 				return 1;
4115 			}
4116 		}
4117 	}
4118 	if (str) {
4119 		DPRINT("unknown floppy option [%s]\n", str);
4120 
4121 		DPRINT("allowed options are:");
4122 		for (i = 0; i < ARRAY_SIZE(config_params); i++)
4123 			printk(" %s", config_params[i].name);
4124 		printk("\n");
4125 	} else
4126 		DPRINT("botched floppy option\n");
4127 	DPRINT("Read Documentation/floppy.txt\n");
4128 	return 0;
4129 }
4130 
4131 static int have_no_fdc = -ENODEV;
4132 
4133 static ssize_t floppy_cmos_show(struct device *dev,
4134 				struct device_attribute *attr, char *buf)
4135 {
4136 	struct platform_device *p;
4137 	int drive;
4138 
4139 	p = container_of(dev, struct platform_device,dev);
4140 	drive = p->id;
4141 	return sprintf(buf, "%X\n", UDP->cmos);
4142 }
4143 DEVICE_ATTR(cmos,S_IRUGO,floppy_cmos_show,NULL);
4144 
4145 static void floppy_device_release(struct device *dev)
4146 {
4147 }
4148 
4149 static struct platform_device floppy_device[N_DRIVE];
4150 
4151 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4152 {
4153 	int drive = (*part & 3) | ((*part & 0x80) >> 5);
4154 	if (drive >= N_DRIVE ||
4155 	    !(allowed_drive_mask & (1 << drive)) ||
4156 	    fdc_state[FDC(drive)].version == FDC_NONE)
4157 		return NULL;
4158 	if (((*part >> 2) & 0x1f) >= ARRAY_SIZE(floppy_type))
4159 		return NULL;
4160 	*part = 0;
4161 	return get_disk(disks[drive]);
4162 }
4163 
4164 static int __init floppy_init(void)
4165 {
4166 	int i, unit, drive;
4167 	int err, dr;
4168 
4169 #if defined(CONFIG_PPC)
4170 	if (check_legacy_ioport(FDC1))
4171 		return -ENODEV;
4172 #endif
4173 
4174 	raw_cmd = NULL;
4175 
4176 	for (dr = 0; dr < N_DRIVE; dr++) {
4177 		disks[dr] = alloc_disk(1);
4178 		if (!disks[dr]) {
4179 			err = -ENOMEM;
4180 			goto out_put_disk;
4181 		}
4182 
4183 		disks[dr]->major = FLOPPY_MAJOR;
4184 		disks[dr]->first_minor = TOMINOR(dr);
4185 		disks[dr]->fops = &floppy_fops;
4186 		sprintf(disks[dr]->disk_name, "fd%d", dr);
4187 
4188 		init_timer(&motor_off_timer[dr]);
4189 		motor_off_timer[dr].data = dr;
4190 		motor_off_timer[dr].function = motor_off_callback;
4191 	}
4192 
4193 	err = register_blkdev(FLOPPY_MAJOR, "fd");
4194 	if (err)
4195 		goto out_put_disk;
4196 
4197 	floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
4198 	if (!floppy_queue) {
4199 		err = -ENOMEM;
4200 		goto out_unreg_blkdev;
4201 	}
4202 	blk_queue_max_sectors(floppy_queue, 64);
4203 
4204 	blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4205 			    floppy_find, NULL, NULL);
4206 
4207 	for (i = 0; i < 256; i++)
4208 		if (ITYPE(i))
4209 			floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4210 		else
4211 			floppy_sizes[i] = MAX_DISK_SIZE << 1;
4212 
4213 	reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
4214 	config_types();
4215 
4216 	for (i = 0; i < N_FDC; i++) {
4217 		fdc = i;
4218 		CLEARSTRUCT(FDCS);
4219 		FDCS->dtr = -1;
4220 		FDCS->dor = 0x4;
4221 #if defined(__sparc__) || defined(__mc68000__)
4222 		/*sparcs/sun3x don't have a DOR reset which we can fall back on to */
4223 #ifdef __mc68000__
4224 		if (MACH_IS_SUN3X)
4225 #endif
4226 			FDCS->version = FDC_82072A;
4227 #endif
4228 	}
4229 
4230 	use_virtual_dma = can_use_virtual_dma & 1;
4231 	fdc_state[0].address = FDC1;
4232 	if (fdc_state[0].address == -1) {
4233 		del_timer(&fd_timeout);
4234 		err = -ENODEV;
4235 		goto out_unreg_region;
4236 	}
4237 #if N_FDC > 1
4238 	fdc_state[1].address = FDC2;
4239 #endif
4240 
4241 	fdc = 0;		/* reset fdc in case of unexpected interrupt */
4242 	err = floppy_grab_irq_and_dma();
4243 	if (err) {
4244 		del_timer(&fd_timeout);
4245 		err = -EBUSY;
4246 		goto out_unreg_region;
4247 	}
4248 
4249 	/* initialise drive state */
4250 	for (drive = 0; drive < N_DRIVE; drive++) {
4251 		CLEARSTRUCT(UDRS);
4252 		CLEARSTRUCT(UDRWE);
4253 		USETF(FD_DISK_NEWCHANGE);
4254 		USETF(FD_DISK_CHANGED);
4255 		USETF(FD_VERIFY);
4256 		UDRS->fd_device = -1;
4257 		floppy_track_buffer = NULL;
4258 		max_buffer_sectors = 0;
4259 	}
4260 	/*
4261 	 * Small 10 msec delay to let through any interrupt that
4262 	 * initialization might have triggered, to not
4263 	 * confuse detection:
4264 	 */
4265 	msleep(10);
4266 
4267 	for (i = 0; i < N_FDC; i++) {
4268 		fdc = i;
4269 		FDCS->driver_version = FD_DRIVER_VERSION;
4270 		for (unit = 0; unit < 4; unit++)
4271 			FDCS->track[unit] = 0;
4272 		if (FDCS->address == -1)
4273 			continue;
4274 		FDCS->rawcmd = 2;
4275 		if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
4276 			/* free ioports reserved by floppy_grab_irq_and_dma() */
4277 			release_region(FDCS->address + 2, 4);
4278 			release_region(FDCS->address + 7, 1);
4279 			FDCS->address = -1;
4280 			FDCS->version = FDC_NONE;
4281 			continue;
4282 		}
4283 		/* Try to determine the floppy controller type */
4284 		FDCS->version = get_fdc_version();
4285 		if (FDCS->version == FDC_NONE) {
4286 			/* free ioports reserved by floppy_grab_irq_and_dma() */
4287 			release_region(FDCS->address + 2, 4);
4288 			release_region(FDCS->address + 7, 1);
4289 			FDCS->address = -1;
4290 			continue;
4291 		}
4292 		if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
4293 			can_use_virtual_dma = 0;
4294 
4295 		have_no_fdc = 0;
4296 		/* Not all FDCs seem to be able to handle the version command
4297 		 * properly, so force a reset for the standard FDC clones,
4298 		 * to avoid interrupt garbage.
4299 		 */
4300 		user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
4301 	}
4302 	fdc = 0;
4303 	del_timer(&fd_timeout);
4304 	current_drive = 0;
4305 	initialising = 0;
4306 	if (have_no_fdc) {
4307 		DPRINT("no floppy controllers found\n");
4308 		err = have_no_fdc;
4309 		goto out_flush_work;
4310 	}
4311 
4312 	for (drive = 0; drive < N_DRIVE; drive++) {
4313 		if (!(allowed_drive_mask & (1 << drive)))
4314 			continue;
4315 		if (fdc_state[FDC(drive)].version == FDC_NONE)
4316 			continue;
4317 
4318 		floppy_device[drive].name = floppy_device_name;
4319 		floppy_device[drive].id = drive;
4320 		floppy_device[drive].dev.release = floppy_device_release;
4321 
4322 		err = platform_device_register(&floppy_device[drive]);
4323 		if (err)
4324 			goto out_flush_work;
4325 
4326 		err = device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
4327 		if (err)
4328 			goto out_unreg_platform_dev;
4329 
4330 		/* to be cleaned up... */
4331 		disks[drive]->private_data = (void *)(long)drive;
4332 		disks[drive]->queue = floppy_queue;
4333 		disks[drive]->flags |= GENHD_FL_REMOVABLE;
4334 		disks[drive]->driverfs_dev = &floppy_device[drive].dev;
4335 		add_disk(disks[drive]);
4336 	}
4337 
4338 	return 0;
4339 
4340 out_unreg_platform_dev:
4341 	platform_device_unregister(&floppy_device[drive]);
4342 out_flush_work:
4343 	flush_scheduled_work();
4344 	if (usage_count)
4345 		floppy_release_irq_and_dma();
4346 out_unreg_region:
4347 	blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4348 	blk_cleanup_queue(floppy_queue);
4349 out_unreg_blkdev:
4350 	unregister_blkdev(FLOPPY_MAJOR, "fd");
4351 out_put_disk:
4352 	while (dr--) {
4353 		del_timer(&motor_off_timer[dr]);
4354 		put_disk(disks[dr]);
4355 	}
4356 	return err;
4357 }
4358 
4359 static DEFINE_SPINLOCK(floppy_usage_lock);
4360 
4361 static int floppy_grab_irq_and_dma(void)
4362 {
4363 	unsigned long flags;
4364 
4365 	spin_lock_irqsave(&floppy_usage_lock, flags);
4366 	if (usage_count++) {
4367 		spin_unlock_irqrestore(&floppy_usage_lock, flags);
4368 		return 0;
4369 	}
4370 	spin_unlock_irqrestore(&floppy_usage_lock, flags);
4371 
4372 	/*
4373 	 * We might have scheduled a free_irq(), wait it to
4374 	 * drain first:
4375 	 */
4376 	flush_scheduled_work();
4377 
4378 	if (fd_request_irq()) {
4379 		DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4380 		       FLOPPY_IRQ);
4381 		spin_lock_irqsave(&floppy_usage_lock, flags);
4382 		usage_count--;
4383 		spin_unlock_irqrestore(&floppy_usage_lock, flags);
4384 		return -1;
4385 	}
4386 	if (fd_request_dma()) {
4387 		DPRINT("Unable to grab DMA%d for the floppy driver\n",
4388 		       FLOPPY_DMA);
4389 		if (can_use_virtual_dma & 2)
4390 			use_virtual_dma = can_use_virtual_dma = 1;
4391 		if (!(can_use_virtual_dma & 1)) {
4392 			fd_free_irq();
4393 			spin_lock_irqsave(&floppy_usage_lock, flags);
4394 			usage_count--;
4395 			spin_unlock_irqrestore(&floppy_usage_lock, flags);
4396 			return -1;
4397 		}
4398 	}
4399 
4400 	for (fdc = 0; fdc < N_FDC; fdc++) {
4401 		if (FDCS->address != -1) {
4402 			if (!request_region(FDCS->address + 2, 4, "floppy")) {
4403 				DPRINT("Floppy io-port 0x%04lx in use\n",
4404 				       FDCS->address + 2);
4405 				goto cleanup1;
4406 			}
4407 			if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
4408 				DPRINT("Floppy io-port 0x%04lx in use\n",
4409 				       FDCS->address + 7);
4410 				goto cleanup2;
4411 			}
4412 			/* address + 6 is reserved, and may be taken by IDE.
4413 			 * Unfortunately, Adaptec doesn't know this :-(, */
4414 		}
4415 	}
4416 	for (fdc = 0; fdc < N_FDC; fdc++) {
4417 		if (FDCS->address != -1) {
4418 			reset_fdc_info(1);
4419 			fd_outb(FDCS->dor, FD_DOR);
4420 		}
4421 	}
4422 	fdc = 0;
4423 	set_dor(0, ~0, 8);	/* avoid immediate interrupt */
4424 
4425 	for (fdc = 0; fdc < N_FDC; fdc++)
4426 		if (FDCS->address != -1)
4427 			fd_outb(FDCS->dor, FD_DOR);
4428 	/*
4429 	 * The driver will try and free resources and relies on us
4430 	 * to know if they were allocated or not.
4431 	 */
4432 	fdc = 0;
4433 	irqdma_allocated = 1;
4434 	return 0;
4435 cleanup2:
4436 	release_region(FDCS->address + 2, 4);
4437 cleanup1:
4438 	fd_free_irq();
4439 	fd_free_dma();
4440 	while (--fdc >= 0) {
4441 		release_region(FDCS->address + 2, 4);
4442 		release_region(FDCS->address + 7, 1);
4443 	}
4444 	spin_lock_irqsave(&floppy_usage_lock, flags);
4445 	usage_count--;
4446 	spin_unlock_irqrestore(&floppy_usage_lock, flags);
4447 	return -1;
4448 }
4449 
4450 static void floppy_release_irq_and_dma(void)
4451 {
4452 	int old_fdc;
4453 #ifdef FLOPPY_SANITY_CHECK
4454 #ifndef __sparc__
4455 	int drive;
4456 #endif
4457 #endif
4458 	long tmpsize;
4459 	unsigned long tmpaddr;
4460 	unsigned long flags;
4461 
4462 	spin_lock_irqsave(&floppy_usage_lock, flags);
4463 	if (--usage_count) {
4464 		spin_unlock_irqrestore(&floppy_usage_lock, flags);
4465 		return;
4466 	}
4467 	spin_unlock_irqrestore(&floppy_usage_lock, flags);
4468 	if (irqdma_allocated) {
4469 		fd_disable_dma();
4470 		fd_free_dma();
4471 		fd_free_irq();
4472 		irqdma_allocated = 0;
4473 	}
4474 	set_dor(0, ~0, 8);
4475 #if N_FDC > 1
4476 	set_dor(1, ~8, 0);
4477 #endif
4478 	floppy_enable_hlt();
4479 
4480 	if (floppy_track_buffer && max_buffer_sectors) {
4481 		tmpsize = max_buffer_sectors * 1024;
4482 		tmpaddr = (unsigned long)floppy_track_buffer;
4483 		floppy_track_buffer = NULL;
4484 		max_buffer_sectors = 0;
4485 		buffer_min = buffer_max = -1;
4486 		fd_dma_mem_free(tmpaddr, tmpsize);
4487 	}
4488 #ifdef FLOPPY_SANITY_CHECK
4489 #ifndef __sparc__
4490 	for (drive = 0; drive < N_FDC * 4; drive++)
4491 		if (timer_pending(motor_off_timer + drive))
4492 			printk("motor off timer %d still active\n", drive);
4493 #endif
4494 
4495 	if (timer_pending(&fd_timeout))
4496 		printk("floppy timer still active:%s\n", timeout_message);
4497 	if (timer_pending(&fd_timer))
4498 		printk("auxiliary floppy timer still active\n");
4499 	if (work_pending(&floppy_work))
4500 		printk("work still pending\n");
4501 #endif
4502 	old_fdc = fdc;
4503 	for (fdc = 0; fdc < N_FDC; fdc++)
4504 		if (FDCS->address != -1) {
4505 			release_region(FDCS->address + 2, 4);
4506 			release_region(FDCS->address + 7, 1);
4507 		}
4508 	fdc = old_fdc;
4509 }
4510 
4511 #ifdef MODULE
4512 
4513 static char *floppy;
4514 
4515 static void __init parse_floppy_cfg_string(char *cfg)
4516 {
4517 	char *ptr;
4518 
4519 	while (*cfg) {
4520 		for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != '\t'; cfg++) ;
4521 		if (*cfg) {
4522 			*cfg = '\0';
4523 			cfg++;
4524 		}
4525 		if (*ptr)
4526 			floppy_setup(ptr);
4527 	}
4528 }
4529 
4530 static int __init floppy_module_init(void)
4531 {
4532 	if (floppy)
4533 		parse_floppy_cfg_string(floppy);
4534 	return floppy_init();
4535 }
4536 module_init(floppy_module_init);
4537 
4538 static void __exit floppy_module_exit(void)
4539 {
4540 	int drive;
4541 
4542 	blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4543 	unregister_blkdev(FLOPPY_MAJOR, "fd");
4544 
4545 	for (drive = 0; drive < N_DRIVE; drive++) {
4546 		del_timer_sync(&motor_off_timer[drive]);
4547 
4548 		if ((allowed_drive_mask & (1 << drive)) &&
4549 		    fdc_state[FDC(drive)].version != FDC_NONE) {
4550 			del_gendisk(disks[drive]);
4551 			device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
4552 			platform_device_unregister(&floppy_device[drive]);
4553 		}
4554 		put_disk(disks[drive]);
4555 	}
4556 
4557 	del_timer_sync(&fd_timeout);
4558 	del_timer_sync(&fd_timer);
4559 	blk_cleanup_queue(floppy_queue);
4560 
4561 	if (usage_count)
4562 		floppy_release_irq_and_dma();
4563 
4564 	/* eject disk, if any */
4565 	fd_eject(0);
4566 }
4567 module_exit(floppy_module_exit);
4568 
4569 module_param(floppy, charp, 0);
4570 module_param(FLOPPY_IRQ, int, 0);
4571 module_param(FLOPPY_DMA, int, 0);
4572 MODULE_AUTHOR("Alain L. Knaff");
4573 MODULE_SUPPORTED_DEVICE("fd");
4574 MODULE_LICENSE("GPL");
4575 
4576 #else
4577 
4578 __setup("floppy=", floppy_setup);
4579 module_init(floppy_init)
4580 #endif
4581 
4582 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);
4583