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