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