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