]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/block/floppy.c
x86: Remove the ancient and deprecated disable_hlt() and enable_hlt() facility
[~shefty/rdma-dev.git] / drivers / block / floppy.c
1 /*
2  *  linux/drivers/block/floppy.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *  Copyright (C) 1993, 1994  Alain Knaff
6  *  Copyright (C) 1998 Alan Cox
7  */
8
9 /*
10  * 02.12.91 - Changed to static variables to indicate need for reset
11  * and recalibrate. This makes some things easier (output_byte reset
12  * checking etc), and means less interrupt jumping in case of errors,
13  * so the code is hopefully easier to understand.
14  */
15
16 /*
17  * This file is certainly a mess. I've tried my best to get it working,
18  * but I don't like programming floppies, and I have only one anyway.
19  * Urgel. I should check for more errors, and do more graceful error
20  * recovery. Seems there are problems with several drives. I've tried to
21  * correct them. No promises.
22  */
23
24 /*
25  * As with hd.c, all routines within this file can (and will) be called
26  * by interrupts, so extreme caution is needed. A hardware interrupt
27  * handler may not sleep, or a kernel panic will happen. Thus I cannot
28  * call "floppy-on" directly, but have to set a special timer interrupt
29  * etc.
30  */
31
32 /*
33  * 28.02.92 - made track-buffering routines, based on the routines written
34  * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
35  */
36
37 /*
38  * Automatic floppy-detection and formatting written by Werner Almesberger
39  * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with
40  * the floppy-change signal detection.
41  */
42
43 /*
44  * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
45  * FDC data overrun bug, added some preliminary stuff for vertical
46  * recording support.
47  *
48  * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
49  *
50  * TODO: Errors are still not counted properly.
51  */
52
53 /* 1992/9/20
54  * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl)
55  * modeled after the freeware MS-DOS program fdformat/88 V1.8 by
56  * Christoph H. Hochst\"atter.
57  * I have fixed the shift values to the ones I always use. Maybe a new
58  * ioctl() should be created to be able to modify them.
59  * There is a bug in the driver that makes it impossible to format a
60  * floppy as the first thing after bootup.
61  */
62
63 /*
64  * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
65  * this helped the floppy driver as well. Much cleaner, and still seems to
66  * work.
67  */
68
69 /* 1994/6/24 --bbroad-- added the floppy table entries and made
70  * minor modifications to allow 2.88 floppies to be run.
71  */
72
73 /* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
74  * disk types.
75  */
76
77 /*
78  * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
79  * format bug fixes, but unfortunately some new bugs too...
80  */
81
82 /* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
83  * errors to allow safe writing by specialized programs.
84  */
85
86 /* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
87  * by defining bit 1 of the "stretch" parameter to mean put sectors on the
88  * opposite side of the disk, leaving the sector IDs alone (i.e. Commodore's
89  * drives are "upside-down").
90  */
91
92 /*
93  * 1995/8/26 -- Andreas Busse -- added Mips support.
94  */
95
96 /*
97  * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
98  * features to asm/floppy.h.
99  */
100
101 /*
102  * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
103  */
104
105 /*
106  * 1998/05/07 -- Russell King -- More portability cleanups; moved definition of
107  * interrupt and dma channel to asm/floppy.h. Cleaned up some formatting &
108  * use of '0' for NULL.
109  */
110
111 /*
112  * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
113  * failures.
114  */
115
116 /*
117  * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
118  */
119
120 /*
121  * 1999/08/13 -- Paul Slootman -- floppy stopped working on Alpha after 24
122  * days, 6 hours, 32 minutes and 32 seconds (i.e. MAXINT jiffies; ints were
123  * being used to store jiffies, which are unsigned longs).
124  */
125
126 /*
127  * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
128  * - get rid of check_region
129  * - s/suser/capable/
130  */
131
132 /*
133  * 2001/08/26 -- Paul Gortmaker - fix insmod oops on machines with no
134  * floppy controller (lingering task on list after module is gone... boom.)
135  */
136
137 /*
138  * 2002/02/07 -- Anton Altaparmakov - Fix io ports reservation to correct range
139  * (0x3f2-0x3f5, 0x3f7). This fix is a bit of a hack but the proper fix
140  * requires many non-obvious changes in arch dependent code.
141  */
142
143 /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
144  * Better audit of register_blkdev.
145  */
146
147 #undef  FLOPPY_SILENT_DCL_CLEAR
148
149 #define REALLY_SLOW_IO
150
151 #define DEBUGT 2
152
153 #define DPRINT(format, args...) \
154         pr_info("floppy%d: " format, current_drive, ##args)
155
156 #define DCL_DEBUG               /* debug disk change line */
157 #ifdef DCL_DEBUG
158 #define debug_dcl(test, fmt, args...) \
159         do { if ((test) & FD_DEBUG) DPRINT(fmt, ##args); } while (0)
160 #else
161 #define debug_dcl(test, fmt, args...) \
162         do { if (0) DPRINT(fmt, ##args); } while (0)
163 #endif
164
165 /* do print messages for unexpected interrupts */
166 static int print_unex = 1;
167 #include <linux/module.h>
168 #include <linux/sched.h>
169 #include <linux/fs.h>
170 #include <linux/kernel.h>
171 #include <linux/timer.h>
172 #include <linux/workqueue.h>
173 #define FDPATCHES
174 #include <linux/fdreg.h>
175 #include <linux/fd.h>
176 #include <linux/hdreg.h>
177 #include <linux/errno.h>
178 #include <linux/slab.h>
179 #include <linux/mm.h>
180 #include <linux/bio.h>
181 #include <linux/string.h>
182 #include <linux/jiffies.h>
183 #include <linux/fcntl.h>
184 #include <linux/delay.h>
185 #include <linux/mc146818rtc.h>  /* CMOS defines */
186 #include <linux/ioport.h>
187 #include <linux/interrupt.h>
188 #include <linux/init.h>
189 #include <linux/platform_device.h>
190 #include <linux/mod_devicetable.h>
191 #include <linux/mutex.h>
192 #include <linux/io.h>
193 #include <linux/uaccess.h>
194
195 /*
196  * PS/2 floppies have much slower step rates than regular floppies.
197  * It's been recommended that take about 1/4 of the default speed
198  * in some more extreme cases.
199  */
200 static DEFINE_MUTEX(floppy_mutex);
201 static int slow_floppy;
202
203 #include <asm/dma.h>
204 #include <asm/irq.h>
205
206 static int FLOPPY_IRQ = 6;
207 static int FLOPPY_DMA = 2;
208 static int can_use_virtual_dma = 2;
209 /* =======
210  * can use virtual DMA:
211  * 0 = use of virtual DMA disallowed by config
212  * 1 = use of virtual DMA prescribed by config
213  * 2 = no virtual DMA preference configured.  By default try hard DMA,
214  * but fall back on virtual DMA when not enough memory available
215  */
216
217 static int use_virtual_dma;
218 /* =======
219  * use virtual DMA
220  * 0 using hard DMA
221  * 1 using virtual DMA
222  * This variable is set to virtual when a DMA mem problem arises, and
223  * reset back in floppy_grab_irq_and_dma.
224  * It is not safe to reset it in other circumstances, because the floppy
225  * driver may have several buffers in use at once, and we do currently not
226  * record each buffers capabilities
227  */
228
229 static DEFINE_SPINLOCK(floppy_lock);
230
231 static unsigned short virtual_dma_port = 0x3f0;
232 irqreturn_t floppy_interrupt(int irq, void *dev_id);
233 static int set_dor(int fdc, char mask, char data);
234
235 #define K_64    0x10000         /* 64KB */
236
237 /* the following is the mask of allowed drives. By default units 2 and
238  * 3 of both floppy controllers are disabled, because switching on the
239  * motor of these drives causes system hangs on some PCI computers. drive
240  * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
241  * a drive is allowed.
242  *
243  * NOTE: This must come before we include the arch floppy header because
244  *       some ports reference this variable from there. -DaveM
245  */
246
247 static int allowed_drive_mask = 0x33;
248
249 #include <asm/floppy.h>
250
251 static int irqdma_allocated;
252
253 #include <linux/blkdev.h>
254 #include <linux/blkpg.h>
255 #include <linux/cdrom.h>        /* for the compatibility eject ioctl */
256 #include <linux/completion.h>
257
258 static struct request *current_req;
259 static void do_fd_request(struct request_queue *q);
260 static int set_next_request(void);
261
262 #ifndef fd_get_dma_residue
263 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
264 #endif
265
266 /* Dma Memory related stuff */
267
268 #ifndef fd_dma_mem_free
269 #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
270 #endif
271
272 #ifndef fd_dma_mem_alloc
273 #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL, get_order(size))
274 #endif
275
276 static inline void fallback_on_nodma_alloc(char **addr, size_t l)
277 {
278 #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
279         if (*addr)
280                 return;         /* we have the memory */
281         if (can_use_virtual_dma != 2)
282                 return;         /* no fallback allowed */
283         pr_info("DMA memory shortage. Temporarily falling back on virtual DMA\n");
284         *addr = (char *)nodma_mem_alloc(l);
285 #else
286         return;
287 #endif
288 }
289
290 /* End dma memory related stuff */
291
292 static unsigned long fake_change;
293 static bool initialized;
294
295 #define ITYPE(x)        (((x) >> 2) & 0x1f)
296 #define TOMINOR(x)      ((x & 3) | ((x & 4) << 5))
297 #define UNIT(x)         ((x) & 0x03)            /* drive on fdc */
298 #define FDC(x)          (((x) & 0x04) >> 2)     /* fdc of drive */
299         /* reverse mapping from unit and fdc to drive */
300 #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
301
302 #define DP      (&drive_params[current_drive])
303 #define DRS     (&drive_state[current_drive])
304 #define DRWE    (&write_errors[current_drive])
305 #define FDCS    (&fdc_state[fdc])
306
307 #define UDP     (&drive_params[drive])
308 #define UDRS    (&drive_state[drive])
309 #define UDRWE   (&write_errors[drive])
310 #define UFDCS   (&fdc_state[FDC(drive)])
311
312 #define PH_HEAD(floppy, head) (((((floppy)->stretch & 2) >> 1) ^ head) << 2)
313 #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
314
315 /* read/write */
316 #define COMMAND         (raw_cmd->cmd[0])
317 #define DR_SELECT       (raw_cmd->cmd[1])
318 #define TRACK           (raw_cmd->cmd[2])
319 #define HEAD            (raw_cmd->cmd[3])
320 #define SECTOR          (raw_cmd->cmd[4])
321 #define SIZECODE        (raw_cmd->cmd[5])
322 #define SECT_PER_TRACK  (raw_cmd->cmd[6])
323 #define GAP             (raw_cmd->cmd[7])
324 #define SIZECODE2       (raw_cmd->cmd[8])
325 #define NR_RW 9
326
327 /* format */
328 #define F_SIZECODE      (raw_cmd->cmd[2])
329 #define F_SECT_PER_TRACK (raw_cmd->cmd[3])
330 #define F_GAP           (raw_cmd->cmd[4])
331 #define F_FILL          (raw_cmd->cmd[5])
332 #define NR_F 6
333
334 /*
335  * Maximum disk size (in kilobytes).
336  * This default is used whenever the current disk size is unknown.
337  * [Now it is rather a minimum]
338  */
339 #define MAX_DISK_SIZE 4         /* 3984 */
340
341 /*
342  * globals used by 'result()'
343  */
344 #define MAX_REPLIES 16
345 static unsigned char reply_buffer[MAX_REPLIES];
346 static int inr;         /* size of reply buffer, when called from interrupt */
347 #define ST0             (reply_buffer[0])
348 #define ST1             (reply_buffer[1])
349 #define ST2             (reply_buffer[2])
350 #define ST3             (reply_buffer[0])       /* result of GETSTATUS */
351 #define R_TRACK         (reply_buffer[3])
352 #define R_HEAD          (reply_buffer[4])
353 #define R_SECTOR        (reply_buffer[5])
354 #define R_SIZECODE      (reply_buffer[6])
355
356 #define SEL_DLY         (2 * HZ / 100)
357
358 /*
359  * this struct defines the different floppy drive types.
360  */
361 static struct {
362         struct floppy_drive_params params;
363         const char *name;       /* name printed while booting */
364 } default_drive_params[] = {
365 /* NOTE: the time values in jiffies should be in msec!
366  CMOS drive type
367   |     Maximum data rate supported by drive type
368   |     |   Head load time, msec
369   |     |   |   Head unload time, msec (not used)
370   |     |   |   |     Step rate interval, usec
371   |     |   |   |     |       Time needed for spinup time (jiffies)
372   |     |   |   |     |       |      Timeout for spinning down (jiffies)
373   |     |   |   |     |       |      |   Spindown offset (where disk stops)
374   |     |   |   |     |       |      |   |     Select delay
375   |     |   |   |     |       |      |   |     |     RPS
376   |     |   |   |     |       |      |   |     |     |    Max number of tracks
377   |     |   |   |     |       |      |   |     |     |    |     Interrupt timeout
378   |     |   |   |     |       |      |   |     |     |    |     |   Max nonintlv. sectors
379   |     |   |   |     |       |      |   |     |     |    |     |   | -Max Errors- flags */
380 {{0,  500, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  80, 3*HZ, 20, {3,1,2,0,2}, 0,
381       0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
382
383 {{1,  300, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  40, 3*HZ, 17, {3,1,2,0,2}, 0,
384       0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
385
386 {{2,  500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6,  83, 3*HZ, 17, {3,1,2,0,2}, 0,
387       0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
388
389 {{3,  250, 16, 16, 3000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
390       0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
391
392 {{4,  500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
393       0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
394
395 {{5, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
396       0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
397
398 {{6, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
399       0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
400 /*    |  --autodetected formats---    |      |      |
401  *    read_track                      |      |    Name printed when booting
402  *                                    |     Native format
403  *                  Frequency of disk change checks */
404 };
405
406 static struct floppy_drive_params drive_params[N_DRIVE];
407 static struct floppy_drive_struct drive_state[N_DRIVE];
408 static struct floppy_write_errors write_errors[N_DRIVE];
409 static struct timer_list motor_off_timer[N_DRIVE];
410 static struct gendisk *disks[N_DRIVE];
411 static struct block_device *opened_bdev[N_DRIVE];
412 static DEFINE_MUTEX(open_lock);
413 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
414 static int fdc_queue;
415
416 /*
417  * This struct defines the different floppy types.
418  *
419  * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
420  * types (e.g. 360kB diskette in 1.2MB drive, etc.).  Bit 1 of 'stretch'
421  * tells if the disk is in Commodore 1581 format, which means side 0 sectors
422  * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
423  * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
424  * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
425  * side 0 is on physical side 0 (but with the misnamed sector IDs).
426  * 'stretch' should probably be renamed to something more general, like
427  * 'options'.
428  *
429  * Bits 2 through 9 of 'stretch' tell the number of the first sector.
430  * The LSB (bit 2) is flipped. For most disks, the first sector
431  * is 1 (represented by 0x00<<2).  For some CP/M and music sampler
432  * disks (such as Ensoniq EPS 16plus) it is 0 (represented as 0x01<<2).
433  * For Amstrad CPC disks it is 0xC1 (represented as 0xC0<<2).
434  *
435  * Other parameters should be self-explanatory (see also setfdprm(8)).
436  */
437 /*
438             Size
439              |  Sectors per track
440              |  | Head
441              |  | |  Tracks
442              |  | |  | Stretch
443              |  | |  | |  Gap 1 size
444              |  | |  | |    |  Data rate, | 0x40 for perp
445              |  | |  | |    |    |  Spec1 (stepping rate, head unload
446              |  | |  | |    |    |    |    /fmt gap (gap2) */
447 static struct floppy_struct floppy_type[32] = {
448         {    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL    }, /*  0 no testing    */
449         {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360"  }, /*  1 360KB PC      */
450         { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /*  2 1.2MB AT      */
451         {  720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360"  }, /*  3 360KB SS 3.5" */
452         { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720"  }, /*  4 720KB 3.5"    */
453         {  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360"  }, /*  5 360KB AT      */
454         { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720"  }, /*  6 720KB AT      */
455         { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /*  7 1.44MB 3.5"   */
456         { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /*  8 2.88MB 3.5"   */
457         { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /*  9 3.12MB 3.5"   */
458
459         { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25"  */
460         { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5"   */
461         {  820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410"  }, /* 12 410KB 5.25"   */
462         { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820"  }, /* 13 820KB 3.5"    */
463         { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25"  */
464         { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5"   */
465         {  840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420"  }, /* 16 420KB 5.25"   */
466         { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830"  }, /* 17 830KB 3.5"    */
467         { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25"  */
468         { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5"  */
469
470         { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880"  }, /* 20 880KB 5.25"   */
471         { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5"   */
472         { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5"   */
473         { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25"   */
474         { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5"   */
475         { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5"   */
476         { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5"   */
477         { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5"   */
478         { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5"   */
479         { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5"   */
480
481         { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800"  }, /* 30 800KB 3.5"    */
482         { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5"    */
483 };
484
485 #define SECTSIZE (_FD_SECTSIZE(*floppy))
486
487 /* Auto-detection: Disk type used until the next media change occurs. */
488 static struct floppy_struct *current_type[N_DRIVE];
489
490 /*
491  * User-provided type information. current_type points to
492  * the respective entry of this array.
493  */
494 static struct floppy_struct user_params[N_DRIVE];
495
496 static sector_t floppy_sizes[256];
497
498 static char floppy_device_name[] = "floppy";
499
500 /*
501  * The driver is trying to determine the correct media format
502  * while probing is set. rw_interrupt() clears it after a
503  * successful access.
504  */
505 static int probing;
506
507 /* Synchronization of FDC access. */
508 #define FD_COMMAND_NONE         -1
509 #define FD_COMMAND_ERROR        2
510 #define FD_COMMAND_OKAY         3
511
512 static volatile int command_status = FD_COMMAND_NONE;
513 static unsigned long fdc_busy;
514 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
515 static DECLARE_WAIT_QUEUE_HEAD(command_done);
516
517 /* Errors during formatting are counted here. */
518 static int format_errors;
519
520 /* Format request descriptor. */
521 static struct format_descr format_req;
522
523 /*
524  * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
525  * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
526  * H is head unload time (1=16ms, 2=32ms, etc)
527  */
528
529 /*
530  * Track buffer
531  * Because these are written to by the DMA controller, they must
532  * not contain a 64k byte boundary crossing, or data will be
533  * corrupted/lost.
534  */
535 static char *floppy_track_buffer;
536 static int max_buffer_sectors;
537
538 static int *errors;
539 typedef void (*done_f)(int);
540 static const struct cont_t {
541         void (*interrupt)(void);
542                                 /* this is called after the interrupt of the
543                                  * main command */
544         void (*redo)(void);     /* this is called to retry the operation */
545         void (*error)(void);    /* this is called to tally an error */
546         done_f done;            /* this is called to say if the operation has
547                                  * succeeded/failed */
548 } *cont;
549
550 static void floppy_ready(void);
551 static void floppy_start(void);
552 static void process_fd_request(void);
553 static void recalibrate_floppy(void);
554 static void floppy_shutdown(unsigned long);
555
556 static int floppy_request_regions(int);
557 static void floppy_release_regions(int);
558 static int floppy_grab_irq_and_dma(void);
559 static void floppy_release_irq_and_dma(void);
560
561 /*
562  * The "reset" variable should be tested whenever an interrupt is scheduled,
563  * after the commands have been sent. This is to ensure that the driver doesn't
564  * get wedged when the interrupt doesn't come because of a failed command.
565  * reset doesn't need to be tested before sending commands, because
566  * output_byte is automatically disabled when reset is set.
567  */
568 static void reset_fdc(void);
569
570 /*
571  * These are global variables, as that's the easiest way to give
572  * information to interrupts. They are the data used for the current
573  * request.
574  */
575 #define NO_TRACK        -1
576 #define NEED_1_RECAL    -2
577 #define NEED_2_RECAL    -3
578
579 static atomic_t usage_count = ATOMIC_INIT(0);
580
581 /* buffer related variables */
582 static int buffer_track = -1;
583 static int buffer_drive = -1;
584 static int buffer_min = -1;
585 static int buffer_max = -1;
586
587 /* fdc related variables, should end up in a struct */
588 static struct floppy_fdc_state fdc_state[N_FDC];
589 static int fdc;                 /* current fdc */
590
591 static struct floppy_struct *_floppy = floppy_type;
592 static unsigned char current_drive;
593 static long current_count_sectors;
594 static unsigned char fsector_t; /* sector in track */
595 static unsigned char in_sector_offset;  /* offset within physical sector,
596                                          * expressed in units of 512 bytes */
597
598 static inline bool drive_no_geom(int drive)
599 {
600         return !current_type[drive] && !ITYPE(UDRS->fd_device);
601 }
602
603 #ifndef fd_eject
604 static inline int fd_eject(int drive)
605 {
606         return -EINVAL;
607 }
608 #endif
609
610 /*
611  * Debugging
612  * =========
613  */
614 #ifdef DEBUGT
615 static long unsigned debugtimer;
616
617 static inline void set_debugt(void)
618 {
619         debugtimer = jiffies;
620 }
621
622 static inline void debugt(const char *func, const char *msg)
623 {
624         if (DP->flags & DEBUGT)
625                 pr_info("%s:%s dtime=%lu\n", func, msg, jiffies - debugtimer);
626 }
627 #else
628 static inline void set_debugt(void) { }
629 static inline void debugt(const char *func, const char *msg) { }
630 #endif /* DEBUGT */
631
632 typedef void (*timeout_fn)(unsigned long);
633 static DEFINE_TIMER(fd_timeout, floppy_shutdown, 0, 0);
634
635 static const char *timeout_message;
636
637 static void is_alive(const char *func, const char *message)
638 {
639         /* this routine checks whether the floppy driver is "alive" */
640         if (test_bit(0, &fdc_busy) && command_status < 2 &&
641             !timer_pending(&fd_timeout)) {
642                 DPRINT("%s: timeout handler died.  %s\n", func, message);
643         }
644 }
645
646 static void (*do_floppy)(void) = NULL;
647
648 #define OLOGSIZE 20
649
650 static void (*lasthandler)(void);
651 static unsigned long interruptjiffies;
652 static unsigned long resultjiffies;
653 static int resultsize;
654 static unsigned long lastredo;
655
656 static struct output_log {
657         unsigned char data;
658         unsigned char status;
659         unsigned long jiffies;
660 } output_log[OLOGSIZE];
661
662 static int output_log_pos;
663
664 #define current_reqD -1
665 #define MAXTIMEOUT -2
666
667 static void __reschedule_timeout(int drive, const char *message)
668 {
669         if (drive == current_reqD)
670                 drive = current_drive;
671         del_timer(&fd_timeout);
672         if (drive < 0 || drive >= N_DRIVE) {
673                 fd_timeout.expires = jiffies + 20UL * HZ;
674                 drive = 0;
675         } else
676                 fd_timeout.expires = jiffies + UDP->timeout;
677         add_timer(&fd_timeout);
678         if (UDP->flags & FD_DEBUG)
679                 DPRINT("reschedule timeout %s\n", message);
680         timeout_message = message;
681 }
682
683 static void reschedule_timeout(int drive, const char *message)
684 {
685         unsigned long flags;
686
687         spin_lock_irqsave(&floppy_lock, flags);
688         __reschedule_timeout(drive, message);
689         spin_unlock_irqrestore(&floppy_lock, flags);
690 }
691
692 #define INFBOUND(a, b) (a) = max_t(int, a, b)
693 #define SUPBOUND(a, b) (a) = min_t(int, a, b)
694
695 /*
696  * Bottom half floppy driver.
697  * ==========================
698  *
699  * This part of the file contains the code talking directly to the hardware,
700  * and also the main service loop (seek-configure-spinup-command)
701  */
702
703 /*
704  * disk change.
705  * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
706  * and the last_checked date.
707  *
708  * last_checked is the date of the last check which showed 'no disk change'
709  * FD_DISK_CHANGE is set under two conditions:
710  * 1. The floppy has been changed after some i/o to that floppy already
711  *    took place.
712  * 2. No floppy disk is in the drive. This is done in order to ensure that
713  *    requests are quickly flushed in case there is no disk in the drive. It
714  *    follows that FD_DISK_CHANGE can only be cleared if there is a disk in
715  *    the drive.
716  *
717  * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
718  * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
719  *  each seek. If a disk is present, the disk change line should also be
720  *  cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
721  *  change line is set, this means either that no disk is in the drive, or
722  *  that it has been removed since the last seek.
723  *
724  * This means that we really have a third possibility too:
725  *  The floppy has been changed after the last seek.
726  */
727
728 static int disk_change(int drive)
729 {
730         int fdc = FDC(drive);
731
732         if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
733                 DPRINT("WARNING disk change called early\n");
734         if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
735             (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
736                 DPRINT("probing disk change on unselected drive\n");
737                 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
738                        (unsigned int)FDCS->dor);
739         }
740
741         debug_dcl(UDP->flags,
742                   "checking disk change line for drive %d\n", drive);
743         debug_dcl(UDP->flags, "jiffies=%lu\n", jiffies);
744         debug_dcl(UDP->flags, "disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
745         debug_dcl(UDP->flags, "flags=%lx\n", UDRS->flags);
746
747         if (UDP->flags & FD_BROKEN_DCL)
748                 return test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
749         if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
750                 set_bit(FD_VERIFY_BIT, &UDRS->flags);
751                                         /* verify write protection */
752
753                 if (UDRS->maxblock)     /* mark it changed */
754                         set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
755
756                 /* invalidate its geometry */
757                 if (UDRS->keep_data >= 0) {
758                         if ((UDP->flags & FTD_MSG) &&
759                             current_type[drive] != NULL)
760                                 DPRINT("Disk type is undefined after disk change\n");
761                         current_type[drive] = NULL;
762                         floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
763                 }
764
765                 return 1;
766         } else {
767                 UDRS->last_checked = jiffies;
768                 clear_bit(FD_DISK_NEWCHANGE_BIT, &UDRS->flags);
769         }
770         return 0;
771 }
772
773 static inline int is_selected(int dor, int unit)
774 {
775         return ((dor & (0x10 << unit)) && (dor & 3) == unit);
776 }
777
778 static bool is_ready_state(int status)
779 {
780         int state = status & (STATUS_READY | STATUS_DIR | STATUS_DMA);
781         return state == STATUS_READY;
782 }
783
784 static int set_dor(int fdc, char mask, char data)
785 {
786         unsigned char unit;
787         unsigned char drive;
788         unsigned char newdor;
789         unsigned char olddor;
790
791         if (FDCS->address == -1)
792                 return -1;
793
794         olddor = FDCS->dor;
795         newdor = (olddor & mask) | data;
796         if (newdor != olddor) {
797                 unit = olddor & 0x3;
798                 if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
799                         drive = REVDRIVE(fdc, unit);
800                         debug_dcl(UDP->flags,
801                                   "calling disk change from set_dor\n");
802                         disk_change(drive);
803                 }
804                 FDCS->dor = newdor;
805                 fd_outb(newdor, FD_DOR);
806
807                 unit = newdor & 0x3;
808                 if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
809                         drive = REVDRIVE(fdc, unit);
810                         UDRS->select_date = jiffies;
811                 }
812         }
813         return olddor;
814 }
815
816 static void twaddle(void)
817 {
818         if (DP->select_delay)
819                 return;
820         fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
821         fd_outb(FDCS->dor, FD_DOR);
822         DRS->select_date = jiffies;
823 }
824
825 /*
826  * Reset all driver information about the current fdc.
827  * This is needed after a reset, and after a raw command.
828  */
829 static void reset_fdc_info(int mode)
830 {
831         int drive;
832
833         FDCS->spec1 = FDCS->spec2 = -1;
834         FDCS->need_configure = 1;
835         FDCS->perp_mode = 1;
836         FDCS->rawcmd = 0;
837         for (drive = 0; drive < N_DRIVE; drive++)
838                 if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
839                         UDRS->track = NEED_2_RECAL;
840 }
841
842 /* selects the fdc and drive, and enables the fdc's input/dma. */
843 static void set_fdc(int drive)
844 {
845         if (drive >= 0 && drive < N_DRIVE) {
846                 fdc = FDC(drive);
847                 current_drive = drive;
848         }
849         if (fdc != 1 && fdc != 0) {
850                 pr_info("bad fdc value\n");
851                 return;
852         }
853         set_dor(fdc, ~0, 8);
854 #if N_FDC > 1
855         set_dor(1 - fdc, ~8, 0);
856 #endif
857         if (FDCS->rawcmd == 2)
858                 reset_fdc_info(1);
859         if (fd_inb(FD_STATUS) != STATUS_READY)
860                 FDCS->reset = 1;
861 }
862
863 /* locks the driver */
864 static int lock_fdc(int drive, bool interruptible)
865 {
866         if (WARN(atomic_read(&usage_count) == 0,
867                  "Trying to lock fdc while usage count=0\n"))
868                 return -1;
869
870         if (wait_event_interruptible(fdc_wait, !test_and_set_bit(0, &fdc_busy)))
871                 return -EINTR;
872
873         command_status = FD_COMMAND_NONE;
874
875         __reschedule_timeout(drive, "lock fdc");
876         set_fdc(drive);
877         return 0;
878 }
879
880 /* unlocks the driver */
881 static void unlock_fdc(void)
882 {
883         unsigned long flags;
884
885         raw_cmd = NULL;
886         if (!test_bit(0, &fdc_busy))
887                 DPRINT("FDC access conflict!\n");
888
889         if (do_floppy)
890                 DPRINT("device interrupt still active at FDC release: %pf!\n",
891                        do_floppy);
892         command_status = FD_COMMAND_NONE;
893         spin_lock_irqsave(&floppy_lock, flags);
894         del_timer(&fd_timeout);
895         cont = NULL;
896         clear_bit(0, &fdc_busy);
897         if (current_req || set_next_request())
898                 do_fd_request(current_req->q);
899         spin_unlock_irqrestore(&floppy_lock, flags);
900         wake_up(&fdc_wait);
901 }
902
903 /* switches the motor off after a given timeout */
904 static void motor_off_callback(unsigned long nr)
905 {
906         unsigned char mask = ~(0x10 << UNIT(nr));
907
908         set_dor(FDC(nr), mask, 0);
909 }
910
911 /* schedules motor off */
912 static void floppy_off(unsigned int drive)
913 {
914         unsigned long volatile delta;
915         int fdc = FDC(drive);
916
917         if (!(FDCS->dor & (0x10 << UNIT(drive))))
918                 return;
919
920         del_timer(motor_off_timer + drive);
921
922         /* make spindle stop in a position which minimizes spinup time
923          * next time */
924         if (UDP->rps) {
925                 delta = jiffies - UDRS->first_read_date + HZ -
926                     UDP->spindown_offset;
927                 delta = ((delta * UDP->rps) % HZ) / UDP->rps;
928                 motor_off_timer[drive].expires =
929                     jiffies + UDP->spindown - delta;
930         }
931         add_timer(motor_off_timer + drive);
932 }
933
934 /*
935  * cycle through all N_DRIVE floppy drives, for disk change testing.
936  * stopping at current drive. This is done before any long operation, to
937  * be sure to have up to date disk change information.
938  */
939 static void scandrives(void)
940 {
941         int i;
942         int drive;
943         int saved_drive;
944
945         if (DP->select_delay)
946                 return;
947
948         saved_drive = current_drive;
949         for (i = 0; i < N_DRIVE; i++) {
950                 drive = (saved_drive + i + 1) % N_DRIVE;
951                 if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
952                         continue;       /* skip closed drives */
953                 set_fdc(drive);
954                 if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
955                       (0x10 << UNIT(drive))))
956                         /* switch the motor off again, if it was off to
957                          * begin with */
958                         set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
959         }
960         set_fdc(saved_drive);
961 }
962
963 static void empty(void)
964 {
965 }
966
967 static DECLARE_WORK(floppy_work, NULL);
968
969 static void schedule_bh(void (*handler)(void))
970 {
971         PREPARE_WORK(&floppy_work, (work_func_t)handler);
972         schedule_work(&floppy_work);
973 }
974
975 static DEFINE_TIMER(fd_timer, NULL, 0, 0);
976
977 static void cancel_activity(void)
978 {
979         unsigned long flags;
980
981         spin_lock_irqsave(&floppy_lock, flags);
982         do_floppy = NULL;
983         PREPARE_WORK(&floppy_work, (work_func_t)empty);
984         del_timer(&fd_timer);
985         spin_unlock_irqrestore(&floppy_lock, flags);
986 }
987
988 /* this function makes sure that the disk stays in the drive during the
989  * transfer */
990 static void fd_watchdog(void)
991 {
992         debug_dcl(DP->flags, "calling disk change from watchdog\n");
993
994         if (disk_change(current_drive)) {
995                 DPRINT("disk removed during i/o\n");
996                 cancel_activity();
997                 cont->done(0);
998                 reset_fdc();
999         } else {
1000                 del_timer(&fd_timer);
1001                 fd_timer.function = (timeout_fn)fd_watchdog;
1002                 fd_timer.expires = jiffies + HZ / 10;
1003                 add_timer(&fd_timer);
1004         }
1005 }
1006
1007 static void main_command_interrupt(void)
1008 {
1009         del_timer(&fd_timer);
1010         cont->interrupt();
1011 }
1012
1013 /* waits for a delay (spinup or select) to pass */
1014 static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
1015 {
1016         if (FDCS->reset) {
1017                 reset_fdc();    /* do the reset during sleep to win time
1018                                  * if we don't need to sleep, it's a good
1019                                  * occasion anyways */
1020                 return 1;
1021         }
1022
1023         if (time_before(jiffies, delay)) {
1024                 del_timer(&fd_timer);
1025                 fd_timer.function = function;
1026                 fd_timer.expires = delay;
1027                 add_timer(&fd_timer);
1028                 return 1;
1029         }
1030         return 0;
1031 }
1032
1033 static void setup_DMA(void)
1034 {
1035         unsigned long f;
1036
1037         if (raw_cmd->length == 0) {
1038                 int i;
1039
1040                 pr_info("zero dma transfer size:");
1041                 for (i = 0; i < raw_cmd->cmd_count; i++)
1042                         pr_cont("%x,", raw_cmd->cmd[i]);
1043                 pr_cont("\n");
1044                 cont->done(0);
1045                 FDCS->reset = 1;
1046                 return;
1047         }
1048         if (((unsigned long)raw_cmd->kernel_data) % 512) {
1049                 pr_info("non aligned address: %p\n", raw_cmd->kernel_data);
1050                 cont->done(0);
1051                 FDCS->reset = 1;
1052                 return;
1053         }
1054         f = claim_dma_lock();
1055         fd_disable_dma();
1056 #ifdef fd_dma_setup
1057         if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1058                          (raw_cmd->flags & FD_RAW_READ) ?
1059                          DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
1060                 release_dma_lock(f);
1061                 cont->done(0);
1062                 FDCS->reset = 1;
1063                 return;
1064         }
1065         release_dma_lock(f);
1066 #else
1067         fd_clear_dma_ff();
1068         fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1069         fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
1070                         DMA_MODE_READ : DMA_MODE_WRITE);
1071         fd_set_dma_addr(raw_cmd->kernel_data);
1072         fd_set_dma_count(raw_cmd->length);
1073         virtual_dma_port = FDCS->address;
1074         fd_enable_dma();
1075         release_dma_lock(f);
1076 #endif
1077 }
1078
1079 static void show_floppy(void);
1080
1081 /* waits until the fdc becomes ready */
1082 static int wait_til_ready(void)
1083 {
1084         int status;
1085         int counter;
1086
1087         if (FDCS->reset)
1088                 return -1;
1089         for (counter = 0; counter < 10000; counter++) {
1090                 status = fd_inb(FD_STATUS);
1091                 if (status & STATUS_READY)
1092                         return status;
1093         }
1094         if (initialized) {
1095                 DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
1096                 show_floppy();
1097         }
1098         FDCS->reset = 1;
1099         return -1;
1100 }
1101
1102 /* sends a command byte to the fdc */
1103 static int output_byte(char byte)
1104 {
1105         int status = wait_til_ready();
1106
1107         if (status < 0)
1108                 return -1;
1109
1110         if (is_ready_state(status)) {
1111                 fd_outb(byte, FD_DATA);
1112                 output_log[output_log_pos].data = byte;
1113                 output_log[output_log_pos].status = status;
1114                 output_log[output_log_pos].jiffies = jiffies;
1115                 output_log_pos = (output_log_pos + 1) % OLOGSIZE;
1116                 return 0;
1117         }
1118         FDCS->reset = 1;
1119         if (initialized) {
1120                 DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
1121                        byte, fdc, status);
1122                 show_floppy();
1123         }
1124         return -1;
1125 }
1126
1127 /* gets the response from the fdc */
1128 static int result(void)
1129 {
1130         int i;
1131         int status = 0;
1132
1133         for (i = 0; i < MAX_REPLIES; i++) {
1134                 status = wait_til_ready();
1135                 if (status < 0)
1136                         break;
1137                 status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
1138                 if ((status & ~STATUS_BUSY) == STATUS_READY) {
1139                         resultjiffies = jiffies;
1140                         resultsize = i;
1141                         return i;
1142                 }
1143                 if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
1144                         reply_buffer[i] = fd_inb(FD_DATA);
1145                 else
1146                         break;
1147         }
1148         if (initialized) {
1149                 DPRINT("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
1150                        fdc, status, i);
1151                 show_floppy();
1152         }
1153         FDCS->reset = 1;
1154         return -1;
1155 }
1156
1157 #define MORE_OUTPUT -2
1158 /* does the fdc need more output? */
1159 static int need_more_output(void)
1160 {
1161         int status = wait_til_ready();
1162
1163         if (status < 0)
1164                 return -1;
1165
1166         if (is_ready_state(status))
1167                 return MORE_OUTPUT;
1168
1169         return result();
1170 }
1171
1172 /* Set perpendicular mode as required, based on data rate, if supported.
1173  * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
1174  */
1175 static void perpendicular_mode(void)
1176 {
1177         unsigned char perp_mode;
1178
1179         if (raw_cmd->rate & 0x40) {
1180                 switch (raw_cmd->rate & 3) {
1181                 case 0:
1182                         perp_mode = 2;
1183                         break;
1184                 case 3:
1185                         perp_mode = 3;
1186                         break;
1187                 default:
1188                         DPRINT("Invalid data rate for perpendicular mode!\n");
1189                         cont->done(0);
1190                         FDCS->reset = 1;
1191                                         /*
1192                                          * convenient way to return to
1193                                          * redo without too much hassle
1194                                          * (deep stack et al.)
1195                                          */
1196                         return;
1197                 }
1198         } else
1199                 perp_mode = 0;
1200
1201         if (FDCS->perp_mode == perp_mode)
1202                 return;
1203         if (FDCS->version >= FDC_82077_ORIG) {
1204                 output_byte(FD_PERPENDICULAR);
1205                 output_byte(perp_mode);
1206                 FDCS->perp_mode = perp_mode;
1207         } else if (perp_mode) {
1208                 DPRINT("perpendicular mode not supported by this FDC.\n");
1209         }
1210 }                               /* perpendicular_mode */
1211
1212 static int fifo_depth = 0xa;
1213 static int no_fifo;
1214
1215 static int fdc_configure(void)
1216 {
1217         /* Turn on FIFO */
1218         output_byte(FD_CONFIGURE);
1219         if (need_more_output() != MORE_OUTPUT)
1220                 return 0;
1221         output_byte(0);
1222         output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1223         output_byte(0);         /* pre-compensation from track
1224                                    0 upwards */
1225         return 1;
1226 }
1227
1228 #define NOMINAL_DTR 500
1229
1230 /* Issue a "SPECIFY" command to set the step rate time, head unload time,
1231  * head load time, and DMA disable flag to values needed by floppy.
1232  *
1233  * The value "dtr" is the data transfer rate in Kbps.  It is needed
1234  * to account for the data rate-based scaling done by the 82072 and 82077
1235  * FDC types.  This parameter is ignored for other types of FDCs (i.e.
1236  * 8272a).
1237  *
1238  * Note that changing the data transfer rate has a (probably deleterious)
1239  * effect on the parameters subject to scaling for 82072/82077 FDCs, so
1240  * fdc_specify is called again after each data transfer rate
1241  * change.
1242  *
1243  * srt: 1000 to 16000 in microseconds
1244  * hut: 16 to 240 milliseconds
1245  * hlt: 2 to 254 milliseconds
1246  *
1247  * These values are rounded up to the next highest available delay time.
1248  */
1249 static void fdc_specify(void)
1250 {
1251         unsigned char spec1;
1252         unsigned char spec2;
1253         unsigned long srt;
1254         unsigned long hlt;
1255         unsigned long hut;
1256         unsigned long dtr = NOMINAL_DTR;
1257         unsigned long scale_dtr = NOMINAL_DTR;
1258         int hlt_max_code = 0x7f;
1259         int hut_max_code = 0xf;
1260
1261         if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
1262                 fdc_configure();
1263                 FDCS->need_configure = 0;
1264         }
1265
1266         switch (raw_cmd->rate & 0x03) {
1267         case 3:
1268                 dtr = 1000;
1269                 break;
1270         case 1:
1271                 dtr = 300;
1272                 if (FDCS->version >= FDC_82078) {
1273                         /* chose the default rate table, not the one
1274                          * where 1 = 2 Mbps */
1275                         output_byte(FD_DRIVESPEC);
1276                         if (need_more_output() == MORE_OUTPUT) {
1277                                 output_byte(UNIT(current_drive));
1278                                 output_byte(0xc0);
1279                         }
1280                 }
1281                 break;
1282         case 2:
1283                 dtr = 250;
1284                 break;
1285         }
1286
1287         if (FDCS->version >= FDC_82072) {
1288                 scale_dtr = dtr;
1289                 hlt_max_code = 0x00;    /* 0==256msec*dtr0/dtr (not linear!) */
1290                 hut_max_code = 0x0;     /* 0==256msec*dtr0/dtr (not linear!) */
1291         }
1292
1293         /* Convert step rate from microseconds to milliseconds and 4 bits */
1294         srt = 16 - DIV_ROUND_UP(DP->srt * scale_dtr / 1000, NOMINAL_DTR);
1295         if (slow_floppy)
1296                 srt = srt / 4;
1297
1298         SUPBOUND(srt, 0xf);
1299         INFBOUND(srt, 0);
1300
1301         hlt = DIV_ROUND_UP(DP->hlt * scale_dtr / 2, NOMINAL_DTR);
1302         if (hlt < 0x01)
1303                 hlt = 0x01;
1304         else if (hlt > 0x7f)
1305                 hlt = hlt_max_code;
1306
1307         hut = DIV_ROUND_UP(DP->hut * scale_dtr / 16, NOMINAL_DTR);
1308         if (hut < 0x1)
1309                 hut = 0x1;
1310         else if (hut > 0xf)
1311                 hut = hut_max_code;
1312
1313         spec1 = (srt << 4) | hut;
1314         spec2 = (hlt << 1) | (use_virtual_dma & 1);
1315
1316         /* If these parameters did not change, just return with success */
1317         if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
1318                 /* Go ahead and set spec1 and spec2 */
1319                 output_byte(FD_SPECIFY);
1320                 output_byte(FDCS->spec1 = spec1);
1321                 output_byte(FDCS->spec2 = spec2);
1322         }
1323 }                               /* fdc_specify */
1324
1325 /* Set the FDC's data transfer rate on behalf of the specified drive.
1326  * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
1327  * of the specify command (i.e. using the fdc_specify function).
1328  */
1329 static int fdc_dtr(void)
1330 {
1331         /* If data rate not already set to desired value, set it. */
1332         if ((raw_cmd->rate & 3) == FDCS->dtr)
1333                 return 0;
1334
1335         /* Set dtr */
1336         fd_outb(raw_cmd->rate & 3, FD_DCR);
1337
1338         /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1339          * need a stabilization period of several milliseconds to be
1340          * enforced after data rate changes before R/W operations.
1341          * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
1342          */
1343         FDCS->dtr = raw_cmd->rate & 3;
1344         return fd_wait_for_completion(jiffies + 2UL * HZ / 100,
1345                                       (timeout_fn)floppy_ready);
1346 }                               /* fdc_dtr */
1347
1348 static void tell_sector(void)
1349 {
1350         pr_cont(": track %d, head %d, sector %d, size %d",
1351                 R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
1352 }                               /* tell_sector */
1353
1354 static void print_errors(void)
1355 {
1356         DPRINT("");
1357         if (ST0 & ST0_ECE) {
1358                 pr_cont("Recalibrate failed!");
1359         } else if (ST2 & ST2_CRC) {
1360                 pr_cont("data CRC error");
1361                 tell_sector();
1362         } else if (ST1 & ST1_CRC) {
1363                 pr_cont("CRC error");
1364                 tell_sector();
1365         } else if ((ST1 & (ST1_MAM | ST1_ND)) ||
1366                    (ST2 & ST2_MAM)) {
1367                 if (!probing) {
1368                         pr_cont("sector not found");
1369                         tell_sector();
1370                 } else
1371                         pr_cont("probe failed...");
1372         } else if (ST2 & ST2_WC) {      /* seek error */
1373                 pr_cont("wrong cylinder");
1374         } else if (ST2 & ST2_BC) {      /* cylinder marked as bad */
1375                 pr_cont("bad cylinder");
1376         } else {
1377                 pr_cont("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
1378                         ST0, ST1, ST2);
1379                 tell_sector();
1380         }
1381         pr_cont("\n");
1382 }
1383
1384 /*
1385  * OK, this error interpreting routine is called after a
1386  * DMA read/write has succeeded
1387  * or failed, so we check the results, and copy any buffers.
1388  * hhb: Added better error reporting.
1389  * ak: Made this into a separate routine.
1390  */
1391 static int interpret_errors(void)
1392 {
1393         char bad;
1394
1395         if (inr != 7) {
1396                 DPRINT("-- FDC reply error\n");
1397                 FDCS->reset = 1;
1398                 return 1;
1399         }
1400
1401         /* check IC to find cause of interrupt */
1402         switch (ST0 & ST0_INTR) {
1403         case 0x40:              /* error occurred during command execution */
1404                 if (ST1 & ST1_EOC)
1405                         return 0;       /* occurs with pseudo-DMA */
1406                 bad = 1;
1407                 if (ST1 & ST1_WP) {
1408                         DPRINT("Drive is write protected\n");
1409                         clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
1410                         cont->done(0);
1411                         bad = 2;
1412                 } else if (ST1 & ST1_ND) {
1413                         set_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
1414                 } else if (ST1 & ST1_OR) {
1415                         if (DP->flags & FTD_MSG)
1416                                 DPRINT("Over/Underrun - retrying\n");
1417                         bad = 0;
1418                 } else if (*errors >= DP->max_errors.reporting) {
1419                         print_errors();
1420                 }
1421                 if (ST2 & ST2_WC || ST2 & ST2_BC)
1422                         /* wrong cylinder => recal */
1423                         DRS->track = NEED_2_RECAL;
1424                 return bad;
1425         case 0x80:              /* invalid command given */
1426                 DPRINT("Invalid FDC command given!\n");
1427                 cont->done(0);
1428                 return 2;
1429         case 0xc0:
1430                 DPRINT("Abnormal termination caused by polling\n");
1431                 cont->error();
1432                 return 2;
1433         default:                /* (0) Normal command termination */
1434                 return 0;
1435         }
1436 }
1437
1438 /*
1439  * This routine is called when everything should be correctly set up
1440  * for the transfer (i.e. floppy motor is on, the correct floppy is
1441  * selected, and the head is sitting on the right track).
1442  */
1443 static void setup_rw_floppy(void)
1444 {
1445         int i;
1446         int r;
1447         int flags;
1448         int dflags;
1449         unsigned long ready_date;
1450         timeout_fn function;
1451
1452         flags = raw_cmd->flags;
1453         if (flags & (FD_RAW_READ | FD_RAW_WRITE))
1454                 flags |= FD_RAW_INTR;
1455
1456         if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
1457                 ready_date = DRS->spinup_date + DP->spinup;
1458                 /* If spinup will take a long time, rerun scandrives
1459                  * again just before spinup completion. Beware that
1460                  * after scandrives, we must again wait for selection.
1461                  */
1462                 if (time_after(ready_date, jiffies + DP->select_delay)) {
1463                         ready_date -= DP->select_delay;
1464                         function = (timeout_fn)floppy_start;
1465                 } else
1466                         function = (timeout_fn)setup_rw_floppy;
1467
1468                 /* wait until the floppy is spinning fast enough */
1469                 if (fd_wait_for_completion(ready_date, function))
1470                         return;
1471         }
1472         dflags = DRS->flags;
1473
1474         if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
1475                 setup_DMA();
1476
1477         if (flags & FD_RAW_INTR)
1478                 do_floppy = main_command_interrupt;
1479
1480         r = 0;
1481         for (i = 0; i < raw_cmd->cmd_count; i++)
1482                 r |= output_byte(raw_cmd->cmd[i]);
1483
1484         debugt(__func__, "rw_command");
1485
1486         if (r) {
1487                 cont->error();
1488                 reset_fdc();
1489                 return;
1490         }
1491
1492         if (!(flags & FD_RAW_INTR)) {
1493                 inr = result();
1494                 cont->interrupt();
1495         } else if (flags & FD_RAW_NEED_DISK)
1496                 fd_watchdog();
1497 }
1498
1499 static int blind_seek;
1500
1501 /*
1502  * This is the routine called after every seek (or recalibrate) interrupt
1503  * from the floppy controller.
1504  */
1505 static void seek_interrupt(void)
1506 {
1507         debugt(__func__, "");
1508         if (inr != 2 || (ST0 & 0xF8) != 0x20) {
1509                 DPRINT("seek failed\n");
1510                 DRS->track = NEED_2_RECAL;
1511                 cont->error();
1512                 cont->redo();
1513                 return;
1514         }
1515         if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
1516                 debug_dcl(DP->flags,
1517                           "clearing NEWCHANGE flag because of effective seek\n");
1518                 debug_dcl(DP->flags, "jiffies=%lu\n", jiffies);
1519                 clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
1520                                         /* effective seek */
1521                 DRS->select_date = jiffies;
1522         }
1523         DRS->track = ST1;
1524         floppy_ready();
1525 }
1526
1527 static void check_wp(void)
1528 {
1529         if (test_bit(FD_VERIFY_BIT, &DRS->flags)) {
1530                                         /* check write protection */
1531                 output_byte(FD_GETSTATUS);
1532                 output_byte(UNIT(current_drive));
1533                 if (result() != 1) {
1534                         FDCS->reset = 1;
1535                         return;
1536                 }
1537                 clear_bit(FD_VERIFY_BIT, &DRS->flags);
1538                 clear_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
1539                 debug_dcl(DP->flags,
1540                           "checking whether disk is write protected\n");
1541                 debug_dcl(DP->flags, "wp=%x\n", ST3 & 0x40);
1542                 if (!(ST3 & 0x40))
1543                         set_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
1544                 else
1545                         clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
1546         }
1547 }
1548
1549 static void seek_floppy(void)
1550 {
1551         int track;
1552
1553         blind_seek = 0;
1554
1555         debug_dcl(DP->flags, "calling disk change from %s\n", __func__);
1556
1557         if (!test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
1558             disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1559                 /* the media changed flag should be cleared after the seek.
1560                  * If it isn't, this means that there is really no disk in
1561                  * the drive.
1562                  */
1563                 set_bit(FD_DISK_CHANGED_BIT, &DRS->flags);
1564                 cont->done(0);
1565                 cont->redo();
1566                 return;
1567         }
1568         if (DRS->track <= NEED_1_RECAL) {
1569                 recalibrate_floppy();
1570                 return;
1571         } else if (test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
1572                    (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1573                    (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
1574                 /* we seek to clear the media-changed condition. Does anybody
1575                  * know a more elegant way, which works on all drives? */
1576                 if (raw_cmd->track)
1577                         track = raw_cmd->track - 1;
1578                 else {
1579                         if (DP->flags & FD_SILENT_DCL_CLEAR) {
1580                                 set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
1581                                 blind_seek = 1;
1582                                 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1583                         }
1584                         track = 1;
1585                 }
1586         } else {
1587                 check_wp();
1588                 if (raw_cmd->track != DRS->track &&
1589                     (raw_cmd->flags & FD_RAW_NEED_SEEK))
1590                         track = raw_cmd->track;
1591                 else {
1592                         setup_rw_floppy();
1593                         return;
1594                 }
1595         }
1596
1597         do_floppy = seek_interrupt;
1598         output_byte(FD_SEEK);
1599         output_byte(UNIT(current_drive));
1600         if (output_byte(track) < 0) {
1601                 reset_fdc();
1602                 return;
1603         }
1604         debugt(__func__, "");
1605 }
1606
1607 static void recal_interrupt(void)
1608 {
1609         debugt(__func__, "");
1610         if (inr != 2)
1611                 FDCS->reset = 1;
1612         else if (ST0 & ST0_ECE) {
1613                 switch (DRS->track) {
1614                 case NEED_1_RECAL:
1615                         debugt(__func__, "need 1 recal");
1616                         /* after a second recalibrate, we still haven't
1617                          * reached track 0. Probably no drive. Raise an
1618                          * error, as failing immediately might upset
1619                          * computers possessed by the Devil :-) */
1620                         cont->error();
1621                         cont->redo();
1622                         return;
1623                 case NEED_2_RECAL:
1624                         debugt(__func__, "need 2 recal");
1625                         /* If we already did a recalibrate,
1626                          * and we are not at track 0, this
1627                          * means we have moved. (The only way
1628                          * not to move at recalibration is to
1629                          * be already at track 0.) Clear the
1630                          * new change flag */
1631                         debug_dcl(DP->flags,
1632                                   "clearing NEWCHANGE flag because of second recalibrate\n");
1633
1634                         clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
1635                         DRS->select_date = jiffies;
1636                         /* fall through */
1637                 default:
1638                         debugt(__func__, "default");
1639                         /* Recalibrate moves the head by at
1640                          * most 80 steps. If after one
1641                          * recalibrate we don't have reached
1642                          * track 0, this might mean that we
1643                          * started beyond track 80.  Try
1644                          * again.  */
1645                         DRS->track = NEED_1_RECAL;
1646                         break;
1647                 }
1648         } else
1649                 DRS->track = ST1;
1650         floppy_ready();
1651 }
1652
1653 static void print_result(char *message, int inr)
1654 {
1655         int i;
1656
1657         DPRINT("%s ", message);
1658         if (inr >= 0)
1659                 for (i = 0; i < inr; i++)
1660                         pr_cont("repl[%d]=%x ", i, reply_buffer[i]);
1661         pr_cont("\n");
1662 }
1663
1664 /* interrupt handler. Note that this can be called externally on the Sparc */
1665 irqreturn_t floppy_interrupt(int irq, void *dev_id)
1666 {
1667         int do_print;
1668         unsigned long f;
1669         void (*handler)(void) = do_floppy;
1670
1671         lasthandler = handler;
1672         interruptjiffies = jiffies;
1673
1674         f = claim_dma_lock();
1675         fd_disable_dma();
1676         release_dma_lock(f);
1677
1678         do_floppy = NULL;
1679         if (fdc >= N_FDC || FDCS->address == -1) {
1680                 /* we don't even know which FDC is the culprit */
1681                 pr_info("DOR0=%x\n", fdc_state[0].dor);
1682                 pr_info("floppy interrupt on bizarre fdc %d\n", fdc);
1683                 pr_info("handler=%pf\n", handler);
1684                 is_alive(__func__, "bizarre fdc");
1685                 return IRQ_NONE;
1686         }
1687
1688         FDCS->reset = 0;
1689         /* We have to clear the reset flag here, because apparently on boxes
1690          * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
1691          * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
1692          * emission of the SENSEI's.
1693          * It is OK to emit floppy commands because we are in an interrupt
1694          * handler here, and thus we have to fear no interference of other
1695          * activity.
1696          */
1697
1698         do_print = !handler && print_unex && initialized;
1699
1700         inr = result();
1701         if (do_print)
1702                 print_result("unexpected interrupt", inr);
1703         if (inr == 0) {
1704                 int max_sensei = 4;
1705                 do {
1706                         output_byte(FD_SENSEI);
1707                         inr = result();
1708                         if (do_print)
1709                                 print_result("sensei", inr);
1710                         max_sensei--;
1711                 } while ((ST0 & 0x83) != UNIT(current_drive) &&
1712                          inr == 2 && max_sensei);
1713         }
1714         if (!handler) {
1715                 FDCS->reset = 1;
1716                 return IRQ_NONE;
1717         }
1718         schedule_bh(handler);
1719         is_alive(__func__, "normal interrupt end");
1720
1721         /* FIXME! Was it really for us? */
1722         return IRQ_HANDLED;
1723 }
1724
1725 static void recalibrate_floppy(void)
1726 {
1727         debugt(__func__, "");
1728         do_floppy = recal_interrupt;
1729         output_byte(FD_RECALIBRATE);
1730         if (output_byte(UNIT(current_drive)) < 0)
1731                 reset_fdc();
1732 }
1733
1734 /*
1735  * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1736  */
1737 static void reset_interrupt(void)
1738 {
1739         debugt(__func__, "");
1740         result();               /* get the status ready for set_fdc */
1741         if (FDCS->reset) {
1742                 pr_info("reset set in interrupt, calling %pf\n", cont->error);
1743                 cont->error();  /* a reset just after a reset. BAD! */
1744         }
1745         cont->redo();
1746 }
1747
1748 /*
1749  * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1750  * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1751  */
1752 static void reset_fdc(void)
1753 {
1754         unsigned long flags;
1755
1756         do_floppy = reset_interrupt;
1757         FDCS->reset = 0;
1758         reset_fdc_info(0);
1759
1760         /* Pseudo-DMA may intercept 'reset finished' interrupt.  */
1761         /* Irrelevant for systems with true DMA (i386).          */
1762
1763         flags = claim_dma_lock();
1764         fd_disable_dma();
1765         release_dma_lock(flags);
1766
1767         if (FDCS->version >= FDC_82072A)
1768                 fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
1769         else {
1770                 fd_outb(FDCS->dor & ~0x04, FD_DOR);
1771                 udelay(FD_RESET_DELAY);
1772                 fd_outb(FDCS->dor, FD_DOR);
1773         }
1774 }
1775
1776 static void show_floppy(void)
1777 {
1778         int i;
1779
1780         pr_info("\n");
1781         pr_info("floppy driver state\n");
1782         pr_info("-------------------\n");
1783         pr_info("now=%lu last interrupt=%lu diff=%lu last called handler=%pf\n",
1784                 jiffies, interruptjiffies, jiffies - interruptjiffies,
1785                 lasthandler);
1786
1787         pr_info("timeout_message=%s\n", timeout_message);
1788         pr_info("last output bytes:\n");
1789         for (i = 0; i < OLOGSIZE; i++)
1790                 pr_info("%2x %2x %lu\n",
1791                         output_log[(i + output_log_pos) % OLOGSIZE].data,
1792                         output_log[(i + output_log_pos) % OLOGSIZE].status,
1793                         output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1794         pr_info("last result at %lu\n", resultjiffies);
1795         pr_info("last redo_fd_request at %lu\n", lastredo);
1796         print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1,
1797                        reply_buffer, resultsize, true);
1798
1799         pr_info("status=%x\n", fd_inb(FD_STATUS));
1800         pr_info("fdc_busy=%lu\n", fdc_busy);
1801         if (do_floppy)
1802                 pr_info("do_floppy=%pf\n", do_floppy);
1803         if (work_pending(&floppy_work))
1804                 pr_info("floppy_work.func=%pf\n", floppy_work.func);
1805         if (timer_pending(&fd_timer))
1806                 pr_info("fd_timer.function=%pf\n", fd_timer.function);
1807         if (timer_pending(&fd_timeout)) {
1808                 pr_info("timer_function=%pf\n", fd_timeout.function);
1809                 pr_info("expires=%lu\n", fd_timeout.expires - jiffies);
1810                 pr_info("now=%lu\n", jiffies);
1811         }
1812         pr_info("cont=%p\n", cont);
1813         pr_info("current_req=%p\n", current_req);
1814         pr_info("command_status=%d\n", command_status);
1815         pr_info("\n");
1816 }
1817
1818 static void floppy_shutdown(unsigned long data)
1819 {
1820         unsigned long flags;
1821
1822         if (initialized)
1823                 show_floppy();
1824         cancel_activity();
1825
1826         flags = claim_dma_lock();
1827         fd_disable_dma();
1828         release_dma_lock(flags);
1829
1830         /* avoid dma going to a random drive after shutdown */
1831
1832         if (initialized)
1833                 DPRINT("floppy timeout called\n");
1834         FDCS->reset = 1;
1835         if (cont) {
1836                 cont->done(0);
1837                 cont->redo();   /* this will recall reset when needed */
1838         } else {
1839                 pr_info("no cont in shutdown!\n");
1840                 process_fd_request();
1841         }
1842         is_alive(__func__, "");
1843 }
1844
1845 /* start motor, check media-changed condition and write protection */
1846 static int start_motor(void (*function)(void))
1847 {
1848         int mask;
1849         int data;
1850
1851         mask = 0xfc;
1852         data = UNIT(current_drive);
1853         if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1854                 if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
1855                         set_debugt();
1856                         /* no read since this drive is running */
1857                         DRS->first_read_date = 0;
1858                         /* note motor start time if motor is not yet running */
1859                         DRS->spinup_date = jiffies;
1860                         data |= (0x10 << UNIT(current_drive));
1861                 }
1862         } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
1863                 mask &= ~(0x10 << UNIT(current_drive));
1864
1865         /* starts motor and selects floppy */
1866         del_timer(motor_off_timer + current_drive);
1867         set_dor(fdc, mask, data);
1868
1869         /* wait_for_completion also schedules reset if needed. */
1870         return fd_wait_for_completion(DRS->select_date + DP->select_delay,
1871                                       (timeout_fn)function);
1872 }
1873
1874 static void floppy_ready(void)
1875 {
1876         if (FDCS->reset) {
1877                 reset_fdc();
1878                 return;
1879         }
1880         if (start_motor(floppy_ready))
1881                 return;
1882         if (fdc_dtr())
1883                 return;
1884
1885         debug_dcl(DP->flags, "calling disk change from floppy_ready\n");
1886         if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1887             disk_change(current_drive) && !DP->select_delay)
1888                 twaddle();      /* this clears the dcl on certain
1889                                  * drive/controller combinations */
1890
1891 #ifdef fd_chose_dma_mode
1892         if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1893                 unsigned long flags = claim_dma_lock();
1894                 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1895                 release_dma_lock(flags);
1896         }
1897 #endif
1898
1899         if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1900                 perpendicular_mode();
1901                 fdc_specify();  /* must be done here because of hut, hlt ... */
1902                 seek_floppy();
1903         } else {
1904                 if ((raw_cmd->flags & FD_RAW_READ) ||
1905                     (raw_cmd->flags & FD_RAW_WRITE))
1906                         fdc_specify();
1907                 setup_rw_floppy();
1908         }
1909 }
1910
1911 static void floppy_start(void)
1912 {
1913         reschedule_timeout(current_reqD, "floppy start");
1914
1915         scandrives();
1916         debug_dcl(DP->flags, "setting NEWCHANGE in floppy_start\n");
1917         set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
1918         floppy_ready();
1919 }
1920
1921 /*
1922  * ========================================================================
1923  * here ends the bottom half. Exported routines are:
1924  * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
1925  * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
1926  * Initialization also uses output_byte, result, set_dor, floppy_interrupt
1927  * and set_dor.
1928  * ========================================================================
1929  */
1930 /*
1931  * General purpose continuations.
1932  * ==============================
1933  */
1934
1935 static void do_wakeup(void)
1936 {
1937         reschedule_timeout(MAXTIMEOUT, "do wakeup");
1938         cont = NULL;
1939         command_status += 2;
1940         wake_up(&command_done);
1941 }
1942
1943 static const struct cont_t wakeup_cont = {
1944         .interrupt      = empty,
1945         .redo           = do_wakeup,
1946         .error          = empty,
1947         .done           = (done_f)empty
1948 };
1949
1950 static const struct cont_t intr_cont = {
1951         .interrupt      = empty,
1952         .redo           = process_fd_request,
1953         .error          = empty,
1954         .done           = (done_f)empty
1955 };
1956
1957 static int wait_til_done(void (*handler)(void), bool interruptible)
1958 {
1959         int ret;
1960
1961         schedule_bh(handler);
1962
1963         if (interruptible)
1964                 wait_event_interruptible(command_done, command_status >= 2);
1965         else
1966                 wait_event(command_done, command_status >= 2);
1967
1968         if (command_status < 2) {
1969                 cancel_activity();
1970                 cont = &intr_cont;
1971                 reset_fdc();
1972                 return -EINTR;
1973         }
1974
1975         if (FDCS->reset)
1976                 command_status = FD_COMMAND_ERROR;
1977         if (command_status == FD_COMMAND_OKAY)
1978                 ret = 0;
1979         else
1980                 ret = -EIO;
1981         command_status = FD_COMMAND_NONE;
1982         return ret;
1983 }
1984
1985 static void generic_done(int result)
1986 {
1987         command_status = result;
1988         cont = &wakeup_cont;
1989 }
1990
1991 static void generic_success(void)
1992 {
1993         cont->done(1);
1994 }
1995
1996 static void generic_failure(void)
1997 {
1998         cont->done(0);
1999 }
2000
2001 static void success_and_wakeup(void)
2002 {
2003         generic_success();
2004         cont->redo();
2005 }
2006
2007 /*
2008  * formatting and rw support.
2009  * ==========================
2010  */
2011
2012 static int next_valid_format(void)
2013 {
2014         int probed_format;
2015
2016         probed_format = DRS->probed_format;
2017         while (1) {
2018                 if (probed_format >= 8 || !DP->autodetect[probed_format]) {
2019                         DRS->probed_format = 0;
2020                         return 1;
2021                 }
2022                 if (floppy_type[DP->autodetect[probed_format]].sect) {
2023                         DRS->probed_format = probed_format;
2024                         return 0;
2025                 }
2026                 probed_format++;
2027         }
2028 }
2029
2030 static void bad_flp_intr(void)
2031 {
2032         int err_count;
2033
2034         if (probing) {
2035                 DRS->probed_format++;
2036                 if (!next_valid_format())
2037                         return;
2038         }
2039         err_count = ++(*errors);
2040         INFBOUND(DRWE->badness, err_count);
2041         if (err_count > DP->max_errors.abort)
2042                 cont->done(0);
2043         if (err_count > DP->max_errors.reset)
2044                 FDCS->reset = 1;
2045         else if (err_count > DP->max_errors.recal)
2046                 DRS->track = NEED_2_RECAL;
2047 }
2048
2049 static void set_floppy(int drive)
2050 {
2051         int type = ITYPE(UDRS->fd_device);
2052
2053         if (type)
2054                 _floppy = floppy_type + type;
2055         else
2056                 _floppy = current_type[drive];
2057 }
2058
2059 /*
2060  * formatting support.
2061  * ===================
2062  */
2063 static void format_interrupt(void)
2064 {
2065         switch (interpret_errors()) {
2066         case 1:
2067                 cont->error();
2068         case 2:
2069                 break;
2070         case 0:
2071                 cont->done(1);
2072         }
2073         cont->redo();
2074 }
2075
2076 #define FM_MODE(x, y) ((y) & ~(((x)->rate & 0x80) >> 1))
2077 #define CT(x) ((x) | 0xc0)
2078
2079 static void setup_format_params(int track)
2080 {
2081         int n;
2082         int il;
2083         int count;
2084         int head_shift;
2085         int track_shift;
2086         struct fparm {
2087                 unsigned char track, head, sect, size;
2088         } *here = (struct fparm *)floppy_track_buffer;
2089
2090         raw_cmd = &default_raw_cmd;
2091         raw_cmd->track = track;
2092
2093         raw_cmd->flags = (FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2094                           FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK);
2095         raw_cmd->rate = _floppy->rate & 0x43;
2096         raw_cmd->cmd_count = NR_F;
2097         COMMAND = FM_MODE(_floppy, FD_FORMAT);
2098         DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2099         F_SIZECODE = FD_SIZECODE(_floppy);
2100         F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2101         F_GAP = _floppy->fmt_gap;
2102         F_FILL = FD_FILL_BYTE;
2103
2104         raw_cmd->kernel_data = floppy_track_buffer;
2105         raw_cmd->length = 4 * F_SECT_PER_TRACK;
2106
2107         /* allow for about 30ms for data transport per track */
2108         head_shift = (F_SECT_PER_TRACK + 5) / 6;
2109
2110         /* a ``cylinder'' is two tracks plus a little stepping time */
2111         track_shift = 2 * head_shift + 3;
2112
2113         /* position of logical sector 1 on this track */
2114         n = (track_shift * format_req.track + head_shift * format_req.head)
2115             % F_SECT_PER_TRACK;
2116
2117         /* determine interleave */
2118         il = 1;
2119         if (_floppy->fmt_gap < 0x22)
2120                 il++;
2121
2122         /* initialize field */
2123         for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2124                 here[count].track = format_req.track;
2125                 here[count].head = format_req.head;
2126                 here[count].sect = 0;
2127                 here[count].size = F_SIZECODE;
2128         }
2129         /* place logical sectors */
2130         for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2131                 here[n].sect = count;
2132                 n = (n + il) % F_SECT_PER_TRACK;
2133                 if (here[n].sect) {     /* sector busy, find next free sector */
2134                         ++n;
2135                         if (n >= F_SECT_PER_TRACK) {
2136                                 n -= F_SECT_PER_TRACK;
2137                                 while (here[n].sect)
2138                                         ++n;
2139                         }
2140                 }
2141         }
2142         if (_floppy->stretch & FD_SECTBASEMASK) {
2143                 for (count = 0; count < F_SECT_PER_TRACK; count++)
2144                         here[count].sect += FD_SECTBASE(_floppy) - 1;
2145         }
2146 }
2147
2148 static void redo_format(void)
2149 {
2150         buffer_track = -1;
2151         setup_format_params(format_req.track << STRETCH(_floppy));
2152         floppy_start();
2153         debugt(__func__, "queue format request");
2154 }
2155
2156 static const struct cont_t format_cont = {
2157         .interrupt      = format_interrupt,
2158         .redo           = redo_format,
2159         .error          = bad_flp_intr,
2160         .done           = generic_done
2161 };
2162
2163 static int do_format(int drive, struct format_descr *tmp_format_req)
2164 {
2165         int ret;
2166
2167         if (lock_fdc(drive, true))
2168                 return -EINTR;
2169
2170         set_floppy(drive);
2171         if (!_floppy ||
2172             _floppy->track > DP->tracks ||
2173             tmp_format_req->track >= _floppy->track ||
2174             tmp_format_req->head >= _floppy->head ||
2175             (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2176             !_floppy->fmt_gap) {
2177                 process_fd_request();
2178                 return -EINVAL;
2179         }
2180         format_req = *tmp_format_req;
2181         format_errors = 0;
2182         cont = &format_cont;
2183         errors = &format_errors;
2184         ret = wait_til_done(redo_format, true);
2185         if (ret == -EINTR)
2186                 return -EINTR;
2187         process_fd_request();
2188         return ret;
2189 }
2190
2191 /*
2192  * Buffer read/write and support
2193  * =============================
2194  */
2195
2196 static void floppy_end_request(struct request *req, int error)
2197 {
2198         unsigned int nr_sectors = current_count_sectors;
2199         unsigned int drive = (unsigned long)req->rq_disk->private_data;
2200
2201         /* current_count_sectors can be zero if transfer failed */
2202         if (error)
2203                 nr_sectors = blk_rq_cur_sectors(req);
2204         if (__blk_end_request(req, error, nr_sectors << 9))
2205                 return;
2206
2207         /* We're done with the request */
2208         floppy_off(drive);
2209         current_req = NULL;
2210 }
2211
2212 /* new request_done. Can handle physical sectors which are smaller than a
2213  * logical buffer */
2214 static void request_done(int uptodate)
2215 {
2216         struct request *req = current_req;
2217         struct request_queue *q;
2218         unsigned long flags;
2219         int block;
2220         char msg[sizeof("request done ") + sizeof(int) * 3];
2221
2222         probing = 0;
2223         snprintf(msg, sizeof(msg), "request done %d", uptodate);
2224         reschedule_timeout(MAXTIMEOUT, msg);
2225
2226         if (!req) {
2227                 pr_info("floppy.c: no request in request_done\n");
2228                 return;
2229         }
2230
2231         q = req->q;
2232
2233         if (uptodate) {
2234                 /* maintain values for invalidation on geometry
2235                  * change */
2236                 block = current_count_sectors + blk_rq_pos(req);
2237                 INFBOUND(DRS->maxblock, block);
2238                 if (block > _floppy->sect)
2239                         DRS->maxtrack = 1;
2240
2241                 /* unlock chained buffers */
2242                 spin_lock_irqsave(q->queue_lock, flags);
2243                 floppy_end_request(req, 0);
2244                 spin_unlock_irqrestore(q->queue_lock, flags);
2245         } else {
2246                 if (rq_data_dir(req) == WRITE) {
2247                         /* record write error information */
2248                         DRWE->write_errors++;
2249                         if (DRWE->write_errors == 1) {
2250                                 DRWE->first_error_sector = blk_rq_pos(req);
2251                                 DRWE->first_error_generation = DRS->generation;
2252                         }
2253                         DRWE->last_error_sector = blk_rq_pos(req);
2254                         DRWE->last_error_generation = DRS->generation;
2255                 }
2256                 spin_lock_irqsave(q->queue_lock, flags);
2257                 floppy_end_request(req, -EIO);
2258                 spin_unlock_irqrestore(q->queue_lock, flags);
2259         }
2260 }
2261
2262 /* Interrupt handler evaluating the result of the r/w operation */
2263 static void rw_interrupt(void)
2264 {
2265         int eoc;
2266         int ssize;
2267         int heads;
2268         int nr_sectors;
2269
2270         if (R_HEAD >= 2) {
2271                 /* some Toshiba floppy controllers occasionnally seem to
2272                  * return bogus interrupts after read/write operations, which
2273                  * can be recognized by a bad head number (>= 2) */
2274                 return;
2275         }
2276
2277         if (!DRS->first_read_date)
2278                 DRS->first_read_date = jiffies;
2279
2280         nr_sectors = 0;
2281         ssize = DIV_ROUND_UP(1 << SIZECODE, 4);
2282
2283         if (ST1 & ST1_EOC)
2284                 eoc = 1;
2285         else
2286                 eoc = 0;
2287
2288         if (COMMAND & 0x80)
2289                 heads = 2;
2290         else
2291                 heads = 1;
2292
2293         nr_sectors = (((R_TRACK - TRACK) * heads +
2294                        R_HEAD - HEAD) * SECT_PER_TRACK +
2295                       R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2296
2297         if (nr_sectors / ssize >
2298             DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {
2299                 DPRINT("long rw: %x instead of %lx\n",
2300                        nr_sectors, current_count_sectors);
2301                 pr_info("rs=%d s=%d\n", R_SECTOR, SECTOR);
2302                 pr_info("rh=%d h=%d\n", R_HEAD, HEAD);
2303                 pr_info("rt=%d t=%d\n", R_TRACK, TRACK);
2304                 pr_info("heads=%d eoc=%d\n", heads, eoc);
2305                 pr_info("spt=%d st=%d ss=%d\n",
2306                         SECT_PER_TRACK, fsector_t, ssize);
2307                 pr_info("in_sector_offset=%d\n", in_sector_offset);
2308         }
2309
2310         nr_sectors -= in_sector_offset;
2311         INFBOUND(nr_sectors, 0);
2312         SUPBOUND(current_count_sectors, nr_sectors);
2313
2314         switch (interpret_errors()) {
2315         case 2:
2316                 cont->redo();
2317                 return;
2318         case 1:
2319                 if (!current_count_sectors) {
2320                         cont->error();
2321                         cont->redo();
2322                         return;
2323                 }
2324                 break;
2325         case 0:
2326                 if (!current_count_sectors) {
2327                         cont->redo();
2328                         return;
2329                 }
2330                 current_type[current_drive] = _floppy;
2331                 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2332                 break;
2333         }
2334
2335         if (probing) {
2336                 if (DP->flags & FTD_MSG)
2337                         DPRINT("Auto-detected floppy type %s in fd%d\n",
2338                                _floppy->name, current_drive);
2339                 current_type[current_drive] = _floppy;
2340                 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2341                 probing = 0;
2342         }
2343
2344         if (CT(COMMAND) != FD_READ ||
2345             raw_cmd->kernel_data == current_req->buffer) {
2346                 /* transfer directly from buffer */
2347                 cont->done(1);
2348         } else if (CT(COMMAND) == FD_READ) {
2349                 buffer_track = raw_cmd->track;
2350                 buffer_drive = current_drive;
2351                 INFBOUND(buffer_max, nr_sectors + fsector_t);
2352         }
2353         cont->redo();
2354 }
2355
2356 /* Compute maximal contiguous buffer size. */
2357 static int buffer_chain_size(void)
2358 {
2359         struct bio_vec *bv;
2360         int size;
2361         struct req_iterator iter;
2362         char *base;
2363
2364         base = bio_data(current_req->bio);
2365         size = 0;
2366
2367         rq_for_each_segment(bv, current_req, iter) {
2368                 if (page_address(bv->bv_page) + bv->bv_offset != base + size)
2369                         break;
2370
2371                 size += bv->bv_len;
2372         }
2373
2374         return size >> 9;
2375 }
2376
2377 /* Compute the maximal transfer size */
2378 static int transfer_size(int ssize, int max_sector, int max_size)
2379 {
2380         SUPBOUND(max_sector, fsector_t + max_size);
2381
2382         /* alignment */
2383         max_sector -= (max_sector % _floppy->sect) % ssize;
2384
2385         /* transfer size, beginning not aligned */
2386         current_count_sectors = max_sector - fsector_t;
2387
2388         return max_sector;
2389 }
2390
2391 /*
2392  * Move data from/to the track buffer to/from the buffer cache.
2393  */
2394 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2395 {
2396         int remaining;          /* number of transferred 512-byte sectors */
2397         struct bio_vec *bv;
2398         char *buffer;
2399         char *dma_buffer;
2400         int size;
2401         struct req_iterator iter;
2402
2403         max_sector = transfer_size(ssize,
2404                                    min(max_sector, max_sector_2),
2405                                    blk_rq_sectors(current_req));
2406
2407         if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2408             buffer_max > fsector_t + blk_rq_sectors(current_req))
2409                 current_count_sectors = min_t(int, buffer_max - fsector_t,
2410                                               blk_rq_sectors(current_req));
2411
2412         remaining = current_count_sectors << 9;
2413         if (remaining > blk_rq_bytes(current_req) && CT(COMMAND) == FD_WRITE) {
2414                 DPRINT("in copy buffer\n");
2415                 pr_info("current_count_sectors=%ld\n", current_count_sectors);
2416                 pr_info("remaining=%d\n", remaining >> 9);
2417                 pr_info("current_req->nr_sectors=%u\n",
2418                         blk_rq_sectors(current_req));
2419                 pr_info("current_req->current_nr_sectors=%u\n",
2420                         blk_rq_cur_sectors(current_req));
2421                 pr_info("max_sector=%d\n", max_sector);
2422                 pr_info("ssize=%d\n", ssize);
2423         }
2424
2425         buffer_max = max(max_sector, buffer_max);
2426
2427         dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2428
2429         size = blk_rq_cur_bytes(current_req);
2430
2431         rq_for_each_segment(bv, current_req, iter) {
2432                 if (!remaining)
2433                         break;
2434
2435                 size = bv->bv_len;
2436                 SUPBOUND(size, remaining);
2437
2438                 buffer = page_address(bv->bv_page) + bv->bv_offset;
2439                 if (dma_buffer + size >
2440                     floppy_track_buffer + (max_buffer_sectors << 10) ||
2441                     dma_buffer < floppy_track_buffer) {
2442                         DPRINT("buffer overrun in copy buffer %d\n",
2443                                (int)((floppy_track_buffer - dma_buffer) >> 9));
2444                         pr_info("fsector_t=%d buffer_min=%d\n",
2445                                 fsector_t, buffer_min);
2446                         pr_info("current_count_sectors=%ld\n",
2447                                 current_count_sectors);
2448                         if (CT(COMMAND) == FD_READ)
2449                                 pr_info("read\n");
2450                         if (CT(COMMAND) == FD_WRITE)
2451                                 pr_info("write\n");
2452                         break;
2453                 }
2454                 if (((unsigned long)buffer) % 512)
2455                         DPRINT("%p buffer not aligned\n", buffer);
2456
2457                 if (CT(COMMAND) == FD_READ)
2458                         memcpy(buffer, dma_buffer, size);
2459                 else
2460                         memcpy(dma_buffer, buffer, size);
2461
2462                 remaining -= size;
2463                 dma_buffer += size;
2464         }
2465         if (remaining) {
2466                 if (remaining > 0)
2467                         max_sector -= remaining >> 9;
2468                 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2469         }
2470 }
2471
2472 /* work around a bug in pseudo DMA
2473  * (on some FDCs) pseudo DMA does not stop when the CPU stops
2474  * sending data.  Hence we need a different way to signal the
2475  * transfer length:  We use SECT_PER_TRACK.  Unfortunately, this
2476  * does not work with MT, hence we can only transfer one head at
2477  * a time
2478  */
2479 static void virtualdmabug_workaround(void)
2480 {
2481         int hard_sectors;
2482         int end_sector;
2483
2484         if (CT(COMMAND) == FD_WRITE) {
2485                 COMMAND &= ~0x80;       /* switch off multiple track mode */
2486
2487                 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2488                 end_sector = SECTOR + hard_sectors - 1;
2489                 if (end_sector > SECT_PER_TRACK) {
2490                         pr_info("too many sectors %d > %d\n",
2491                                 end_sector, SECT_PER_TRACK);
2492                         return;
2493                 }
2494                 SECT_PER_TRACK = end_sector;
2495                                         /* make sure SECT_PER_TRACK
2496                                          * points to end of transfer */
2497         }
2498 }
2499
2500 /*
2501  * Formulate a read/write request.
2502  * this routine decides where to load the data (directly to buffer, or to
2503  * tmp floppy area), how much data to load (the size of the buffer, the whole
2504  * track, or a single sector)
2505  * All floppy_track_buffer handling goes in here. If we ever add track buffer
2506  * allocation on the fly, it should be done here. No other part should need
2507  * modification.
2508  */
2509
2510 static int make_raw_rw_request(void)
2511 {
2512         int aligned_sector_t;
2513         int max_sector;
2514         int max_size;
2515         int tracksize;
2516         int ssize;
2517
2518         if (WARN(max_buffer_sectors == 0, "VFS: Block I/O scheduled on unopened device\n"))
2519                 return 0;
2520
2521         set_fdc((long)current_req->rq_disk->private_data);
2522
2523         raw_cmd = &default_raw_cmd;
2524         raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2525             FD_RAW_NEED_SEEK;
2526         raw_cmd->cmd_count = NR_RW;
2527         if (rq_data_dir(current_req) == READ) {
2528                 raw_cmd->flags |= FD_RAW_READ;
2529                 COMMAND = FM_MODE(_floppy, FD_READ);
2530         } else if (rq_data_dir(current_req) == WRITE) {
2531                 raw_cmd->flags |= FD_RAW_WRITE;
2532                 COMMAND = FM_MODE(_floppy, FD_WRITE);
2533         } else {
2534                 DPRINT("%s: unknown command\n", __func__);
2535                 return 0;
2536         }
2537
2538         max_sector = _floppy->sect * _floppy->head;
2539
2540         TRACK = (int)blk_rq_pos(current_req) / max_sector;
2541         fsector_t = (int)blk_rq_pos(current_req) % max_sector;
2542         if (_floppy->track && TRACK >= _floppy->track) {
2543                 if (blk_rq_cur_sectors(current_req) & 1) {
2544                         current_count_sectors = 1;
2545                         return 1;
2546                 } else
2547                         return 0;
2548         }
2549         HEAD = fsector_t / _floppy->sect;
2550
2551         if (((_floppy->stretch & (FD_SWAPSIDES | FD_SECTBASEMASK)) ||
2552              test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags)) &&
2553             fsector_t < _floppy->sect)
2554                 max_sector = _floppy->sect;
2555
2556         /* 2M disks have phantom sectors on the first track */
2557         if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2558                 max_sector = 2 * _floppy->sect / 3;
2559                 if (fsector_t >= max_sector) {
2560                         current_count_sectors =
2561                             min_t(int, _floppy->sect - fsector_t,
2562                                   blk_rq_sectors(current_req));
2563                         return 1;
2564                 }
2565                 SIZECODE = 2;
2566         } else
2567                 SIZECODE = FD_SIZECODE(_floppy);
2568         raw_cmd->rate = _floppy->rate & 0x43;
2569         if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2570                 raw_cmd->rate = 1;
2571
2572         if (SIZECODE)
2573                 SIZECODE2 = 0xff;
2574         else
2575                 SIZECODE2 = 0x80;
2576         raw_cmd->track = TRACK << STRETCH(_floppy);
2577         DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2578         GAP = _floppy->gap;
2579         ssize = DIV_ROUND_UP(1 << SIZECODE, 4);
2580         SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2581         SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
2582             FD_SECTBASE(_floppy);
2583
2584         /* tracksize describes the size which can be filled up with sectors
2585          * of size ssize.
2586          */
2587         tracksize = _floppy->sect - _floppy->sect % ssize;
2588         if (tracksize < _floppy->sect) {
2589                 SECT_PER_TRACK++;
2590                 if (tracksize <= fsector_t % _floppy->sect)
2591                         SECTOR--;
2592
2593                 /* if we are beyond tracksize, fill up using smaller sectors */
2594                 while (tracksize <= fsector_t % _floppy->sect) {
2595                         while (tracksize + ssize > _floppy->sect) {
2596                                 SIZECODE--;
2597                                 ssize >>= 1;
2598                         }
2599                         SECTOR++;
2600                         SECT_PER_TRACK++;
2601                         tracksize += ssize;
2602                 }
2603                 max_sector = HEAD * _floppy->sect + tracksize;
2604         } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2605                 max_sector = _floppy->sect;
2606         } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2607                 /* for virtual DMA bug workaround */
2608                 max_sector = _floppy->sect;
2609         }
2610
2611         in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2612         aligned_sector_t = fsector_t - in_sector_offset;
2613         max_size = blk_rq_sectors(current_req);
2614         if ((raw_cmd->track == buffer_track) &&
2615             (current_drive == buffer_drive) &&
2616             (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2617                 /* data already in track buffer */
2618                 if (CT(COMMAND) == FD_READ) {
2619                         copy_buffer(1, max_sector, buffer_max);
2620                         return 1;
2621                 }
2622         } else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {
2623                 if (CT(COMMAND) == FD_WRITE) {
2624                         unsigned int sectors;
2625
2626                         sectors = fsector_t + blk_rq_sectors(current_req);
2627                         if (sectors > ssize && sectors < ssize + ssize)
2628                                 max_size = ssize + ssize;
2629                         else
2630                                 max_size = ssize;
2631                 }
2632                 raw_cmd->flags &= ~FD_RAW_WRITE;
2633                 raw_cmd->flags |= FD_RAW_READ;
2634                 COMMAND = FM_MODE(_floppy, FD_READ);
2635         } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2636                 unsigned long dma_limit;
2637                 int direct, indirect;
2638
2639                 indirect =
2640                     transfer_size(ssize, max_sector,
2641                                   max_buffer_sectors * 2) - fsector_t;
2642
2643                 /*
2644                  * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2645                  * on a 64 bit machine!
2646                  */
2647                 max_size = buffer_chain_size();
2648                 dma_limit = (MAX_DMA_ADDRESS -
2649                              ((unsigned long)current_req->buffer)) >> 9;
2650                 if ((unsigned long)max_size > dma_limit)
2651                         max_size = dma_limit;
2652                 /* 64 kb boundaries */
2653                 if (CROSS_64KB(current_req->buffer, max_size << 9))
2654                         max_size = (K_64 -
2655                                     ((unsigned long)current_req->buffer) %
2656                                     K_64) >> 9;
2657                 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2658                 /*
2659                  * We try to read tracks, but if we get too many errors, we
2660                  * go back to reading just one sector at a time.
2661                  *
2662                  * This means we should be able to read a sector even if there
2663                  * are other bad sectors on this track.
2664                  */
2665                 if (!direct ||
2666                     (indirect * 2 > direct * 3 &&
2667                      *errors < DP->max_errors.read_track &&
2668                      ((!probing ||
2669                        (DP->read_track & (1 << DRS->probed_format)))))) {
2670                         max_size = blk_rq_sectors(current_req);
2671                 } else {
2672                         raw_cmd->kernel_data = current_req->buffer;
2673                         raw_cmd->length = current_count_sectors << 9;
2674                         if (raw_cmd->length == 0) {
2675                                 DPRINT("%s: zero dma transfer attempted\n", __func__);
2676                                 DPRINT("indirect=%d direct=%d fsector_t=%d\n",
2677                                        indirect, direct, fsector_t);
2678                                 return 0;
2679                         }
2680                         virtualdmabug_workaround();
2681                         return 2;
2682                 }
2683         }
2684
2685         if (CT(COMMAND) == FD_READ)
2686                 max_size = max_sector;  /* unbounded */
2687
2688         /* claim buffer track if needed */
2689         if (buffer_track != raw_cmd->track ||   /* bad track */
2690             buffer_drive != current_drive ||    /* bad drive */
2691             fsector_t > buffer_max ||
2692             fsector_t < buffer_min ||
2693             ((CT(COMMAND) == FD_READ ||
2694               (!in_sector_offset && blk_rq_sectors(current_req) >= ssize)) &&
2695              max_sector > 2 * max_buffer_sectors + buffer_min &&
2696              max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)) {
2697                 /* not enough space */
2698                 buffer_track = -1;
2699                 buffer_drive = current_drive;
2700                 buffer_max = buffer_min = aligned_sector_t;
2701         }
2702         raw_cmd->kernel_data = floppy_track_buffer +
2703                 ((aligned_sector_t - buffer_min) << 9);
2704
2705         if (CT(COMMAND) == FD_WRITE) {
2706                 /* copy write buffer to track buffer.
2707                  * if we get here, we know that the write
2708                  * is either aligned or the data already in the buffer
2709                  * (buffer will be overwritten) */
2710                 if (in_sector_offset && buffer_track == -1)
2711                         DPRINT("internal error offset !=0 on write\n");
2712                 buffer_track = raw_cmd->track;
2713                 buffer_drive = current_drive;
2714                 copy_buffer(ssize, max_sector,
2715                             2 * max_buffer_sectors + buffer_min);
2716         } else
2717                 transfer_size(ssize, max_sector,
2718                               2 * max_buffer_sectors + buffer_min -
2719                               aligned_sector_t);
2720
2721         /* round up current_count_sectors to get dma xfer size */
2722         raw_cmd->length = in_sector_offset + current_count_sectors;
2723         raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2724         raw_cmd->length <<= 9;
2725         if ((raw_cmd->length < current_count_sectors << 9) ||
2726             (raw_cmd->kernel_data != current_req->buffer &&
2727              CT(COMMAND) == FD_WRITE &&
2728              (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2729               aligned_sector_t < buffer_min)) ||
2730             raw_cmd->length % (128 << SIZECODE) ||
2731             raw_cmd->length <= 0 || current_count_sectors <= 0) {
2732                 DPRINT("fractionary current count b=%lx s=%lx\n",
2733                        raw_cmd->length, current_count_sectors);
2734                 if (raw_cmd->kernel_data != current_req->buffer)
2735                         pr_info("addr=%d, length=%ld\n",
2736                                 (int)((raw_cmd->kernel_data -
2737                                        floppy_track_buffer) >> 9),
2738                                 current_count_sectors);
2739                 pr_info("st=%d ast=%d mse=%d msi=%d\n",
2740                         fsector_t, aligned_sector_t, max_sector, max_size);
2741                 pr_info("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2742                 pr_info("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2743                         COMMAND, SECTOR, HEAD, TRACK);
2744                 pr_info("buffer drive=%d\n", buffer_drive);
2745                 pr_info("buffer track=%d\n", buffer_track);
2746                 pr_info("buffer_min=%d\n", buffer_min);
2747                 pr_info("buffer_max=%d\n", buffer_max);
2748                 return 0;
2749         }
2750
2751         if (raw_cmd->kernel_data != current_req->buffer) {
2752                 if (raw_cmd->kernel_data < floppy_track_buffer ||
2753                     current_count_sectors < 0 ||
2754                     raw_cmd->length < 0 ||
2755                     raw_cmd->kernel_data + raw_cmd->length >
2756                     floppy_track_buffer + (max_buffer_sectors << 10)) {
2757                         DPRINT("buffer overrun in schedule dma\n");
2758                         pr_info("fsector_t=%d buffer_min=%d current_count=%ld\n",
2759                                 fsector_t, buffer_min, raw_cmd->length >> 9);
2760                         pr_info("current_count_sectors=%ld\n",
2761                                 current_count_sectors);
2762                         if (CT(COMMAND) == FD_READ)
2763                                 pr_info("read\n");
2764                         if (CT(COMMAND) == FD_WRITE)
2765                                 pr_info("write\n");
2766                         return 0;
2767                 }
2768         } else if (raw_cmd->length > blk_rq_bytes(current_req) ||
2769                    current_count_sectors > blk_rq_sectors(current_req)) {
2770                 DPRINT("buffer overrun in direct transfer\n");
2771                 return 0;
2772         } else if (raw_cmd->length < current_count_sectors << 9) {
2773                 DPRINT("more sectors than bytes\n");
2774                 pr_info("bytes=%ld\n", raw_cmd->length >> 9);
2775                 pr_info("sectors=%ld\n", current_count_sectors);
2776         }
2777         if (raw_cmd->length == 0) {
2778                 DPRINT("zero dma transfer attempted from make_raw_request\n");
2779                 return 0;
2780         }
2781
2782         virtualdmabug_workaround();
2783         return 2;
2784 }
2785
2786 /*
2787  * Round-robin between our available drives, doing one request from each
2788  */
2789 static int set_next_request(void)
2790 {
2791         struct request_queue *q;
2792         int old_pos = fdc_queue;
2793
2794         do {
2795                 q = disks[fdc_queue]->queue;
2796                 if (++fdc_queue == N_DRIVE)
2797                         fdc_queue = 0;
2798                 if (q) {
2799                         current_req = blk_fetch_request(q);
2800                         if (current_req)
2801                                 break;
2802                 }
2803         } while (fdc_queue != old_pos);
2804
2805         return current_req != NULL;
2806 }
2807
2808 static void redo_fd_request(void)
2809 {
2810         int drive;
2811         int tmp;
2812
2813         lastredo = jiffies;
2814         if (current_drive < N_DRIVE)
2815                 floppy_off(current_drive);
2816
2817 do_request:
2818         if (!current_req) {
2819                 int pending;
2820
2821                 spin_lock_irq(&floppy_lock);
2822                 pending = set_next_request();
2823                 spin_unlock_irq(&floppy_lock);
2824
2825                 if (!pending) {
2826                         do_floppy = NULL;
2827                         unlock_fdc();
2828                         return;
2829                 }
2830         }
2831         drive = (long)current_req->rq_disk->private_data;
2832         set_fdc(drive);
2833         reschedule_timeout(current_reqD, "redo fd request");
2834
2835         set_floppy(drive);
2836         raw_cmd = &default_raw_cmd;
2837         raw_cmd->flags = 0;
2838         if (start_motor(redo_fd_request))
2839                 return;
2840
2841         disk_change(current_drive);
2842         if (test_bit(current_drive, &fake_change) ||
2843             test_bit(FD_DISK_CHANGED_BIT, &DRS->flags)) {
2844                 DPRINT("disk absent or changed during operation\n");
2845                 request_done(0);
2846                 goto do_request;
2847         }
2848         if (!_floppy) { /* Autodetection */
2849                 if (!probing) {
2850                         DRS->probed_format = 0;
2851                         if (next_valid_format()) {
2852                                 DPRINT("no autodetectable formats\n");
2853                                 _floppy = NULL;
2854                                 request_done(0);
2855                                 goto do_request;
2856                         }
2857                 }
2858                 probing = 1;
2859                 _floppy = floppy_type + DP->autodetect[DRS->probed_format];
2860         } else
2861                 probing = 0;
2862         errors = &(current_req->errors);
2863         tmp = make_raw_rw_request();
2864         if (tmp < 2) {
2865                 request_done(tmp);
2866                 goto do_request;
2867         }
2868
2869         if (test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags))
2870                 twaddle();
2871         schedule_bh(floppy_start);
2872         debugt(__func__, "queue fd request");
2873         return;
2874 }
2875
2876 static const struct cont_t rw_cont = {
2877         .interrupt      = rw_interrupt,
2878         .redo           = redo_fd_request,
2879         .error          = bad_flp_intr,
2880         .done           = request_done
2881 };
2882
2883 static void process_fd_request(void)
2884 {
2885         cont = &rw_cont;
2886         schedule_bh(redo_fd_request);
2887 }
2888
2889 static void do_fd_request(struct request_queue *q)
2890 {
2891         if (WARN(max_buffer_sectors == 0,
2892                  "VFS: %s called on non-open device\n", __func__))
2893                 return;
2894
2895         if (WARN(atomic_read(&usage_count) == 0,
2896                  "warning: usage count=0, current_req=%p sect=%ld type=%x flags=%x\n",
2897                  current_req, (long)blk_rq_pos(current_req), current_req->cmd_type,
2898                  current_req->cmd_flags))
2899                 return;
2900
2901         if (test_bit(0, &fdc_busy)) {
2902                 /* fdc busy, this new request will be treated when the
2903                    current one is done */
2904                 is_alive(__func__, "old request running");
2905                 return;
2906         }
2907         lock_fdc(MAXTIMEOUT, false);
2908         process_fd_request();
2909         is_alive(__func__, "");
2910 }
2911
2912 static const struct cont_t poll_cont = {
2913         .interrupt      = success_and_wakeup,
2914         .redo           = floppy_ready,
2915         .error          = generic_failure,
2916         .done           = generic_done
2917 };
2918
2919 static int poll_drive(bool interruptible, int flag)
2920 {
2921         /* no auto-sense, just clear dcl */
2922         raw_cmd = &default_raw_cmd;
2923         raw_cmd->flags = flag;
2924         raw_cmd->track = 0;
2925         raw_cmd->cmd_count = 0;
2926         cont = &poll_cont;
2927         debug_dcl(DP->flags, "setting NEWCHANGE in poll_drive\n");
2928         set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
2929
2930         return wait_til_done(floppy_ready, interruptible);
2931 }
2932
2933 /*
2934  * User triggered reset
2935  * ====================
2936  */
2937
2938 static void reset_intr(void)
2939 {
2940         pr_info("weird, reset interrupt called\n");
2941 }
2942
2943 static const struct cont_t reset_cont = {
2944         .interrupt      = reset_intr,
2945         .redo           = success_and_wakeup,
2946         .error          = generic_failure,
2947         .done           = generic_done
2948 };
2949
2950 static int user_reset_fdc(int drive, int arg, bool interruptible)
2951 {
2952         int ret;
2953
2954         if (lock_fdc(drive, interruptible))
2955                 return -EINTR;
2956
2957         if (arg == FD_RESET_ALWAYS)
2958                 FDCS->reset = 1;
2959         if (FDCS->reset) {
2960                 cont = &reset_cont;
2961                 ret = wait_til_done(reset_fdc, interruptible);
2962                 if (ret == -EINTR)
2963                         return -EINTR;
2964         }
2965         process_fd_request();
2966         return 0;
2967 }
2968
2969 /*
2970  * Misc Ioctl's and support
2971  * ========================
2972  */
2973 static inline int fd_copyout(void __user *param, const void *address,
2974                              unsigned long size)
2975 {
2976         return copy_to_user(param, address, size) ? -EFAULT : 0;
2977 }
2978
2979 static inline int fd_copyin(void __user *param, void *address,
2980                             unsigned long size)
2981 {
2982         return copy_from_user(address, param, size) ? -EFAULT : 0;
2983 }
2984
2985 static const char *drive_name(int type, int drive)
2986 {
2987         struct floppy_struct *floppy;
2988
2989         if (type)
2990                 floppy = floppy_type + type;
2991         else {
2992                 if (UDP->native_format)
2993                         floppy = floppy_type + UDP->native_format;
2994                 else
2995                         return "(null)";
2996         }
2997         if (floppy->name)
2998                 return floppy->name;
2999         else
3000                 return "(null)";
3001 }
3002
3003 /* raw commands */
3004 static void raw_cmd_done(int flag)
3005 {
3006         int i;
3007
3008         if (!flag) {
3009                 raw_cmd->flags |= FD_RAW_FAILURE;
3010                 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3011         } else {
3012                 raw_cmd->reply_count = inr;
3013                 if (raw_cmd->reply_count > MAX_REPLIES)
3014                         raw_cmd->reply_count = 0;
3015                 for (i = 0; i < raw_cmd->reply_count; i++)
3016                         raw_cmd->reply[i] = reply_buffer[i];
3017
3018                 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3019                         unsigned long flags;
3020                         flags = claim_dma_lock();
3021                         raw_cmd->length = fd_get_dma_residue();
3022                         release_dma_lock(flags);
3023                 }
3024
3025                 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3026                     (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3027                         raw_cmd->flags |= FD_RAW_FAILURE;
3028
3029                 if (disk_change(current_drive))
3030                         raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3031                 else
3032                         raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3033                 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3034                         motor_off_callback(current_drive);
3035
3036                 if (raw_cmd->next &&
3037                     (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3038                      !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3039                     ((raw_cmd->flags & FD_RAW_FAILURE) ||
3040                      !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3041                         raw_cmd = raw_cmd->next;
3042                         return;
3043                 }
3044         }
3045         generic_done(flag);
3046 }
3047
3048 static const struct cont_t raw_cmd_cont = {
3049         .interrupt      = success_and_wakeup,
3050         .redo           = floppy_start,
3051         .error          = generic_failure,
3052         .done           = raw_cmd_done
3053 };
3054
3055 static int raw_cmd_copyout(int cmd, void __user *param,
3056                                   struct floppy_raw_cmd *ptr)
3057 {
3058         int ret;
3059
3060         while (ptr) {
3061                 ret = copy_to_user(param, ptr, sizeof(*ptr));
3062                 if (ret)
3063                         return -EFAULT;
3064                 param += sizeof(struct floppy_raw_cmd);
3065                 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3066                         if (ptr->length >= 0 &&
3067                             ptr->length <= ptr->buffer_length) {
3068                                 long length = ptr->buffer_length - ptr->length;
3069                                 ret = fd_copyout(ptr->data, ptr->kernel_data,
3070                                                  length);
3071                                 if (ret)
3072                                         return ret;
3073                         }
3074                 }
3075                 ptr = ptr->next;
3076         }
3077
3078         return 0;
3079 }
3080
3081 static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3082 {
3083         struct floppy_raw_cmd *next;
3084         struct floppy_raw_cmd *this;
3085
3086         this = *ptr;
3087         *ptr = NULL;
3088         while (this) {
3089                 if (this->buffer_length) {
3090                         fd_dma_mem_free((unsigned long)this->kernel_data,
3091                                         this->buffer_length);
3092                         this->buffer_length = 0;
3093                 }
3094                 next = this->next;
3095                 kfree(this);
3096                 this = next;
3097         }
3098 }
3099
3100 static int raw_cmd_copyin(int cmd, void __user *param,
3101                                  struct floppy_raw_cmd **rcmd)
3102 {
3103         struct floppy_raw_cmd *ptr;
3104         int ret;
3105         int i;
3106
3107         *rcmd = NULL;
3108
3109 loop:
3110         ptr = kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3111         if (!ptr)
3112                 return -ENOMEM;
3113         *rcmd = ptr;
3114         ret = copy_from_user(ptr, param, sizeof(*ptr));
3115         if (ret)
3116                 return -EFAULT;
3117         ptr->next = NULL;
3118         ptr->buffer_length = 0;
3119         param += sizeof(struct floppy_raw_cmd);
3120         if (ptr->cmd_count > 33)
3121                         /* the command may now also take up the space
3122                          * initially intended for the reply & the
3123                          * reply count. Needed for long 82078 commands
3124                          * such as RESTORE, which takes ... 17 command
3125                          * bytes. Murphy's law #137: When you reserve
3126                          * 16 bytes for a structure, you'll one day
3127                          * discover that you really need 17...
3128                          */
3129                 return -EINVAL;
3130
3131         for (i = 0; i < 16; i++)
3132                 ptr->reply[i] = 0;
3133         ptr->resultcode = 0;
3134         ptr->kernel_data = NULL;
3135
3136         if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3137                 if (ptr->length <= 0)
3138                         return -EINVAL;
3139                 ptr->kernel_data = (char *)fd_dma_mem_alloc(ptr->length);
3140                 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3141                 if (!ptr->kernel_data)
3142                         return -ENOMEM;
3143                 ptr->buffer_length = ptr->length;
3144         }
3145         if (ptr->flags & FD_RAW_WRITE) {
3146                 ret = fd_copyin(ptr->data, ptr->kernel_data, ptr->length);
3147                 if (ret)
3148                         return ret;
3149         }
3150
3151         if (ptr->flags & FD_RAW_MORE) {
3152                 rcmd = &(ptr->next);
3153                 ptr->rate &= 0x43;
3154                 goto loop;
3155         }
3156
3157         return 0;
3158 }
3159
3160 static int raw_cmd_ioctl(int cmd, void __user *param)
3161 {
3162         struct floppy_raw_cmd *my_raw_cmd;
3163         int drive;
3164         int ret2;
3165         int ret;
3166
3167         if (FDCS->rawcmd <= 1)
3168                 FDCS->rawcmd = 1;
3169         for (drive = 0; drive < N_DRIVE; drive++) {
3170                 if (FDC(drive) != fdc)
3171                         continue;
3172                 if (drive == current_drive) {
3173                         if (UDRS->fd_ref > 1) {
3174                                 FDCS->rawcmd = 2;
3175                                 break;
3176                         }
3177                 } else if (UDRS->fd_ref) {
3178                         FDCS->rawcmd = 2;
3179                         break;
3180                 }
3181         }
3182
3183         if (FDCS->reset)
3184                 return -EIO;
3185
3186         ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3187         if (ret) {
3188                 raw_cmd_free(&my_raw_cmd);
3189                 return ret;
3190         }
3191
3192         raw_cmd = my_raw_cmd;
3193         cont = &raw_cmd_cont;
3194         ret = wait_til_done(floppy_start, true);
3195         debug_dcl(DP->flags, "calling disk change from raw_cmd ioctl\n");
3196
3197         if (ret != -EINTR && FDCS->reset)
3198                 ret = -EIO;
3199
3200         DRS->track = NO_TRACK;
3201
3202         ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3203         if (!ret)
3204                 ret = ret2;
3205         raw_cmd_free(&my_raw_cmd);
3206         return ret;
3207 }
3208
3209 static int invalidate_drive(struct block_device *bdev)
3210 {
3211         /* invalidate the buffer track to force a reread */
3212         set_bit((long)bdev->bd_disk->private_data, &fake_change);
3213         process_fd_request();
3214         check_disk_change(bdev);
3215         return 0;
3216 }
3217
3218 static int set_geometry(unsigned int cmd, struct floppy_struct *g,
3219                                int drive, int type, struct block_device *bdev)
3220 {
3221         int cnt;
3222
3223         /* sanity checking for parameters. */
3224         if (g->sect <= 0 ||
3225             g->head <= 0 ||
3226             g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3227             /* check if reserved bits are set */
3228             (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0)
3229                 return -EINVAL;
3230         if (type) {
3231                 if (!capable(CAP_SYS_ADMIN))
3232                         return -EPERM;
3233                 mutex_lock(&open_lock);
3234                 if (lock_fdc(drive, true)) {
3235                         mutex_unlock(&open_lock);
3236                         return -EINTR;
3237                 }
3238                 floppy_type[type] = *g;
3239                 floppy_type[type].name = "user format";
3240                 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3241                         floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3242                             floppy_type[type].size + 1;
3243                 process_fd_request();
3244                 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3245                         struct block_device *bdev = opened_bdev[cnt];
3246                         if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3247                                 continue;
3248                         __invalidate_device(bdev, true);
3249                 }
3250                 mutex_unlock(&open_lock);
3251         } else {
3252                 int oldStretch;
3253
3254                 if (lock_fdc(drive, true))
3255                         return -EINTR;
3256                 if (cmd != FDDEFPRM) {
3257                         /* notice a disk change immediately, else
3258                          * we lose our settings immediately*/
3259                         if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
3260                                 return -EINTR;
3261                 }
3262                 oldStretch = g->stretch;
3263                 user_params[drive] = *g;
3264                 if (buffer_drive == drive)
3265                         SUPBOUND(buffer_max, user_params[drive].sect);
3266                 current_type[drive] = &user_params[drive];
3267                 floppy_sizes[drive] = user_params[drive].size;
3268                 if (cmd == FDDEFPRM)
3269                         DRS->keep_data = -1;
3270                 else
3271                         DRS->keep_data = 1;
3272                 /* invalidation. Invalidate only when needed, i.e.
3273                  * when there are already sectors in the buffer cache
3274                  * whose number will change. This is useful, because
3275                  * mtools often changes the geometry of the disk after
3276                  * looking at the boot block */
3277                 if (DRS->maxblock > user_params[drive].sect ||
3278                     DRS->maxtrack ||
3279                     ((user_params[drive].sect ^ oldStretch) &
3280                      (FD_SWAPSIDES | FD_SECTBASEMASK)))
3281                         invalidate_drive(bdev);
3282                 else
3283                         process_fd_request();
3284         }
3285         return 0;
3286 }
3287
3288 /* handle obsolete ioctl's */
3289 static unsigned int ioctl_table[] = {
3290         FDCLRPRM,
3291         FDSETPRM,
3292         FDDEFPRM,
3293         FDGETPRM,
3294         FDMSGON,
3295         FDMSGOFF,
3296         FDFMTBEG,
3297         FDFMTTRK,
3298         FDFMTEND,
3299         FDSETEMSGTRESH,
3300         FDFLUSH,
3301         FDSETMAXERRS,
3302         FDGETMAXERRS,
3303         FDGETDRVTYP,
3304         FDSETDRVPRM,
3305         FDGETDRVPRM,
3306         FDGETDRVSTAT,
3307         FDPOLLDRVSTAT,
3308         FDRESET,
3309         FDGETFDCSTAT,
3310         FDWERRORCLR,
3311         FDWERRORGET,
3312         FDRAWCMD,
3313         FDEJECT,
3314         FDTWADDLE
3315 };
3316
3317 static int normalize_ioctl(unsigned int *cmd, int *size)
3318 {
3319         int i;
3320
3321         for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3322                 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3323                         *size = _IOC_SIZE(*cmd);
3324                         *cmd = ioctl_table[i];
3325                         if (*size > _IOC_SIZE(*cmd)) {
3326                                 pr_info("ioctl not yet supported\n");
3327                                 return -EFAULT;
3328                         }
3329                         return 0;
3330                 }
3331         }
3332         return -EINVAL;
3333 }
3334
3335 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3336 {
3337         if (type)
3338                 *g = &floppy_type[type];
3339         else {
3340                 if (lock_fdc(drive, false))
3341                         return -EINTR;
3342                 if (poll_drive(false, 0) == -EINTR)
3343                         return -EINTR;
3344                 process_fd_request();
3345                 *g = current_type[drive];
3346         }
3347         if (!*g)
3348                 return -ENODEV;
3349         return 0;
3350 }
3351
3352 static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3353 {
3354