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