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