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