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