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