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