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