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