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