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