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