2 * linux/drivers/block/floppy.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1993, 1994 Alain Knaff
6 * Copyright (C) 1998 Alan Cox
9 * 02.12.91 - Changed to static variables to indicate need for reset
10 * and recalibrate. This makes some things easier (output_byte reset
11 * checking etc), and means less interrupt jumping in case of errors,
12 * so the code is hopefully easier to understand.
16 * This file is certainly a mess. I've tried my best to get it working,
17 * but I don't like programming floppies, and I have only one anyway.
18 * Urgel. I should check for more errors, and do more graceful error
19 * recovery. Seems there are problems with several drives. I've tried to
20 * correct them. No promises.
24 * As with hd.c, all routines within this file can (and will) be called
25 * by interrupts, so extreme caution is needed. A hardware interrupt
26 * handler may not sleep, or a kernel panic will happen. Thus I cannot
27 * call "floppy-on" directly, but have to set a special timer interrupt
32 * 28.02.92 - made track-buffering routines, based on the routines written
33 * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
37 * Automatic floppy-detection and formatting written by Werner Almesberger
38 * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with
39 * the floppy-change signal detection.
43 * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
44 * FDC data overrun bug, added some preliminary stuff for vertical
47 * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
49 * TODO: Errors are still not counted properly.
53 * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl)
54 * modeled after the freeware MS-DOS program fdformat/88 V1.8 by
55 * Christoph H. Hochst\"atter.
56 * I have fixed the shift values to the ones I always use. Maybe a new
57 * ioctl() should be created to be able to modify them.
58 * There is a bug in the driver that makes it impossible to format a
59 * floppy as the first thing after bootup.
63 * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
64 * this helped the floppy driver as well. Much cleaner, and still seems to
68 /* 1994/6/24 --bbroad-- added the floppy table entries and made
69 * minor modifications to allow 2.88 floppies to be run.
72 /* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
77 * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
78 * format bug fixes, but unfortunately some new bugs too...
81 /* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
82 * errors to allow safe writing by specialized programs.
85 /* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
86 * by defining bit 1 of the "stretch" parameter to mean put sectors on the
87 * opposite side of the disk, leaving the sector IDs alone (i.e. Commodore's
88 * drives are "upside-down").
92 * 1995/8/26 -- Andreas Busse -- added Mips support.
96 * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
97 * features to asm/floppy.h.
101 * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
105 * 1998/05/07 -- Russell King -- More portability cleanups; moved definition of
106 * interrupt and dma channel to asm/floppy.h. Cleaned up some formatting &
107 * use of '0' for NULL.
111 * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
116 * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
120 * 1999/08/13 -- Paul Slootman -- floppy stopped working on Alpha after 24
121 * days, 6 hours, 32 minutes and 32 seconds (i.e. MAXINT jiffies; ints were
122 * being used to store jiffies, which are unsigned longs).
126 * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
127 * - get rid of check_region
132 * 2001/08/26 -- Paul Gortmaker - fix insmod oops on machines with no
133 * floppy controller (lingering task on list after module is gone... boom.)
137 * 2002/02/07 -- Anton Altaparmakov - Fix io ports reservation to correct range
138 * (0x3f2-0x3f5, 0x3f7). This fix is a bit of a hack but the proper fix
139 * requires many non-obvious changes in arch dependent code.
142 /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
143 * Better audit of register_blkdev.
146 #define FLOPPY_SANITY_CHECK
147 #undef FLOPPY_SILENT_DCL_CLEAR
149 #define REALLY_SLOW_IO
152 #define DCL_DEBUG /* debug disk change line */
154 /* do print messages for unexpected interrupts */
155 static int print_unex = 1;
156 #include <linux/module.h>
157 #include <linux/sched.h>
158 #include <linux/fs.h>
159 #include <linux/kernel.h>
160 #include <linux/timer.h>
161 #include <linux/workqueue.h>
163 #include <linux/fdreg.h>
165 #include <linux/fd.h>
166 #include <linux/hdreg.h>
168 #include <linux/errno.h>
169 #include <linux/slab.h>
170 #include <linux/mm.h>
171 #include <linux/bio.h>
172 #include <linux/string.h>
173 #include <linux/fcntl.h>
174 #include <linux/delay.h>
175 #include <linux/mc146818rtc.h> /* CMOS defines */
176 #include <linux/ioport.h>
177 #include <linux/interrupt.h>
178 #include <linux/init.h>
179 #include <linux/devfs_fs_kernel.h>
180 #include <linux/platform_device.h>
181 #include <linux/buffer_head.h> /* for invalidate_buffers() */
184 * PS/2 floppies have much slower step rates than regular floppies.
185 * It's been recommended that take about 1/4 of the default speed
186 * in some more extreme cases.
188 static int slow_floppy;
192 #include <asm/system.h>
194 #include <asm/uaccess.h>
196 static int FLOPPY_IRQ = 6;
197 static int FLOPPY_DMA = 2;
198 static int can_use_virtual_dma = 2;
200 * can use virtual DMA:
201 * 0 = use of virtual DMA disallowed by config
202 * 1 = use of virtual DMA prescribed by config
203 * 2 = no virtual DMA preference configured. By default try hard DMA,
204 * but fall back on virtual DMA when not enough memory available
207 static int use_virtual_dma;
211 * 1 using virtual DMA
212 * This variable is set to virtual when a DMA mem problem arises, and
213 * reset back in floppy_grab_irq_and_dma.
214 * It is not safe to reset it in other circumstances, because the floppy
215 * driver may have several buffers in use at once, and we do currently not
216 * record each buffers capabilities
219 static DEFINE_SPINLOCK(floppy_lock);
220 static struct completion device_release;
222 static unsigned short virtual_dma_port = 0x3f0;
223 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
224 static int set_dor(int fdc, char mask, char data);
225 static void register_devfs_entries(int drive) __init;
227 #define K_64 0x10000 /* 64KB */
229 /* the following is the mask of allowed drives. By default units 2 and
230 * 3 of both floppy controllers are disabled, because switching on the
231 * motor of these drives causes system hangs on some PCI computers. drive
232 * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
233 * a drive is allowed.
235 * NOTE: This must come before we include the arch floppy header because
236 * some ports reference this variable from there. -DaveM
239 static int allowed_drive_mask = 0x33;
241 #include <asm/floppy.h>
243 static int irqdma_allocated;
245 #define LOCAL_END_REQUEST
246 #define DEVICE_NAME "floppy"
248 #include <linux/blkdev.h>
249 #include <linux/blkpg.h>
250 #include <linux/cdrom.h> /* for the compatibility eject ioctl */
251 #include <linux/completion.h>
253 static struct request *current_req;
254 static struct request_queue *floppy_queue;
255 static void do_fd_request(request_queue_t * q);
257 #ifndef fd_get_dma_residue
258 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
261 /* Dma Memory related stuff */
263 #ifndef fd_dma_mem_free
264 #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
267 #ifndef fd_dma_mem_alloc
268 #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
271 static inline void fallback_on_nodma_alloc(char **addr, size_t l)
273 #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
275 return; /* we have the memory */
276 if (can_use_virtual_dma != 2)
277 return; /* no fallback allowed */
279 ("DMA memory shortage. Temporarily falling back on virtual DMA\n");
280 *addr = (char *)nodma_mem_alloc(l);
286 /* End dma memory related stuff */
288 static unsigned long fake_change;
289 static int initialising = 1;
291 #define ITYPE(x) (((x)>>2) & 0x1f)
292 #define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
293 #define UNIT(x) ((x) & 0x03) /* drive on fdc */
294 #define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
295 #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
296 /* reverse mapping from unit and fdc to drive */
297 #define DP (&drive_params[current_drive])
298 #define DRS (&drive_state[current_drive])
299 #define DRWE (&write_errors[current_drive])
300 #define FDCS (&fdc_state[fdc])
301 #define CLEARF(x) (clear_bit(x##_BIT, &DRS->flags))
302 #define SETF(x) (set_bit(x##_BIT, &DRS->flags))
303 #define TESTF(x) (test_bit(x##_BIT, &DRS->flags))
305 #define UDP (&drive_params[drive])
306 #define UDRS (&drive_state[drive])
307 #define UDRWE (&write_errors[drive])
308 #define UFDCS (&fdc_state[FDC(drive)])
309 #define UCLEARF(x) (clear_bit(x##_BIT, &UDRS->flags))
310 #define USETF(x) (set_bit(x##_BIT, &UDRS->flags))
311 #define UTESTF(x) (test_bit(x##_BIT, &UDRS->flags))
313 #define DPRINT(format, args...) printk(DEVICE_NAME "%d: " format, current_drive , ## args)
315 #define PH_HEAD(floppy,head) (((((floppy)->stretch & 2) >>1) ^ head) << 2)
316 #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
318 #define CLEARSTRUCT(x) memset((x), 0, sizeof(*(x)))
321 #define COMMAND raw_cmd->cmd[0]
322 #define DR_SELECT raw_cmd->cmd[1]
323 #define TRACK raw_cmd->cmd[2]
324 #define HEAD raw_cmd->cmd[3]
325 #define SECTOR raw_cmd->cmd[4]
326 #define SIZECODE raw_cmd->cmd[5]
327 #define SECT_PER_TRACK raw_cmd->cmd[6]
328 #define GAP raw_cmd->cmd[7]
329 #define SIZECODE2 raw_cmd->cmd[8]
333 #define F_SIZECODE raw_cmd->cmd[2]
334 #define F_SECT_PER_TRACK raw_cmd->cmd[3]
335 #define F_GAP raw_cmd->cmd[4]
336 #define F_FILL raw_cmd->cmd[5]
340 * Maximum disk size (in kilobytes). This default is used whenever the
341 * current disk size is unknown.
342 * [Now it is rather a minimum]
344 #define MAX_DISK_SIZE 4 /* 3984 */
347 * globals used by 'result()'
349 #define MAX_REPLIES 16
350 static unsigned char reply_buffer[MAX_REPLIES];
351 static int inr; /* size of reply buffer, when called from interrupt */
352 #define ST0 (reply_buffer[0])
353 #define ST1 (reply_buffer[1])
354 #define ST2 (reply_buffer[2])
355 #define ST3 (reply_buffer[0]) /* result of GETSTATUS */
356 #define R_TRACK (reply_buffer[3])
357 #define R_HEAD (reply_buffer[4])
358 #define R_SECTOR (reply_buffer[5])
359 #define R_SIZECODE (reply_buffer[6])
361 #define SEL_DLY (2*HZ/100)
364 * this struct defines the different floppy drive types.
367 struct floppy_drive_params params;
368 const char *name; /* name printed while booting */
369 } default_drive_params[] = {
370 /* NOTE: the time values in jiffies should be in msec!
372 | Maximum data rate supported by drive type
373 | | Head load time, msec
374 | | | Head unload time, msec (not used)
375 | | | | Step rate interval, usec
376 | | | | | Time needed for spinup time (jiffies)
377 | | | | | | Timeout for spinning down (jiffies)
378 | | | | | | | Spindown offset (where disk stops)
379 | | | | | | | | Select delay
380 | | | | | | | | | RPS
381 | | | | | | | | | | Max number of tracks
382 | | | | | | | | | | | Interrupt timeout
383 | | | | | | | | | | | | Max nonintlv. sectors
384 | | | | | | | | | | | | | -Max Errors- flags */
385 {{0, 500, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 80, 3*HZ, 20, {3,1,2,0,2}, 0,
386 0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
388 {{1, 300, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 40, 3*HZ, 17, {3,1,2,0,2}, 0,
389 0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
391 {{2, 500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6, 83, 3*HZ, 17, {3,1,2,0,2}, 0,
392 0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
394 {{3, 250, 16, 16, 3000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
395 0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
397 {{4, 500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
398 0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
400 {{5, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
401 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
403 {{6, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
404 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
405 /* | --autodetected formats--- | | |
406 * read_track | | Name printed when booting
408 * Frequency of disk change checks */
411 static struct floppy_drive_params drive_params[N_DRIVE];
412 static struct floppy_drive_struct drive_state[N_DRIVE];
413 static struct floppy_write_errors write_errors[N_DRIVE];
414 static struct timer_list motor_off_timer[N_DRIVE];
415 static struct gendisk *disks[N_DRIVE];
416 static struct block_device *opened_bdev[N_DRIVE];
417 static DECLARE_MUTEX(open_lock);
418 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
421 * This struct defines the different floppy types.
423 * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
424 * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
425 * tells if the disk is in Commodore 1581 format, which means side 0 sectors
426 * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
427 * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
428 * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
429 * side 0 is on physical side 0 (but with the misnamed sector IDs).
430 * 'stretch' should probably be renamed to something more general, like
431 * 'options'. Other parameters should be self-explanatory (see also
441 | | | | | | Data rate, | 0x40 for perp
442 | | | | | | | Spec1 (stepping rate, head unload
443 | | | | | | | | /fmt gap (gap2) */
444 static struct floppy_struct floppy_type[32] = {
445 { 0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL }, /* 0 no testing */
446 { 720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360" }, /* 1 360KB PC */
447 { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /* 2 1.2MB AT */
448 { 720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360" }, /* 3 360KB SS 3.5" */
449 { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720" }, /* 4 720KB 3.5" */
450 { 720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360" }, /* 5 360KB AT */
451 { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720" }, /* 6 720KB AT */
452 { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /* 7 1.44MB 3.5" */
453 { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /* 8 2.88MB 3.5" */
454 { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /* 9 3.12MB 3.5" */
456 { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25" */
457 { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5" */
458 { 820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410" }, /* 12 410KB 5.25" */
459 { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820" }, /* 13 820KB 3.5" */
460 { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25" */
461 { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5" */
462 { 840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420" }, /* 16 420KB 5.25" */
463 { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830" }, /* 17 830KB 3.5" */
464 { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25" */
465 { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5" */
467 { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880" }, /* 20 880KB 5.25" */
468 { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5" */
469 { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5" */
470 { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25" */
471 { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5" */
472 { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5" */
473 { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5" */
474 { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5" */
475 { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5" */
477 { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5" */
478 { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800" }, /* 30 800KB 3.5" */
479 { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5" */
482 #define NUMBER(x) (sizeof(x) / sizeof(*(x)))
483 #define SECTSIZE (_FD_SECTSIZE(*floppy))
485 /* Auto-detection: Disk type used until the next media change occurs. */
486 static struct floppy_struct *current_type[N_DRIVE];
489 * User-provided type information. current_type points to
490 * the respective entry of this array.
492 static struct floppy_struct user_params[N_DRIVE];
494 static sector_t floppy_sizes[256];
496 static char floppy_device_name[] = "floppy";
499 * The driver is trying to determine the correct media format
500 * while probing is set. rw_interrupt() clears it after a
505 /* Synchronization of FDC access. */
506 #define FD_COMMAND_NONE -1
507 #define FD_COMMAND_ERROR 2
508 #define FD_COMMAND_OKAY 3
510 static volatile int command_status = FD_COMMAND_NONE;
511 static unsigned long fdc_busy;
512 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
513 static DECLARE_WAIT_QUEUE_HEAD(command_done);
515 #define NO_SIGNAL (!interruptible || !signal_pending(current))
516 #define CALL(x) if ((x) == -EINTR) return -EINTR
517 #define ECALL(x) if ((ret = (x))) return ret;
518 #define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
519 #define WAIT(x) _WAIT((x),interruptible)
520 #define IWAIT(x) _WAIT((x),1)
522 /* Errors during formatting are counted here. */
523 static int format_errors;
525 /* Format request descriptor. */
526 static struct format_descr format_req;
529 * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
530 * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
531 * H is head unload time (1=16ms, 2=32ms, etc)
536 * Because these are written to by the DMA controller, they must
537 * not contain a 64k byte boundary crossing, or data will be
540 static char *floppy_track_buffer;
541 static int max_buffer_sectors;
544 typedef void (*done_f) (int);
545 static struct cont_t {
546 void (*interrupt) (void); /* this is called after the interrupt of the
548 void (*redo) (void); /* this is called to retry the operation */
549 void (*error) (void); /* this is called to tally an error */
550 done_f done; /* this is called to say if the operation has
551 * succeeded/failed */
554 static void floppy_ready(void);
555 static void floppy_start(void);
556 static void process_fd_request(void);
557 static void recalibrate_floppy(void);
558 static void floppy_shutdown(unsigned long);
560 static int floppy_grab_irq_and_dma(void);
561 static void floppy_release_irq_and_dma(void);
564 * The "reset" variable should be tested whenever an interrupt is scheduled,
565 * after the commands have been sent. This is to ensure that the driver doesn't
566 * get wedged when the interrupt doesn't come because of a failed command.
567 * reset doesn't need to be tested before sending commands, because
568 * output_byte is automatically disabled when reset is set.
570 #define CHECK_RESET { if (FDCS->reset){ reset_fdc(); return; } }
571 static void reset_fdc(void);
574 * These are global variables, as that's the easiest way to give
575 * information to interrupts. They are the data used for the current
579 #define NEED_1_RECAL -2
580 #define NEED_2_RECAL -3
582 static int usage_count;
584 /* buffer related variables */
585 static int buffer_track = -1;
586 static int buffer_drive = -1;
587 static int buffer_min = -1;
588 static int buffer_max = -1;
590 /* fdc related variables, should end up in a struct */
591 static struct floppy_fdc_state fdc_state[N_FDC];
592 static int fdc; /* current fdc */
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 */
602 static inline int fd_eject(int drive)
613 static long unsigned debugtimer;
615 static inline void set_debugt(void)
617 debugtimer = jiffies;
620 static inline void debugt(const char *message)
622 if (DP->flags & DEBUGT)
623 printk("%s dtime=%lu\n", message, jiffies - debugtimer);
626 static inline void set_debugt(void) { }
627 static inline void debugt(const char *message) { }
630 typedef void (*timeout_fn) (unsigned long);
631 static DEFINE_TIMER(fd_timeout, floppy_shutdown, 0, 0);
633 static const char *timeout_message;
635 #ifdef FLOPPY_SANITY_CHECK
636 static void is_alive(const char *message)
638 /* this routine checks whether the floppy driver is "alive" */
639 if (test_bit(0, &fdc_busy) && command_status < 2
640 && !timer_pending(&fd_timeout)) {
641 DPRINT("timeout handler died: %s\n", message);
646 static void (*do_floppy) (void) = NULL;
648 #ifdef FLOPPY_SANITY_CHECK
652 static void (*lasthandler) (void);
653 static unsigned long interruptjiffies;
654 static unsigned long resultjiffies;
655 static int resultsize;
656 static unsigned long lastredo;
658 static struct output_log {
660 unsigned char status;
661 unsigned long jiffies;
662 } output_log[OLOGSIZE];
664 static int output_log_pos;
667 #define current_reqD -1
668 #define MAXTIMEOUT -2
670 static void __reschedule_timeout(int drive, const char *message, int marg)
672 if (drive == current_reqD)
673 drive = current_drive;
674 del_timer(&fd_timeout);
675 if (drive < 0 || drive > N_DRIVE) {
676 fd_timeout.expires = jiffies + 20UL * HZ;
679 fd_timeout.expires = jiffies + UDP->timeout;
680 add_timer(&fd_timeout);
681 if (UDP->flags & FD_DEBUG) {
682 DPRINT("reschedule timeout ");
683 printk(message, marg);
686 timeout_message = message;
689 static void reschedule_timeout(int drive, const char *message, int marg)
693 spin_lock_irqsave(&floppy_lock, flags);
694 __reschedule_timeout(drive, message, marg);
695 spin_unlock_irqrestore(&floppy_lock, flags);
698 #define INFBOUND(a,b) (a)=max_t(int, a, b)
700 #define SUPBOUND(a,b) (a)=min_t(int, a, b)
703 * Bottom half floppy driver.
704 * ==========================
706 * This part of the file contains the code talking directly to the hardware,
707 * and also the main service loop (seek-configure-spinup-command)
712 * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
713 * and the last_checked date.
715 * last_checked is the date of the last check which showed 'no disk change'
716 * FD_DISK_CHANGE is set under two conditions:
717 * 1. The floppy has been changed after some i/o to that floppy already
719 * 2. No floppy disk is in the drive. This is done in order to ensure that
720 * requests are quickly flushed in case there is no disk in the drive. It
721 * follows that FD_DISK_CHANGE can only be cleared if there is a disk in
724 * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
725 * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
726 * each seek. If a disk is present, the disk change line should also be
727 * cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
728 * change line is set, this means either that no disk is in the drive, or
729 * that it has been removed since the last seek.
731 * This means that we really have a third possibility too:
732 * The floppy has been changed after the last seek.
735 static int disk_change(int drive)
737 int fdc = FDC(drive);
738 #ifdef FLOPPY_SANITY_CHECK
739 if (jiffies - UDRS->select_date < UDP->select_delay)
740 DPRINT("WARNING disk change called early\n");
741 if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
742 (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
743 DPRINT("probing disk change on unselected drive\n");
744 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
745 (unsigned int)FDCS->dor);
750 if (UDP->flags & FD_DEBUG) {
751 DPRINT("checking disk change line for drive %d\n", drive);
752 DPRINT("jiffies=%lu\n", jiffies);
753 DPRINT("disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
754 DPRINT("flags=%lx\n", UDRS->flags);
757 if (UDP->flags & FD_BROKEN_DCL)
758 return UTESTF(FD_DISK_CHANGED);
759 if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
760 USETF(FD_VERIFY); /* verify write protection */
761 if (UDRS->maxblock) {
762 /* mark it changed */
763 USETF(FD_DISK_CHANGED);
766 /* invalidate its geometry */
767 if (UDRS->keep_data >= 0) {
768 if ((UDP->flags & FTD_MSG) &&
769 current_type[drive] != NULL)
770 DPRINT("Disk type is undefined after "
772 current_type[drive] = NULL;
773 floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
776 /*USETF(FD_DISK_NEWCHANGE); */
779 UDRS->last_checked = jiffies;
780 UCLEARF(FD_DISK_NEWCHANGE);
785 static inline int is_selected(int dor, int unit)
787 return ((dor & (0x10 << unit)) && (dor & 3) == unit);
790 static int set_dor(int fdc, char mask, char data)
792 register unsigned char drive, unit, newdor, olddor;
794 if (FDCS->address == -1)
798 newdor = (olddor & mask) | data;
799 if (newdor != olddor) {
801 if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
802 drive = REVDRIVE(fdc, unit);
804 if (UDP->flags & FD_DEBUG) {
805 DPRINT("calling disk change from set_dor\n");
811 fd_outb(newdor, FD_DOR);
814 if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
815 drive = REVDRIVE(fdc, unit);
816 UDRS->select_date = jiffies;
820 * We should propagate failures to grab the resources back
821 * nicely from here. Actually we ought to rewrite the fd
822 * driver some day too.
824 if (newdor & FLOPPY_MOTOR_MASK)
825 floppy_grab_irq_and_dma();
826 if (olddor & FLOPPY_MOTOR_MASK)
827 floppy_release_irq_and_dma();
831 static void twaddle(void)
833 if (DP->select_delay)
835 fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
836 fd_outb(FDCS->dor, FD_DOR);
837 DRS->select_date = jiffies;
840 /* reset all driver information about the current fdc. This is needed after
841 * a reset, and after a raw command. */
842 static void reset_fdc_info(int mode)
846 FDCS->spec1 = FDCS->spec2 = -1;
847 FDCS->need_configure = 1;
850 for (drive = 0; drive < N_DRIVE; drive++)
851 if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
852 UDRS->track = NEED_2_RECAL;
855 /* selects the fdc and drive, and enables the fdc's input/dma. */
856 static void set_fdc(int drive)
858 if (drive >= 0 && drive < N_DRIVE) {
860 current_drive = drive;
862 if (fdc != 1 && fdc != 0) {
863 printk("bad fdc value\n");
868 set_dor(1 - fdc, ~8, 0);
870 if (FDCS->rawcmd == 2)
872 if (fd_inb(FD_STATUS) != STATUS_READY)
876 /* locks the driver */
877 static int _lock_fdc(int drive, int interruptible, int line)
881 "Trying to lock fdc while usage count=0 at line %d\n",
885 if (floppy_grab_irq_and_dma() == -1)
888 if (test_and_set_bit(0, &fdc_busy)) {
889 DECLARE_WAITQUEUE(wait, current);
890 add_wait_queue(&fdc_wait, &wait);
893 set_current_state(TASK_INTERRUPTIBLE);
895 if (!test_and_set_bit(0, &fdc_busy))
901 remove_wait_queue(&fdc_wait, &wait);
906 set_current_state(TASK_RUNNING);
907 remove_wait_queue(&fdc_wait, &wait);
909 command_status = FD_COMMAND_NONE;
911 __reschedule_timeout(drive, "lock fdc", 0);
916 #define lock_fdc(drive,interruptible) _lock_fdc(drive,interruptible, __LINE__)
918 #define LOCK_FDC(drive,interruptible) \
919 if (lock_fdc(drive,interruptible)) return -EINTR;
921 /* unlocks the driver */
922 static inline void unlock_fdc(void)
927 if (!test_bit(0, &fdc_busy))
928 DPRINT("FDC access conflict!\n");
931 DPRINT("device interrupt still active at FDC release: %p!\n",
933 command_status = FD_COMMAND_NONE;
934 spin_lock_irqsave(&floppy_lock, flags);
935 del_timer(&fd_timeout);
937 clear_bit(0, &fdc_busy);
938 if (elv_next_request(floppy_queue))
939 do_fd_request(floppy_queue);
940 spin_unlock_irqrestore(&floppy_lock, flags);
941 floppy_release_irq_and_dma();
945 /* switches the motor off after a given timeout */
946 static void motor_off_callback(unsigned long nr)
948 unsigned char mask = ~(0x10 << UNIT(nr));
950 set_dor(FDC(nr), mask, 0);
953 /* schedules motor off */
954 static void floppy_off(unsigned int drive)
956 unsigned long volatile delta;
957 register int fdc = FDC(drive);
959 if (!(FDCS->dor & (0x10 << UNIT(drive))))
962 del_timer(motor_off_timer + drive);
964 /* make spindle stop in a position which minimizes spinup time
967 delta = jiffies - UDRS->first_read_date + HZ -
968 UDP->spindown_offset;
969 delta = ((delta * UDP->rps) % HZ) / UDP->rps;
970 motor_off_timer[drive].expires =
971 jiffies + UDP->spindown - delta;
973 add_timer(motor_off_timer + drive);
977 * cycle through all N_DRIVE floppy drives, for disk change testing.
978 * stopping at current drive. This is done before any long operation, to
979 * be sure to have up to date disk change information.
981 static void scandrives(void)
983 int i, drive, saved_drive;
985 if (DP->select_delay)
988 saved_drive = current_drive;
989 for (i = 0; i < N_DRIVE; i++) {
990 drive = (saved_drive + i + 1) % N_DRIVE;
991 if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
992 continue; /* skip closed drives */
994 if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
995 (0x10 << UNIT(drive))))
996 /* switch the motor off again, if it was off to
998 set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
1000 set_fdc(saved_drive);
1003 static void empty(void)
1007 static DECLARE_WORK(floppy_work, NULL, NULL);
1009 static void schedule_bh(void (*handler) (void))
1011 PREPARE_WORK(&floppy_work, (void (*)(void *))handler, NULL);
1012 schedule_work(&floppy_work);
1015 static DEFINE_TIMER(fd_timer, NULL, 0, 0);
1017 static void cancel_activity(void)
1019 unsigned long flags;
1021 spin_lock_irqsave(&floppy_lock, flags);
1023 PREPARE_WORK(&floppy_work, (void *)empty, NULL);
1024 del_timer(&fd_timer);
1025 spin_unlock_irqrestore(&floppy_lock, flags);
1028 /* this function makes sure that the disk stays in the drive during the
1030 static void fd_watchdog(void)
1033 if (DP->flags & FD_DEBUG) {
1034 DPRINT("calling disk change from watchdog\n");
1038 if (disk_change(current_drive)) {
1039 DPRINT("disk removed during i/o\n");
1044 del_timer(&fd_timer);
1045 fd_timer.function = (timeout_fn) fd_watchdog;
1046 fd_timer.expires = jiffies + HZ / 10;
1047 add_timer(&fd_timer);
1051 static void main_command_interrupt(void)
1053 del_timer(&fd_timer);
1057 /* waits for a delay (spinup or select) to pass */
1058 static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
1061 reset_fdc(); /* do the reset during sleep to win time
1062 * if we don't need to sleep, it's a good
1063 * occasion anyways */
1067 if ((signed)(jiffies - delay) < 0) {
1068 del_timer(&fd_timer);
1069 fd_timer.function = function;
1070 fd_timer.expires = delay;
1071 add_timer(&fd_timer);
1077 static DEFINE_SPINLOCK(floppy_hlt_lock);
1078 static int hlt_disabled;
1079 static void floppy_disable_hlt(void)
1081 unsigned long flags;
1083 spin_lock_irqsave(&floppy_hlt_lock, flags);
1084 if (!hlt_disabled) {
1086 #ifdef HAVE_DISABLE_HLT
1090 spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1093 static void floppy_enable_hlt(void)
1095 unsigned long flags;
1097 spin_lock_irqsave(&floppy_hlt_lock, flags);
1100 #ifdef HAVE_DISABLE_HLT
1104 spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1107 static void setup_DMA(void)
1111 #ifdef FLOPPY_SANITY_CHECK
1112 if (raw_cmd->length == 0) {
1115 printk("zero dma transfer size:");
1116 for (i = 0; i < raw_cmd->cmd_count; i++)
1117 printk("%x,", raw_cmd->cmd[i]);
1123 if (((unsigned long)raw_cmd->kernel_data) % 512) {
1124 printk("non aligned address: %p\n", raw_cmd->kernel_data);
1130 f = claim_dma_lock();
1133 if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1134 (raw_cmd->flags & FD_RAW_READ) ?
1135 DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
1136 release_dma_lock(f);
1141 release_dma_lock(f);
1144 fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1145 fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
1146 DMA_MODE_READ : DMA_MODE_WRITE);
1147 fd_set_dma_addr(raw_cmd->kernel_data);
1148 fd_set_dma_count(raw_cmd->length);
1149 virtual_dma_port = FDCS->address;
1151 release_dma_lock(f);
1153 floppy_disable_hlt();
1156 static void show_floppy(void);
1158 /* waits until the fdc becomes ready */
1159 static int wait_til_ready(void)
1161 int counter, status;
1164 for (counter = 0; counter < 10000; counter++) {
1165 status = fd_inb(FD_STATUS);
1166 if (status & STATUS_READY)
1169 if (!initialising) {
1170 DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
1177 /* sends a command byte to the fdc */
1178 static int output_byte(char byte)
1182 if ((status = wait_til_ready()) < 0)
1184 if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY) {
1185 fd_outb(byte, FD_DATA);
1186 #ifdef FLOPPY_SANITY_CHECK
1187 output_log[output_log_pos].data = byte;
1188 output_log[output_log_pos].status = status;
1189 output_log[output_log_pos].jiffies = jiffies;
1190 output_log_pos = (output_log_pos + 1) % OLOGSIZE;
1195 if (!initialising) {
1196 DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
1203 #define LAST_OUT(x) if (output_byte(x)<0){ reset_fdc();return;}
1205 /* gets the response from the fdc */
1206 static int result(void)
1210 for (i = 0; i < MAX_REPLIES; i++) {
1211 if ((status = wait_til_ready()) < 0)
1213 status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
1214 if ((status & ~STATUS_BUSY) == STATUS_READY) {
1215 #ifdef FLOPPY_SANITY_CHECK
1216 resultjiffies = jiffies;
1221 if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
1222 reply_buffer[i] = fd_inb(FD_DATA);
1226 if (!initialising) {
1228 ("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
1236 #define MORE_OUTPUT -2
1237 /* does the fdc need more output? */
1238 static int need_more_output(void)
1241 if ((status = wait_til_ready()) < 0)
1243 if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY)
1248 /* Set perpendicular mode as required, based on data rate, if supported.
1249 * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
1251 static inline void perpendicular_mode(void)
1253 unsigned char perp_mode;
1255 if (raw_cmd->rate & 0x40) {
1256 switch (raw_cmd->rate & 3) {
1264 DPRINT("Invalid data rate for perpendicular mode!\n");
1266 FDCS->reset = 1; /* convenient way to return to
1267 * redo without to much hassle (deep
1274 if (FDCS->perp_mode == perp_mode)
1276 if (FDCS->version >= FDC_82077_ORIG) {
1277 output_byte(FD_PERPENDICULAR);
1278 output_byte(perp_mode);
1279 FDCS->perp_mode = perp_mode;
1280 } else if (perp_mode) {
1281 DPRINT("perpendicular mode not supported by this FDC.\n");
1283 } /* perpendicular_mode */
1285 static int fifo_depth = 0xa;
1288 static int fdc_configure(void)
1291 output_byte(FD_CONFIGURE);
1292 if (need_more_output() != MORE_OUTPUT)
1295 output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1296 output_byte(0); /* pre-compensation from track
1301 #define NOMINAL_DTR 500
1303 /* Issue a "SPECIFY" command to set the step rate time, head unload time,
1304 * head load time, and DMA disable flag to values needed by floppy.
1306 * The value "dtr" is the data transfer rate in Kbps. It is needed
1307 * to account for the data rate-based scaling done by the 82072 and 82077
1308 * FDC types. This parameter is ignored for other types of FDCs (i.e.
1311 * Note that changing the data transfer rate has a (probably deleterious)
1312 * effect on the parameters subject to scaling for 82072/82077 FDCs, so
1313 * fdc_specify is called again after each data transfer rate
1316 * srt: 1000 to 16000 in microseconds
1317 * hut: 16 to 240 milliseconds
1318 * hlt: 2 to 254 milliseconds
1320 * These values are rounded up to the next highest available delay time.
1322 static void fdc_specify(void)
1324 unsigned char spec1, spec2;
1325 unsigned long srt, hlt, hut;
1326 unsigned long dtr = NOMINAL_DTR;
1327 unsigned long scale_dtr = NOMINAL_DTR;
1328 int hlt_max_code = 0x7f;
1329 int hut_max_code = 0xf;
1331 if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
1333 FDCS->need_configure = 0;
1334 /*DPRINT("FIFO enabled\n"); */
1337 switch (raw_cmd->rate & 0x03) {
1343 if (FDCS->version >= FDC_82078) {
1344 /* chose the default rate table, not the one
1345 * where 1 = 2 Mbps */
1346 output_byte(FD_DRIVESPEC);
1347 if (need_more_output() == MORE_OUTPUT) {
1348 output_byte(UNIT(current_drive));
1358 if (FDCS->version >= FDC_82072) {
1360 hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
1361 hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
1364 /* Convert step rate from microseconds to milliseconds and 4 bits */
1365 srt = 16 - (DP->srt * scale_dtr / 1000 + NOMINAL_DTR - 1) / NOMINAL_DTR;
1372 hlt = (DP->hlt * scale_dtr / 2 + NOMINAL_DTR - 1) / NOMINAL_DTR;
1375 else if (hlt > 0x7f)
1378 hut = (DP->hut * scale_dtr / 16 + NOMINAL_DTR - 1) / NOMINAL_DTR;
1384 spec1 = (srt << 4) | hut;
1385 spec2 = (hlt << 1) | (use_virtual_dma & 1);
1387 /* If these parameters did not change, just return with success */
1388 if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
1389 /* Go ahead and set spec1 and spec2 */
1390 output_byte(FD_SPECIFY);
1391 output_byte(FDCS->spec1 = spec1);
1392 output_byte(FDCS->spec2 = spec2);
1396 /* Set the FDC's data transfer rate on behalf of the specified drive.
1397 * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
1398 * of the specify command (i.e. using the fdc_specify function).
1400 static int fdc_dtr(void)
1402 /* If data rate not already set to desired value, set it. */
1403 if ((raw_cmd->rate & 3) == FDCS->dtr)
1407 fd_outb(raw_cmd->rate & 3, FD_DCR);
1409 /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1410 * need a stabilization period of several milliseconds to be
1411 * enforced after data rate changes before R/W operations.
1412 * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
1414 FDCS->dtr = raw_cmd->rate & 3;
1415 return (fd_wait_for_completion(jiffies + 2UL * HZ / 100,
1416 (timeout_fn) floppy_ready));
1419 static void tell_sector(void)
1421 printk(": track %d, head %d, sector %d, size %d",
1422 R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
1426 * OK, this error interpreting routine is called after a
1427 * DMA read/write has succeeded
1428 * or failed, so we check the results, and copy any buffers.
1429 * hhb: Added better error reporting.
1430 * ak: Made this into a separate routine.
1432 static int interpret_errors(void)
1437 DPRINT("-- FDC reply error");
1442 /* check IC to find cause of interrupt */
1443 switch (ST0 & ST0_INTR) {
1444 case 0x40: /* error occurred during command execution */
1446 return 0; /* occurs with pseudo-DMA */
1449 DPRINT("Drive is write protected\n");
1450 CLEARF(FD_DISK_WRITABLE);
1453 } else if (ST1 & ST1_ND) {
1454 SETF(FD_NEED_TWADDLE);
1455 } else if (ST1 & ST1_OR) {
1456 if (DP->flags & FTD_MSG)
1457 DPRINT("Over/Underrun - retrying\n");
1459 } else if (*errors >= DP->max_errors.reporting) {
1461 if (ST0 & ST0_ECE) {
1462 printk("Recalibrate failed!");
1463 } else if (ST2 & ST2_CRC) {
1464 printk("data CRC error");
1466 } else if (ST1 & ST1_CRC) {
1467 printk("CRC error");
1469 } else if ((ST1 & (ST1_MAM | ST1_ND))
1470 || (ST2 & ST2_MAM)) {
1472 printk("sector not found");
1475 printk("probe failed...");
1476 } else if (ST2 & ST2_WC) { /* seek error */
1477 printk("wrong cylinder");
1478 } else if (ST2 & ST2_BC) { /* cylinder marked as bad */
1479 printk("bad cylinder");
1482 ("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
1489 if (ST2 & ST2_WC || ST2 & ST2_BC)
1490 /* wrong cylinder => recal */
1491 DRS->track = NEED_2_RECAL;
1493 case 0x80: /* invalid command given */
1494 DPRINT("Invalid FDC command given!\n");
1498 DPRINT("Abnormal termination caused by polling\n");
1501 default: /* (0) Normal command termination */
1507 * This routine is called when everything should be correctly set up
1508 * for the transfer (i.e. floppy motor is on, the correct floppy is
1509 * selected, and the head is sitting on the right track).
1511 static void setup_rw_floppy(void)
1513 int i, r, flags, dflags;
1514 unsigned long ready_date;
1515 timeout_fn function;
1517 flags = raw_cmd->flags;
1518 if (flags & (FD_RAW_READ | FD_RAW_WRITE))
1519 flags |= FD_RAW_INTR;
1521 if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
1522 ready_date = DRS->spinup_date + DP->spinup;
1523 /* If spinup will take a long time, rerun scandrives
1524 * again just before spinup completion. Beware that
1525 * after scandrives, we must again wait for selection.
1527 if ((signed)(ready_date - jiffies) > DP->select_delay) {
1528 ready_date -= DP->select_delay;
1529 function = (timeout_fn) floppy_start;
1531 function = (timeout_fn) setup_rw_floppy;
1533 /* wait until the floppy is spinning fast enough */
1534 if (fd_wait_for_completion(ready_date, function))
1537 dflags = DRS->flags;
1539 if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
1542 if (flags & FD_RAW_INTR)
1543 do_floppy = main_command_interrupt;
1546 for (i = 0; i < raw_cmd->cmd_count; i++)
1547 r |= output_byte(raw_cmd->cmd[i]);
1549 debugt("rw_command: ");
1557 if (!(flags & FD_RAW_INTR)) {
1560 } else if (flags & FD_RAW_NEED_DISK)
1564 static int blind_seek;
1567 * This is the routine called after every seek (or recalibrate) interrupt
1568 * from the floppy controller.
1570 static void seek_interrupt(void)
1572 debugt("seek interrupt:");
1573 if (inr != 2 || (ST0 & 0xF8) != 0x20) {
1574 DPRINT("seek failed\n");
1575 DRS->track = NEED_2_RECAL;
1580 if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
1582 if (DP->flags & FD_DEBUG) {
1584 ("clearing NEWCHANGE flag because of effective seek\n");
1585 DPRINT("jiffies=%lu\n", jiffies);
1588 CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
1589 DRS->select_date = jiffies;
1595 static void check_wp(void)
1597 if (TESTF(FD_VERIFY)) {
1598 /* check write protection */
1599 output_byte(FD_GETSTATUS);
1600 output_byte(UNIT(current_drive));
1601 if (result() != 1) {
1606 CLEARF(FD_NEED_TWADDLE);
1608 if (DP->flags & FD_DEBUG) {
1609 DPRINT("checking whether disk is write protected\n");
1610 DPRINT("wp=%x\n", ST3 & 0x40);
1614 SETF(FD_DISK_WRITABLE);
1616 CLEARF(FD_DISK_WRITABLE);
1620 static void seek_floppy(void)
1627 if (DP->flags & FD_DEBUG) {
1628 DPRINT("calling disk change from seek\n");
1632 if (!TESTF(FD_DISK_NEWCHANGE) &&
1633 disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1634 /* the media changed flag should be cleared after the seek.
1635 * If it isn't, this means that there is really no disk in
1638 SETF(FD_DISK_CHANGED);
1643 if (DRS->track <= NEED_1_RECAL) {
1644 recalibrate_floppy();
1646 } else if (TESTF(FD_DISK_NEWCHANGE) &&
1647 (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1648 (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
1649 /* we seek to clear the media-changed condition. Does anybody
1650 * know a more elegant way, which works on all drives? */
1652 track = raw_cmd->track - 1;
1654 if (DP->flags & FD_SILENT_DCL_CLEAR) {
1655 set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
1657 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1663 if (raw_cmd->track != DRS->track &&
1664 (raw_cmd->flags & FD_RAW_NEED_SEEK))
1665 track = raw_cmd->track;
1672 do_floppy = seek_interrupt;
1673 output_byte(FD_SEEK);
1674 output_byte(UNIT(current_drive));
1676 debugt("seek command:");
1679 static void recal_interrupt(void)
1681 debugt("recal interrupt:");
1684 else if (ST0 & ST0_ECE) {
1685 switch (DRS->track) {
1687 debugt("recal interrupt need 1 recal:");
1688 /* after a second recalibrate, we still haven't
1689 * reached track 0. Probably no drive. Raise an
1690 * error, as failing immediately might upset
1691 * computers possessed by the Devil :-) */
1696 debugt("recal interrupt need 2 recal:");
1697 /* If we already did a recalibrate,
1698 * and we are not at track 0, this
1699 * means we have moved. (The only way
1700 * not to move at recalibration is to
1701 * be already at track 0.) Clear the
1702 * new change flag */
1704 if (DP->flags & FD_DEBUG) {
1706 ("clearing NEWCHANGE flag because of second recalibrate\n");
1710 CLEARF(FD_DISK_NEWCHANGE);
1711 DRS->select_date = jiffies;
1714 debugt("recal interrupt default:");
1715 /* Recalibrate moves the head by at
1716 * most 80 steps. If after one
1717 * recalibrate we don't have reached
1718 * track 0, this might mean that we
1719 * started beyond track 80. Try
1721 DRS->track = NEED_1_RECAL;
1729 static void print_result(char *message, int inr)
1733 DPRINT("%s ", message);
1735 for (i = 0; i < inr; i++)
1736 printk("repl[%d]=%x ", i, reply_buffer[i]);
1740 /* interrupt handler. Note that this can be called externally on the Sparc */
1741 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1743 void (*handler) (void) = do_floppy;
1747 lasthandler = handler;
1748 interruptjiffies = jiffies;
1750 f = claim_dma_lock();
1752 release_dma_lock(f);
1754 floppy_enable_hlt();
1756 if (fdc >= N_FDC || FDCS->address == -1) {
1757 /* we don't even know which FDC is the culprit */
1758 printk("DOR0=%x\n", fdc_state[0].dor);
1759 printk("floppy interrupt on bizarre fdc %d\n", fdc);
1760 printk("handler=%p\n", handler);
1761 is_alive("bizarre fdc");
1766 /* We have to clear the reset flag here, because apparently on boxes
1767 * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
1768 * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
1769 * emission of the SENSEI's.
1770 * It is OK to emit floppy commands because we are in an interrupt
1771 * handler here, and thus we have to fear no interference of other
1775 do_print = !handler && print_unex && !initialising;
1779 print_result("unexpected interrupt", inr);
1783 output_byte(FD_SENSEI);
1786 print_result("sensei", inr);
1788 } while ((ST0 & 0x83) != UNIT(current_drive) && inr == 2
1795 schedule_bh(handler);
1796 is_alive("normal interrupt end");
1798 /* FIXME! Was it really for us? */
1802 static void recalibrate_floppy(void)
1804 debugt("recalibrate floppy:");
1805 do_floppy = recal_interrupt;
1806 output_byte(FD_RECALIBRATE);
1807 LAST_OUT(UNIT(current_drive));
1811 * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1813 static void reset_interrupt(void)
1815 debugt("reset interrupt:");
1816 result(); /* get the status ready for set_fdc */
1818 printk("reset set in interrupt, calling %p\n", cont->error);
1819 cont->error(); /* a reset just after a reset. BAD! */
1825 * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1826 * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1828 static void reset_fdc(void)
1830 unsigned long flags;
1832 do_floppy = reset_interrupt;
1836 /* Pseudo-DMA may intercept 'reset finished' interrupt. */
1837 /* Irrelevant for systems with true DMA (i386). */
1839 flags = claim_dma_lock();
1841 release_dma_lock(flags);
1843 if (FDCS->version >= FDC_82072A)
1844 fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
1846 fd_outb(FDCS->dor & ~0x04, FD_DOR);
1847 udelay(FD_RESET_DELAY);
1848 fd_outb(FDCS->dor, FD_DOR);
1852 static void show_floppy(void)
1857 printk("floppy driver state\n");
1858 printk("-------------------\n");
1859 printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",
1860 jiffies, interruptjiffies, jiffies - interruptjiffies,
1863 #ifdef FLOPPY_SANITY_CHECK
1864 printk("timeout_message=%s\n", timeout_message);
1865 printk("last output bytes:\n");
1866 for (i = 0; i < OLOGSIZE; i++)
1867 printk("%2x %2x %lu\n",
1868 output_log[(i + output_log_pos) % OLOGSIZE].data,
1869 output_log[(i + output_log_pos) % OLOGSIZE].status,
1870 output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1871 printk("last result at %lu\n", resultjiffies);
1872 printk("last redo_fd_request at %lu\n", lastredo);
1873 for (i = 0; i < resultsize; i++) {
1874 printk("%2x ", reply_buffer[i]);
1879 printk("status=%x\n", fd_inb(FD_STATUS));
1880 printk("fdc_busy=%lu\n", fdc_busy);
1882 printk("do_floppy=%p\n", do_floppy);
1883 if (floppy_work.pending)
1884 printk("floppy_work.func=%p\n", floppy_work.func);
1885 if (timer_pending(&fd_timer))
1886 printk("fd_timer.function=%p\n", fd_timer.function);
1887 if (timer_pending(&fd_timeout)) {
1888 printk("timer_function=%p\n", fd_timeout.function);
1889 printk("expires=%lu\n", fd_timeout.expires - jiffies);
1890 printk("now=%lu\n", jiffies);
1892 printk("cont=%p\n", cont);
1893 printk("current_req=%p\n", current_req);
1894 printk("command_status=%d\n", command_status);
1898 static void floppy_shutdown(unsigned long data)
1900 unsigned long flags;
1906 floppy_enable_hlt();
1908 flags = claim_dma_lock();
1910 release_dma_lock(flags);
1912 /* avoid dma going to a random drive after shutdown */
1915 DPRINT("floppy timeout called\n");
1919 cont->redo(); /* this will recall reset when needed */
1921 printk("no cont in shutdown!\n");
1922 process_fd_request();
1924 is_alive("floppy shutdown");
1927 /*typedef void (*timeout_fn)(unsigned long);*/
1929 /* start motor, check media-changed condition and write protection */
1930 static int start_motor(void (*function) (void))
1935 data = UNIT(current_drive);
1936 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1937 if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
1939 /* no read since this drive is running */
1940 DRS->first_read_date = 0;
1941 /* note motor start time if motor is not yet running */
1942 DRS->spinup_date = jiffies;
1943 data |= (0x10 << UNIT(current_drive));
1945 } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
1946 mask &= ~(0x10 << UNIT(current_drive));
1948 /* starts motor and selects floppy */
1949 del_timer(motor_off_timer + current_drive);
1950 set_dor(fdc, mask, data);
1952 /* wait_for_completion also schedules reset if needed. */
1953 return (fd_wait_for_completion(DRS->select_date + DP->select_delay,
1954 (timeout_fn) function));
1957 static void floppy_ready(void)
1960 if (start_motor(floppy_ready))
1966 if (DP->flags & FD_DEBUG) {
1967 DPRINT("calling disk change from floppy_ready\n");
1970 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1971 disk_change(current_drive) && !DP->select_delay)
1972 twaddle(); /* this clears the dcl on certain drive/controller
1975 #ifdef fd_chose_dma_mode
1976 if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1977 unsigned long flags = claim_dma_lock();
1978 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1979 release_dma_lock(flags);
1983 if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1984 perpendicular_mode();
1985 fdc_specify(); /* must be done here because of hut, hlt ... */
1988 if ((raw_cmd->flags & FD_RAW_READ) ||
1989 (raw_cmd->flags & FD_RAW_WRITE))
1995 static void floppy_start(void)
1997 reschedule_timeout(current_reqD, "floppy start", 0);
2001 if (DP->flags & FD_DEBUG) {
2002 DPRINT("setting NEWCHANGE in floppy_start\n");
2005 SETF(FD_DISK_NEWCHANGE);
2010 * ========================================================================
2011 * here ends the bottom half. Exported routines are:
2012 * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
2013 * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
2014 * Initialization also uses output_byte, result, set_dor, floppy_interrupt
2016 * ========================================================================
2019 * General purpose continuations.
2020 * ==============================
2023 static void do_wakeup(void)
2025 reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
2027 command_status += 2;
2028 wake_up(&command_done);
2031 static struct cont_t wakeup_cont = {
2035 .done = (done_f) empty
2038 static struct cont_t intr_cont = {
2040 .redo = process_fd_request,
2042 .done = (done_f) empty
2045 static int wait_til_done(void (*handler) (void), int interruptible)
2049 schedule_bh(handler);
2051 if (command_status < 2 && NO_SIGNAL) {
2052 DECLARE_WAITQUEUE(wait, current);
2054 add_wait_queue(&command_done, &wait);
2056 set_current_state(interruptible ?
2057 TASK_INTERRUPTIBLE :
2058 TASK_UNINTERRUPTIBLE);
2060 if (command_status >= 2 || !NO_SIGNAL)
2063 is_alive("wait_til_done");
2068 set_current_state(TASK_RUNNING);
2069 remove_wait_queue(&command_done, &wait);
2072 if (command_status < 2) {
2080 command_status = FD_COMMAND_ERROR;
2081 if (command_status == FD_COMMAND_OKAY)
2085 command_status = FD_COMMAND_NONE;
2089 static void generic_done(int result)
2091 command_status = result;
2092 cont = &wakeup_cont;
2095 static void generic_success(void)
2100 static void generic_failure(void)
2105 static void success_and_wakeup(void)
2112 * formatting and rw support.
2113 * ==========================
2116 static int next_valid_format(void)
2120 probed_format = DRS->probed_format;
2122 if (probed_format >= 8 || !DP->autodetect[probed_format]) {
2123 DRS->probed_format = 0;
2126 if (floppy_type[DP->autodetect[probed_format]].sect) {
2127 DRS->probed_format = probed_format;
2134 static void bad_flp_intr(void)
2139 DRS->probed_format++;
2140 if (!next_valid_format())
2143 err_count = ++(*errors);
2144 INFBOUND(DRWE->badness, err_count);
2145 if (err_count > DP->max_errors.abort)
2147 if (err_count > DP->max_errors.reset)
2149 else if (err_count > DP->max_errors.recal)
2150 DRS->track = NEED_2_RECAL;
2153 static void set_floppy(int drive)
2155 int type = ITYPE(UDRS->fd_device);
2157 _floppy = floppy_type + type;
2159 _floppy = current_type[drive];
2163 * formatting support.
2164 * ===================
2166 static void format_interrupt(void)
2168 switch (interpret_errors()) {
2179 #define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
2180 #define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80) >>1))
2181 #define CT(x) ((x) | 0xc0)
2182 static void setup_format_params(int track)
2185 unsigned char track, head, sect, size;
2186 } *here = (struct fparm *)floppy_track_buffer;
2188 int count, head_shift, track_shift;
2190 raw_cmd = &default_raw_cmd;
2191 raw_cmd->track = track;
2193 raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2194 FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2195 raw_cmd->rate = _floppy->rate & 0x43;
2196 raw_cmd->cmd_count = NR_F;
2197 COMMAND = FM_MODE(_floppy, FD_FORMAT);
2198 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2199 F_SIZECODE = FD_SIZECODE(_floppy);
2200 F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2201 F_GAP = _floppy->fmt_gap;
2202 F_FILL = FD_FILL_BYTE;
2204 raw_cmd->kernel_data = floppy_track_buffer;
2205 raw_cmd->length = 4 * F_SECT_PER_TRACK;
2207 /* allow for about 30ms for data transport per track */
2208 head_shift = (F_SECT_PER_TRACK + 5) / 6;
2210 /* a ``cylinder'' is two tracks plus a little stepping time */
2211 track_shift = 2 * head_shift + 3;
2213 /* position of logical sector 1 on this track */
2214 n = (track_shift * format_req.track + head_shift * format_req.head)
2217 /* determine interleave */
2219 if (_floppy->fmt_gap < 0x22)
2222 /* initialize field */
2223 for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2224 here[count].track = format_req.track;
2225 here[count].head = format_req.head;
2226 here[count].sect = 0;
2227 here[count].size = F_SIZECODE;
2229 /* place logical sectors */
2230 for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2231 here[n].sect = count;
2232 n = (n + il) % F_SECT_PER_TRACK;
2233 if (here[n].sect) { /* sector busy, find next free sector */
2235 if (n >= F_SECT_PER_TRACK) {
2236 n -= F_SECT_PER_TRACK;
2237 while (here[n].sect)
2242 if (_floppy->stretch & FD_ZEROBASED) {
2243 for (count = 0; count < F_SECT_PER_TRACK; count++)
2248 static void redo_format(void)
2251 setup_format_params(format_req.track << STRETCH(_floppy));
2253 debugt("queue format request");
2256 static struct cont_t format_cont = {
2257 .interrupt = format_interrupt,
2258 .redo = redo_format,
2259 .error = bad_flp_intr,
2260 .done = generic_done
2263 static int do_format(int drive, struct format_descr *tmp_format_req)
2270 _floppy->track > DP->tracks ||
2271 tmp_format_req->track >= _floppy->track ||
2272 tmp_format_req->head >= _floppy->head ||
2273 (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2274 !_floppy->fmt_gap) {
2275 process_fd_request();
2278 format_req = *tmp_format_req;
2280 cont = &format_cont;
2281 errors = &format_errors;
2283 process_fd_request();
2288 * Buffer read/write and support
2289 * =============================
2292 static void floppy_end_request(struct request *req, int uptodate)
2294 unsigned int nr_sectors = current_count_sectors;
2296 /* current_count_sectors can be zero if transfer failed */
2298 nr_sectors = req->current_nr_sectors;
2299 if (end_that_request_first(req, uptodate, nr_sectors))
2301 add_disk_randomness(req->rq_disk);
2302 floppy_off((long)req->rq_disk->private_data);
2303 blkdev_dequeue_request(req);
2304 end_that_request_last(req, uptodate);
2306 /* We're done with the request */
2310 /* new request_done. Can handle physical sectors which are smaller than a
2312 static void request_done(int uptodate)
2314 struct request_queue *q = floppy_queue;
2315 struct request *req = current_req;
2316 unsigned long flags;
2320 reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
2323 printk("floppy.c: no request in request_done\n");
2328 /* maintain values for invalidation on geometry
2330 block = current_count_sectors + req->sector;
2331 INFBOUND(DRS->maxblock, block);
2332 if (block > _floppy->sect)
2335 /* unlock chained buffers */
2336 spin_lock_irqsave(q->queue_lock, flags);
2337 floppy_end_request(req, 1);
2338 spin_unlock_irqrestore(q->queue_lock, flags);
2340 if (rq_data_dir(req) == WRITE) {
2341 /* record write error information */
2342 DRWE->write_errors++;
2343 if (DRWE->write_errors == 1) {
2344 DRWE->first_error_sector = req->sector;
2345 DRWE->first_error_generation = DRS->generation;
2347 DRWE->last_error_sector = req->sector;
2348 DRWE->last_error_generation = DRS->generation;
2350 spin_lock_irqsave(q->queue_lock, flags);
2351 floppy_end_request(req, 0);
2352 spin_unlock_irqrestore(q->queue_lock, flags);
2356 /* Interrupt handler evaluating the result of the r/w operation */
2357 static void rw_interrupt(void)
2359 int nr_sectors, ssize, eoc, heads;
2362 /* some Toshiba floppy controllers occasionnally seem to
2363 * return bogus interrupts after read/write operations, which
2364 * can be recognized by a bad head number (>= 2) */
2368 if (!DRS->first_read_date)
2369 DRS->first_read_date = jiffies;
2384 nr_sectors = (((R_TRACK - TRACK) * heads +
2385 R_HEAD - HEAD) * SECT_PER_TRACK +
2386 R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2388 #ifdef FLOPPY_SANITY_CHECK
2389 if (nr_sectors / ssize >
2390 (in_sector_offset + current_count_sectors + ssize - 1) / ssize) {
2391 DPRINT("long rw: %x instead of %lx\n",
2392 nr_sectors, current_count_sectors);
2393 printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
2394 printk("rh=%d h=%d\n", R_HEAD, HEAD);
2395 printk("rt=%d t=%d\n", R_TRACK, TRACK);
2396 printk("heads=%d eoc=%d\n", heads, eoc);
2397 printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
2399 printk("in_sector_offset=%d\n", in_sector_offset);
2403 nr_sectors -= in_sector_offset;
2404 INFBOUND(nr_sectors, 0);
2405 SUPBOUND(current_count_sectors, nr_sectors);
2407 switch (interpret_errors()) {
2412 if (!current_count_sectors) {
2419 if (!current_count_sectors) {
2423 current_type[current_drive] = _floppy;
2424 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2429 if (DP->flags & FTD_MSG)
2430 DPRINT("Auto-detected floppy type %s in fd%d\n",
2431 _floppy->name, current_drive);
2432 current_type[current_drive] = _floppy;
2433 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2437 if (CT(COMMAND) != FD_READ ||
2438 raw_cmd->kernel_data == current_req->buffer) {
2439 /* transfer directly from buffer */
2441 } else if (CT(COMMAND) == FD_READ) {
2442 buffer_track = raw_cmd->track;
2443 buffer_drive = current_drive;
2444 INFBOUND(buffer_max, nr_sectors + fsector_t);
2449 /* Compute maximal contiguous buffer size. */
2450 static int buffer_chain_size(void)
2457 base = bio_data(current_req->bio);
2460 rq_for_each_bio(bio, current_req) {
2461 bio_for_each_segment(bv, bio, i) {
2462 if (page_address(bv->bv_page) + bv->bv_offset !=
2473 /* Compute the maximal transfer size */
2474 static int transfer_size(int ssize, int max_sector, int max_size)
2476 SUPBOUND(max_sector, fsector_t + max_size);
2479 max_sector -= (max_sector % _floppy->sect) % ssize;
2481 /* transfer size, beginning not aligned */
2482 current_count_sectors = max_sector - fsector_t;
2488 * Move data from/to the track buffer to/from the buffer cache.
2490 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2492 int remaining; /* number of transferred 512-byte sectors */
2495 char *buffer, *dma_buffer;
2498 max_sector = transfer_size(ssize,
2499 min(max_sector, max_sector_2),
2500 current_req->nr_sectors);
2502 if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2503 buffer_max > fsector_t + current_req->nr_sectors)
2504 current_count_sectors = min_t(int, buffer_max - fsector_t,
2505 current_req->nr_sectors);
2507 remaining = current_count_sectors << 9;
2508 #ifdef FLOPPY_SANITY_CHECK
2509 if ((remaining >> 9) > current_req->nr_sectors &&
2510 CT(COMMAND) == FD_WRITE) {
2511 DPRINT("in copy buffer\n");
2512 printk("current_count_sectors=%ld\n", current_count_sectors);
2513 printk("remaining=%d\n", remaining >> 9);
2514 printk("current_req->nr_sectors=%ld\n",
2515 current_req->nr_sectors);
2516 printk("current_req->current_nr_sectors=%u\n",
2517 current_req->current_nr_sectors);
2518 printk("max_sector=%d\n", max_sector);
2519 printk("ssize=%d\n", ssize);
2523 buffer_max = max(max_sector, buffer_max);
2525 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2527 size = current_req->current_nr_sectors << 9;
2529 rq_for_each_bio(bio, current_req) {
2530 bio_for_each_segment(bv, bio, i) {
2535 SUPBOUND(size, remaining);
2537 buffer = page_address(bv->bv_page) + bv->bv_offset;
2538 #ifdef FLOPPY_SANITY_CHECK
2539 if (dma_buffer + size >
2540 floppy_track_buffer + (max_buffer_sectors << 10) ||
2541 dma_buffer < floppy_track_buffer) {
2542 DPRINT("buffer overrun in copy buffer %d\n",
2543 (int)((floppy_track_buffer -
2545 printk("fsector_t=%d buffer_min=%d\n",
2546 fsector_t, buffer_min);
2547 printk("current_count_sectors=%ld\n",
2548 current_count_sectors);
2549 if (CT(COMMAND) == FD_READ)
2551 if (CT(COMMAND) == FD_WRITE)
2555 if (((unsigned long)buffer) % 512)
2556 DPRINT("%p buffer not aligned\n", buffer);
2558 if (CT(COMMAND) == FD_READ)
2559 memcpy(buffer, dma_buffer, size);
2561 memcpy(dma_buffer, buffer, size);
2567 #ifdef FLOPPY_SANITY_CHECK
2570 max_sector -= remaining >> 9;
2571 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2577 static inline int check_dma_crossing(char *start,
2578 unsigned long length, char *message)
2580 if (CROSS_64KB(start, length)) {
2581 printk("DMA xfer crosses 64KB boundary in %s %p-%p\n",
2582 message, start, start + length);
2589 /* work around a bug in pseudo DMA
2590 * (on some FDCs) pseudo DMA does not stop when the CPU stops
2591 * sending data. Hence we need a different way to signal the
2592 * transfer length: We use SECT_PER_TRACK. Unfortunately, this
2593 * does not work with MT, hence we can only transfer one head at
2596 static void virtualdmabug_workaround(void)
2598 int hard_sectors, end_sector;
2600 if (CT(COMMAND) == FD_WRITE) {
2601 COMMAND &= ~0x80; /* switch off multiple track mode */
2603 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2604 end_sector = SECTOR + hard_sectors - 1;
2605 #ifdef FLOPPY_SANITY_CHECK
2606 if (end_sector > SECT_PER_TRACK) {
2607 printk("too many sectors %d > %d\n",
2608 end_sector, SECT_PER_TRACK);
2612 SECT_PER_TRACK = end_sector; /* make sure SECT_PER_TRACK points
2613 * to end of transfer */
2618 * Formulate a read/write request.
2619 * this routine decides where to load the data (directly to buffer, or to
2620 * tmp floppy area), how much data to load (the size of the buffer, the whole
2621 * track, or a single sector)
2622 * All floppy_track_buffer handling goes in here. If we ever add track buffer
2623 * allocation on the fly, it should be done here. No other part should need
2627 static int make_raw_rw_request(void)
2629 int aligned_sector_t;
2630 int max_sector, max_size, tracksize, ssize;
2632 if (max_buffer_sectors == 0) {
2633 printk("VFS: Block I/O scheduled on unopened device\n");
2637 set_fdc((long)current_req->rq_disk->private_data);
2639 raw_cmd = &default_raw_cmd;
2640 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2642 raw_cmd->cmd_count = NR_RW;
2643 if (rq_data_dir(current_req) == READ) {
2644 raw_cmd->flags |= FD_RAW_READ;
2645 COMMAND = FM_MODE(_floppy, FD_READ);
2646 } else if (rq_data_dir(current_req) == WRITE) {
2647 raw_cmd->flags |= FD_RAW_WRITE;
2648 COMMAND = FM_MODE(_floppy, FD_WRITE);
2650 DPRINT("make_raw_rw_request: unknown command\n");
2654 max_sector = _floppy->sect * _floppy->head;
2656 TRACK = (int)current_req->sector / max_sector;
2657 fsector_t = (int)current_req->sector % max_sector;
2658 if (_floppy->track && TRACK >= _floppy->track) {
2659 if (current_req->current_nr_sectors & 1) {
2660 current_count_sectors = 1;
2665 HEAD = fsector_t / _floppy->sect;
2667 if (((_floppy->stretch & (FD_SWAPSIDES | FD_ZEROBASED)) ||
2668 TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
2669 max_sector = _floppy->sect;
2671 /* 2M disks have phantom sectors on the first track */
2672 if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2673 max_sector = 2 * _floppy->sect / 3;
2674 if (fsector_t >= max_sector) {
2675 current_count_sectors =
2676 min_t(int, _floppy->sect - fsector_t,
2677 current_req->nr_sectors);
2682 SIZECODE = FD_SIZECODE(_floppy);
2683 raw_cmd->rate = _floppy->rate & 0x43;
2684 if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2691 raw_cmd->track = TRACK << STRETCH(_floppy);
2692 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2695 SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2696 SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
2697 ((_floppy->stretch & FD_ZEROBASED) ? 0 : 1);
2699 /* tracksize describes the size which can be filled up with sectors
2702 tracksize = _floppy->sect - _floppy->sect % ssize;
2703 if (tracksize < _floppy->sect) {
2705 if (tracksize <= fsector_t % _floppy->sect)
2708 /* if we are beyond tracksize, fill up using smaller sectors */
2709 while (tracksize <= fsector_t % _floppy->sect) {
2710 while (tracksize + ssize > _floppy->sect) {
2718 max_sector = HEAD * _floppy->sect + tracksize;
2719 } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2720 max_sector = _floppy->sect;
2721 } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2722 /* for virtual DMA bug workaround */
2723 max_sector = _floppy->sect;
2726 in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2727 aligned_sector_t = fsector_t - in_sector_offset;
2728 max_size = current_req->nr_sectors;
2729 if ((raw_cmd->track == buffer_track) &&
2730 (current_drive == buffer_drive) &&
2731 (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2732 /* data already in track buffer */
2733 if (CT(COMMAND) == FD_READ) {
2734 copy_buffer(1, max_sector, buffer_max);
2737 } else if (in_sector_offset || current_req->nr_sectors < ssize) {
2738 if (CT(COMMAND) == FD_WRITE) {
2739 if (fsector_t + current_req->nr_sectors > ssize &&
2740 fsector_t + current_req->nr_sectors < ssize + ssize)
2741 max_size = ssize + ssize;
2745 raw_cmd->flags &= ~FD_RAW_WRITE;
2746 raw_cmd->flags |= FD_RAW_READ;
2747 COMMAND = FM_MODE(_floppy, FD_READ);
2748 } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2749 unsigned long dma_limit;
2750 int direct, indirect;
2753 transfer_size(ssize, max_sector,
2754 max_buffer_sectors * 2) - fsector_t;
2757 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2758 * on a 64 bit machine!
2760 max_size = buffer_chain_size();
2763 ((unsigned long)current_req->buffer)) >> 9;
2764 if ((unsigned long)max_size > dma_limit) {
2765 max_size = dma_limit;
2767 /* 64 kb boundaries */
2768 if (CROSS_64KB(current_req->buffer, max_size << 9))
2770 ((unsigned long)current_req->buffer) %
2772 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2774 * We try to read tracks, but if we get too many errors, we
2775 * go back to reading just one sector at a time.
2777 * This means we should be able to read a sector even if there
2778 * are other bad sectors on this track.
2781 (indirect * 2 > direct * 3 &&
2782 *errors < DP->max_errors.read_track &&
2783 /*!TESTF(FD_NEED_TWADDLE) && */
2785 || (DP->read_track & (1 << DRS->probed_format)))))) {
2786 max_size = current_req->nr_sectors;
2788 raw_cmd->kernel_data = current_req->buffer;
2789 raw_cmd->length = current_count_sectors << 9;
2790 if (raw_cmd->length == 0) {
2792 ("zero dma transfer attempted from make_raw_request\n");
2793 DPRINT("indirect=%d direct=%d fsector_t=%d",
2794 indirect, direct, fsector_t);
2797 /* check_dma_crossing(raw_cmd->kernel_data,
2799 "end of make_raw_request [1]");*/
2801 virtualdmabug_workaround();
2806 if (CT(COMMAND) == FD_READ)
2807 max_size = max_sector; /* unbounded */
2809 /* claim buffer track if needed */
2810 if (buffer_track != raw_cmd->track || /* bad track */
2811 buffer_drive != current_drive || /* bad drive */
2812 fsector_t > buffer_max ||
2813 fsector_t < buffer_min ||
2814 ((CT(COMMAND) == FD_READ ||
2815 (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
2816 max_sector > 2 * max_buffer_sectors + buffer_min &&
2817 max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
2818 /* not enough space */
2821 buffer_drive = current_drive;
2822 buffer_max = buffer_min = aligned_sector_t;
2824 raw_cmd->kernel_data = floppy_track_buffer +
2825 ((aligned_sector_t - buffer_min) << 9);
2827 if (CT(COMMAND) == FD_WRITE) {
2828 /* copy write buffer to track buffer.
2829 * if we get here, we know that the write
2830 * is either aligned or the data already in the buffer
2831 * (buffer will be overwritten) */
2832 #ifdef FLOPPY_SANITY_CHECK
2833 if (in_sector_offset && buffer_track == -1)
2834 DPRINT("internal error offset !=0 on write\n");
2836 buffer_track = raw_cmd->track;
2837 buffer_drive = current_drive;
2838 copy_buffer(ssize, max_sector,
2839 2 * max_buffer_sectors + buffer_min);
2841 transfer_size(ssize, max_sector,
2842 2 * max_buffer_sectors + buffer_min -
2845 /* round up current_count_sectors to get dma xfer size */
2846 raw_cmd->length = in_sector_offset + current_count_sectors;
2847 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2848 raw_cmd->length <<= 9;
2849 #ifdef FLOPPY_SANITY_CHECK
2850 /*check_dma_crossing(raw_cmd->kernel_data, raw_cmd->length,
2851 "end of make_raw_request"); */
2852 if ((raw_cmd->length < current_count_sectors << 9) ||
2853 (raw_cmd->kernel_data != current_req->buffer &&
2854 CT(COMMAND) == FD_WRITE &&
2855 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2856 aligned_sector_t < buffer_min)) ||
2857 raw_cmd->length % (128 << SIZECODE) ||
2858 raw_cmd->length <= 0 || current_count_sectors <= 0) {
2859 DPRINT("fractionary current count b=%lx s=%lx\n",
2860 raw_cmd->length, current_count_sectors);
2861 if (raw_cmd->kernel_data != current_req->buffer)
2862 printk("addr=%d, length=%ld\n",
2863 (int)((raw_cmd->kernel_data -
2864 floppy_track_buffer) >> 9),
2865 current_count_sectors);
2866 printk("st=%d ast=%d mse=%d msi=%d\n",
2867 fsector_t, aligned_sector_t, max_sector, max_size);
2868 printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2869 printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2870 COMMAND, SECTOR, HEAD, TRACK);
2871 printk("buffer drive=%d\n", buffer_drive);
2872 printk("buffer track=%d\n", buffer_track);
2873 printk("buffer_min=%d\n", buffer_min);
2874 printk("buffer_max=%d\n", buffer_max);
2878 if (raw_cmd->kernel_data != current_req->buffer) {
2879 if (raw_cmd->kernel_data < floppy_track_buffer ||
2880 current_count_sectors < 0 ||
2881 raw_cmd->length < 0 ||
2882 raw_cmd->kernel_data + raw_cmd->length >
2883 floppy_track_buffer + (max_buffer_sectors << 10)) {
2884 DPRINT("buffer overrun in schedule dma\n");
2885 printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
2886 fsector_t, buffer_min, raw_cmd->length >> 9);
2887 printk("current_count_sectors=%ld\n",
2888 current_count_sectors);
2889 if (CT(COMMAND) == FD_READ)
2891 if (CT(COMMAND) == FD_WRITE)
2895 } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
2896 current_count_sectors > current_req->nr_sectors) {
2897 DPRINT("buffer overrun in direct transfer\n");
2899 } else if (raw_cmd->length < current_count_sectors << 9) {
2900 DPRINT("more sectors than bytes\n");
2901 printk("bytes=%ld\n", raw_cmd->length >> 9);
2902 printk("sectors=%ld\n", current_count_sectors);
2904 if (raw_cmd->length == 0) {
2905 DPRINT("zero dma transfer attempted from make_raw_request\n");
2910 virtualdmabug_workaround();
2914 static void redo_fd_request(void)
2916 #define REPEAT {request_done(0); continue; }
2921 if (current_drive < N_DRIVE)
2922 floppy_off(current_drive);
2926 struct request *req;
2928 spin_lock_irq(floppy_queue->queue_lock);
2929 req = elv_next_request(floppy_queue);
2930 spin_unlock_irq(floppy_queue->queue_lock);
2938 drive = (long)current_req->rq_disk->private_data;
2940 reschedule_timeout(current_reqD, "redo fd request", 0);
2943 raw_cmd = &default_raw_cmd;
2945 if (start_motor(redo_fd_request))
2947 disk_change(current_drive);
2948 if (test_bit(current_drive, &fake_change) ||
2949 TESTF(FD_DISK_CHANGED)) {
2950 DPRINT("disk absent or changed during operation\n");
2953 if (!_floppy) { /* Autodetection */
2955 DRS->probed_format = 0;
2956 if (next_valid_format()) {
2957 DPRINT("no autodetectable formats\n");
2964 floppy_type + DP->autodetect[DRS->probed_format];
2967 errors = &(current_req->errors);
2968 tmp = make_raw_rw_request();
2974 if (TESTF(FD_NEED_TWADDLE))
2976 schedule_bh(floppy_start);
2977 debugt("queue fd request");
2983 static struct cont_t rw_cont = {
2984 .interrupt = rw_interrupt,
2985 .redo = redo_fd_request,
2986 .error = bad_flp_intr,
2987 .done = request_done
2990 static void process_fd_request(void)
2993 schedule_bh(redo_fd_request);
2996 static void do_fd_request(request_queue_t * q)
2998 if (max_buffer_sectors == 0) {
2999 printk("VFS: do_fd_request called on non-open device\n");
3003 if (usage_count == 0) {
3004 printk("warning: usage count=0, current_req=%p exiting\n",
3006 printk("sect=%ld flags=%lx\n", (long)current_req->sector,
3007 current_req->flags);
3010 if (test_bit(0, &fdc_busy)) {
3011 /* fdc busy, this new request will be treated when the
3012 current one is done */
3013 is_alive("do fd request, old request running");
3016 lock_fdc(MAXTIMEOUT, 0);
3017 process_fd_request();
3018 is_alive("do fd request");
3021 static struct cont_t poll_cont = {
3022 .interrupt = success_and_wakeup,
3023 .redo = floppy_ready,
3024 .error = generic_failure,
3025 .done = generic_done
3028 static int poll_drive(int interruptible, int flag)
3031 /* no auto-sense, just clear dcl */
3032 raw_cmd = &default_raw_cmd;
3033 raw_cmd->flags = flag;
3035 raw_cmd->cmd_count = 0;
3038 if (DP->flags & FD_DEBUG) {
3039 DPRINT("setting NEWCHANGE in poll_drive\n");
3042 SETF(FD_DISK_NEWCHANGE);
3048 * User triggered reset
3049 * ====================
3052 static void reset_intr(void)
3054 printk("weird, reset interrupt called\n");
3057 static struct cont_t reset_cont = {
3058 .interrupt = reset_intr,
3059 .redo = success_and_wakeup,
3060 .error = generic_failure,
3061 .done = generic_done
3064 static int user_reset_fdc(int drive, int arg, int interruptible)
3069 LOCK_FDC(drive, interruptible);
3070 if (arg == FD_RESET_ALWAYS)
3076 process_fd_request();
3081 * Misc Ioctl's and support
3082 * ========================
3084 static inline int fd_copyout(void __user *param, const void *address,
3087 return copy_to_user(param, address, size) ? -EFAULT : 0;
3090 static inline int fd_copyin(void __user *param, void *address, unsigned long size)
3092 return copy_from_user(address, param, size) ? -EFAULT : 0;
3095 #define _COPYOUT(x) (copy_to_user((void __user *)param, &(x), sizeof(x)) ? -EFAULT : 0)
3096 #define _COPYIN(x) (copy_from_user(&(x), (void __user *)param, sizeof(x)) ? -EFAULT : 0)
3098 #define COPYOUT(x) ECALL(_COPYOUT(x))
3099 #define COPYIN(x) ECALL(_COPYIN(x))
3101 static inline const char *drive_name(int type, int drive)
3103 struct floppy_struct *floppy;
3106 floppy = floppy_type + type;
3108 if (UDP->native_format)
3109 floppy = floppy_type + UDP->native_format;
3114 return floppy->name;
3120 static void raw_cmd_done(int flag)
3125 raw_cmd->flags |= FD_RAW_FAILURE;
3126 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3128 raw_cmd->reply_count = inr;
3129 if (raw_cmd->reply_count > MAX_REPLIES)
3130 raw_cmd->reply_count = 0;
3131 for (i = 0; i < raw_cmd->reply_count; i++)
3132 raw_cmd->reply[i] = reply_buffer[i];
3134 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3135 unsigned long flags;
3136 flags = claim_dma_lock();
3137 raw_cmd->length = fd_get_dma_residue();
3138 release_dma_lock(flags);
3141 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3142 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3143 raw_cmd->flags |= FD_RAW_FAILURE;
3145 if (disk_change(current_drive))
3146 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3148 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3149 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3150 motor_off_callback(current_drive);
3152 if (raw_cmd->next &&
3153 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3154 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3155 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3156 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3157 raw_cmd = raw_cmd->next;
3164 static struct cont_t raw_cmd_cont = {
3165 .interrupt = success_and_wakeup,
3166 .redo = floppy_start,
3167 .error = generic_failure,
3168 .done = raw_cmd_done
3171 static inline int raw_cmd_copyout(int cmd, char __user *param,
3172 struct floppy_raw_cmd *ptr)
3178 param += sizeof(struct floppy_raw_cmd);
3179 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3180 if (ptr->length >= 0
3181 && ptr->length <= ptr->buffer_length)
3183 (ptr->data, ptr->kernel_data,
3184 ptr->buffer_length - ptr->length));
3191 static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3193 struct floppy_raw_cmd *next, *this;
3198 if (this->buffer_length) {
3199 fd_dma_mem_free((unsigned long)this->kernel_data,
3200 this->buffer_length);
3201 this->buffer_length = 0;
3209 static inline int raw_cmd_copyin(int cmd, char __user *param,
3210 struct floppy_raw_cmd **rcmd)
3212 struct floppy_raw_cmd *ptr;
3218 ptr = (struct floppy_raw_cmd *)
3219 kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3225 ptr->buffer_length = 0;
3226 param += sizeof(struct floppy_raw_cmd);
3227 if (ptr->cmd_count > 33)
3228 /* the command may now also take up the space
3229 * initially intended for the reply & the
3230 * reply count. Needed for long 82078 commands
3231 * such as RESTORE, which takes ... 17 command
3232 * bytes. Murphy's law #137: When you reserve
3233 * 16 bytes for a structure, you'll one day
3234 * discover that you really need 17...
3238 for (i = 0; i < 16; i++)
3240 ptr->resultcode = 0;
3241 ptr->kernel_data = NULL;
3243 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3244 if (ptr->length <= 0)
3247 (char *)fd_dma_mem_alloc(ptr->length);
3248 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3249 if (!ptr->kernel_data)
3251 ptr->buffer_length = ptr->length;
3253 if (ptr->flags & FD_RAW_WRITE)
3254 ECALL(fd_copyin(ptr->data, ptr->kernel_data,
3256 rcmd = &(ptr->next);
3257 if (!(ptr->flags & FD_RAW_MORE))
3263 static int raw_cmd_ioctl(int cmd, void __user *param)
3265 int drive, ret, ret2;
3266 struct floppy_raw_cmd *my_raw_cmd;
3268 if (FDCS->rawcmd <= 1)
3270 for (drive = 0; drive < N_DRIVE; drive++) {
3271 if (FDC(drive) != fdc)
3273 if (drive == current_drive) {
3274 if (UDRS->fd_ref > 1) {
3278 } else if (UDRS->fd_ref) {
3287 ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3289 raw_cmd_free(&my_raw_cmd);
3293 raw_cmd = my_raw_cmd;
3294 cont = &raw_cmd_cont;
3295 ret = wait_til_done(floppy_start, 1);
3297 if (DP->flags & FD_DEBUG) {
3298 DPRINT("calling disk change from raw_cmd ioctl\n");
3302 if (ret != -EINTR && FDCS->reset)
3305 DRS->track = NO_TRACK;
3307 ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3310 raw_cmd_free(&my_raw_cmd);
3314 static int invalidate_drive(struct block_device *bdev)
3316 /* invalidate the buffer track to force a reread */
3317 set_bit((long)bdev->bd_disk->private_data, &fake_change);
3318 process_fd_request();
3319 check_disk_change(bdev);
3323 static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
3324 int drive, int type, struct block_device *bdev)
3328 /* sanity checking for parameters. */
3331 g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3332 /* check if reserved bits are set */
3333 (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_ZEROBASED)) != 0)
3336 if (!capable(CAP_SYS_ADMIN))
3340 floppy_type[type] = *g;
3341 floppy_type[type].name = "user format";
3342 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3343 floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3344 floppy_type[type].size + 1;
3345 process_fd_request();
3346 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3347 struct block_device *bdev = opened_bdev[cnt];
3348 if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3350 __invalidate_device(bdev);
3356 if (cmd != FDDEFPRM)
3357 /* notice a disk change immediately, else
3358 * we lose our settings immediately*/
3359 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3360 oldStretch = g->stretch;
3361 user_params[drive] = *g;
3362 if (buffer_drive == drive)
3363 SUPBOUND(buffer_max, user_params[drive].sect);
3364 current_type[drive] = &user_params[drive];
3365 floppy_sizes[drive] = user_params[drive].size;
3366 if (cmd == FDDEFPRM)
3367 DRS->keep_data = -1;
3370 /* invalidation. Invalidate only when needed, i.e.
3371 * when there are already sectors in the buffer cache
3372 * whose number will change. This is useful, because
3373 * mtools often changes the geometry of the disk after
3374 * looking at the boot block */
3375 if (DRS->maxblock > user_params[drive].sect ||
3377 ((user_params[drive].sect ^ oldStretch) &
3378 (FD_SWAPSIDES | FD_ZEROBASED)))
3379 invalidate_drive(bdev);
3381 process_fd_request();
3386 /* handle obsolete ioctl's */
3387 static int ioctl_table[] = {
3415 static inline int normalize_ioctl(int *cmd, int *size)
3419 for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3420 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3421 *size = _IOC_SIZE(*cmd);
3422 *cmd = ioctl_table[i];
3423 if (*size > _IOC_SIZE(*cmd)) {
3424 printk("ioctl not yet supported\n");
3433 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3436 *g = &floppy_type[type];
3439 CALL(poll_drive(0, 0));
3440 process_fd_request();
3441 *g = current_type[drive];
3448 static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3450 int drive = (long)bdev->bd_disk->private_data;
3451 int type = ITYPE(drive_state[drive].fd_device);
3452 struct floppy_struct *g;
3455 ret = get_floppy_geometry(drive, type, &g);
3459 geo->heads = g->head;
3460 geo->sectors = g->sect;
3461 geo->cylinders = g->track;
3465 static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
3466 unsigned long param)
3468 #define FD_IOCTL_ALLOWED ((filp) && (filp)->private_data)
3469 #define OUT(c,x) case c: outparam = (const char *) (x); break
3470 #define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
3472 int drive = (long)inode->i_bdev->bd_disk->private_data;
3473 int i, type = ITYPE(UDRS->fd_device);
3477 struct floppy_struct g; /* geometry */
3478 struct format_descr f;
3479 struct floppy_max_errors max_errors;
3480 struct floppy_drive_params dp;
3481 } inparam; /* parameters coming from user space */
3482 const char *outparam; /* parameters passed back to user space */
3484 /* convert compatibility eject ioctls into floppy eject ioctl.
3485 * We do this in order to provide a means to eject floppy disks before
3486 * installing the new fdutils package */
3487 if (cmd == CDROMEJECT || /* CD-ROM eject */
3488 cmd == 0x6470 /* SunOS floppy eject */ ) {
3489 DPRINT("obsolete eject ioctl\n");
3490 DPRINT("please use floppycontrol --eject\n");
3494 /* convert the old style command into a new style command */
3495 if ((cmd & 0xff00) == 0x0200) {
3496 ECALL(normalize_ioctl(&cmd, &size));
3500 /* permission checks */
3501 if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
3502 ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3506 CLEARSTRUCT(&inparam);
3507 if (_IOC_DIR(cmd) & _IOC_WRITE)
3508 ECALL(fd_copyin((void __user *)param, &inparam, size))
3512 if (UDRS->fd_ref != 1)
3513 /* somebody else has this drive open */
3517 /* do the actual eject. Fails on
3518 * non-Sparc architectures */
3519 ret = fd_eject(UNIT(drive));
3521 USETF(FD_DISK_CHANGED);
3523 process_fd_request();
3527 current_type[drive] = NULL;
3528 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3529 UDRS->keep_data = 0;
3530 return invalidate_drive(inode->i_bdev);
3533 return set_geometry(cmd, &inparam.g,
3534 drive, type, inode->i_bdev);
3536 ECALL(get_floppy_geometry(drive, type,
3537 (struct floppy_struct **)
3542 UDP->flags |= FTD_MSG;
3545 UDP->flags &= ~FTD_MSG;
3550 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3552 process_fd_request();
3553 if (ret & FD_VERIFY)
3555 if (!(ret & FD_DISK_WRITABLE))
3559 if (UDRS->fd_ref != 1)
3561 return do_format(drive, &inparam.f);
3565 return invalidate_drive(inode->i_bdev);
3567 case FDSETEMSGTRESH:
3568 UDP->max_errors.reporting =
3569 (unsigned short)(param & 0x0f);
3571 OUT(FDGETMAXERRS, &UDP->max_errors);
3572 IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
3575 outparam = drive_name(type, drive);
3576 SUPBOUND(size, strlen(outparam) + 1);
3579 IN(FDSETDRVPRM, UDP, dp);
3580 OUT(FDGETDRVPRM, UDP);
3584 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3585 process_fd_request();
3587 OUT(FDGETDRVSTAT, UDRS);
3590 return user_reset_fdc(drive, (int)param, 1);
3592 OUT(FDGETFDCSTAT, UFDCS);
3597 OUT(FDWERRORGET, UDRWE);
3604 CALL(i = raw_cmd_ioctl(cmd, (void __user *)param));
3605 process_fd_request();
3611 process_fd_request();
3618 if (_IOC_DIR(cmd) & _IOC_READ)
3619 return fd_copyout((void __user *)param, outparam, size);
3626 static void __init config_types(void)
3631 /* read drive info out of physical CMOS */
3634 UDP->cmos = FLOPPY0_TYPE;
3636 if (!UDP->cmos && FLOPPY1_TYPE)
3637 UDP->cmos = FLOPPY1_TYPE;
3640 /* additional physical CMOS drive detection should go here */
3642 for (drive = 0; drive < N_DRIVE; drive++) {
3643 unsigned int type = UDP->cmos;
3644 struct floppy_drive_params *params;
3645 const char *name = NULL;
3646 static char temparea[32];
3648 if (type < NUMBER(default_drive_params)) {
3649 params = &default_drive_params[type].params;
3651 name = default_drive_params[type].name;
3652 allowed_drive_mask |= 1 << drive;
3654 allowed_drive_mask &= ~(1 << drive);
3656 params = &default_drive_params[0].params;
3657 sprintf(temparea, "unknown type %d (usb?)", type);
3661 const char *prepend = ",";
3663 prepend = KERN_INFO "Floppy drive(s):";
3666 printk("%s fd%d is %s", prepend, drive, name);
3667 register_devfs_entries(drive);
3675 static int floppy_release(struct inode *inode, struct file *filp)
3677 int drive = (long)inode->i_bdev->bd_disk->private_data;
3680 if (UDRS->fd_ref < 0)
3682 else if (!UDRS->fd_ref--) {
3683 DPRINT("floppy_release with fd_ref == 0");
3687 opened_bdev[drive] = NULL;
3688 floppy_release_irq_and_dma();
3694 * floppy_open check for aliasing (/dev/fd0 can be the same as
3695 * /dev/PS0 etc), and disallows simultaneous access to the same
3696 * drive with different device numbers.
3698 static int floppy_open(struct inode *inode, struct file *filp)
3700 int drive = (long)inode->i_bdev->bd_disk->private_data;
3706 filp->private_data = (void *)0;
3708 old_dev = UDRS->fd_device;
3709 if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
3712 if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
3713 USETF(FD_DISK_CHANGED);
3717 if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
3720 if (floppy_grab_irq_and_dma())
3723 if (filp->f_flags & O_EXCL)
3728 opened_bdev[drive] = inode->i_bdev;
3732 if (!floppy_track_buffer) {
3733 /* if opening an ED drive, reserve a big buffer,
3734 * else reserve a small one */
3735 if ((UDP->cmos == 6) || (UDP->cmos == 5))
3736 try = 64; /* Only 48 actually useful */
3738 try = 32; /* Only 24 actually useful */
3740 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3741 if (!tmp && !floppy_track_buffer) {
3742 try >>= 1; /* buffer only one side */
3744 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3746 if (!tmp && !floppy_track_buffer) {
3747 fallback_on_nodma_alloc(&tmp, 2048 * try);
3749 if (!tmp && !floppy_track_buffer) {
3750 DPRINT("Unable to allocate DMA memory\n");
3753 if (floppy_track_buffer) {
3755 fd_dma_mem_free((unsigned long)tmp, try * 1024);
3757 buffer_min = buffer_max = -1;
3758 floppy_track_buffer = tmp;
3759 max_buffer_sectors = try;
3763 UDRS->fd_device = iminor(inode);
3764 set_capacity(disks[drive], floppy_sizes[iminor(inode)]);
3765 if (old_dev != -1 && old_dev != iminor(inode)) {
3766 if (buffer_drive == drive)
3770 /* Allow ioctls if we have write-permissions even if read-only open.
3771 * Needed so that programs such as fdrawcmd still can work on write
3772 * protected disks */
3773 if ((filp->f_mode & FMODE_WRITE) || !file_permission(filp, MAY_WRITE))
3774 filp->private_data = (void *)8;
3776 if (UFDCS->rawcmd == 1)
3779 if (!(filp->f_flags & O_NDELAY)) {
3780 if (filp->f_mode & 3) {
3781 UDRS->last_checked = 0;
3782 check_disk_change(inode->i_bdev);
3783 if (UTESTF(FD_DISK_CHANGED))
3787 if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
3793 if (UDRS->fd_ref < 0)
3798 opened_bdev[drive] = NULL;
3799 floppy_release_irq_and_dma();
3806 * Check if the disk has been changed or if a change has been faked.
3808 static int check_floppy_change(struct gendisk *disk)
3810 int drive = (long)disk->private_data;
3812 if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
3815 if (UDP->checkfreq < (int)(jiffies - UDRS->last_checked)) {
3816 if (floppy_grab_irq_and_dma()) {
3822 process_fd_request();
3823 floppy_release_irq_and_dma();
3826 if (UTESTF(FD_DISK_CHANGED) ||
3827 UTESTF(FD_VERIFY) ||
3828 test_bit(drive, &fake_change) ||
3829 (!ITYPE(UDRS->fd_device) && !current_type[drive]))
3835 * This implements "read block 0" for floppy_revalidate().
3836 * Needed for format autodetection, checking whether there is
3837 * a disk in the drive, and whether that disk is writable.
3840 static int floppy_rb0_complete(struct bio *bio, unsigned int bytes_done,
3846 complete((struct completion *)bio->bi_private);
3850 static int __floppy_read_block_0(struct block_device *bdev)
3853 struct bio_vec bio_vec;
3854 struct completion complete;
3858 page = alloc_page(GFP_NOIO);
3860 process_fd_request();
3864 size = bdev->bd_block_size;
3869 bio.bi_io_vec = &bio_vec;
3870 bio_vec.bv_page = page;
3871 bio_vec.bv_len = size;
3872 bio_vec.bv_offset = 0;
3878 init_completion(&complete);
3879 bio.bi_private = &complete;
3880 bio.bi_end_io = floppy_rb0_complete;
3882 submit_bio(READ, &bio);
3883 generic_unplug_device(bdev_get_queue(bdev));
3884 process_fd_request();
3885 wait_for_completion(&complete);
3892 /* revalidate the floppy disk, i.e. trigger format autodetection by reading
3893 * the bootblock (block 0). "Autodetection" is also needed to check whether
3894 * there is a disk in the drive at all... Thus we also do it for fixed
3895 * geometry formats */
3896 static int floppy_revalidate(struct gendisk *disk)
3898 int drive = (long)disk->private_data;
3899 #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
3903 if (UTESTF(FD_DISK_CHANGED) ||
3904 UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
3905 if (usage_count == 0) {
3906 printk("VFS: revalidate called on non-open device.\n");
3910 cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
3911 if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
3912 process_fd_request(); /*already done by another thread */
3917 if (buffer_drive == drive)
3919 clear_bit(drive, &fake_change);
3920 UCLEARF(FD_DISK_CHANGED);
3925 res = __floppy_read_block_0(opened_bdev[drive]);
3928 poll_drive(0, FD_RAW_NEED_DISK);
3929 process_fd_request();
3932 set_capacity(disk, floppy_sizes[UDRS->fd_device]);
3936 static struct block_device_operations floppy_fops = {
3937 .owner = THIS_MODULE,
3938 .open = floppy_open,
3939 .release = floppy_release,
3941 .getgeo = fd_getgeo,
3942 .media_changed = check_floppy_change,
3943 .revalidate_disk = floppy_revalidate,
3945 static char *table[] = {
3946 "", "d360", "h1200", "u360", "u720", "h360", "h720",
3947 "u1440", "u2880", "CompaQ", "h1440", "u1680", "h410",
3948 "u820", "h1476", "u1722", "h420", "u830", "h1494", "u1743",
3949 "h880", "u1040", "u1120", "h1600", "u1760", "u1920",
3950 "u3200", "u3520", "u3840", "u1840", "u800", "u1600",
3953 static int t360[] = { 1, 0 },
3954 t1200[] = { 2, 5, 6, 10, 12, 14, 16, 18, 20, 23, 0 },
3955 t3in[] = { 8, 9, 26, 27, 28, 7, 11, 15, 19, 24, 25, 29, 31, 3, 4, 13,
3956 17, 21, 22, 30, 0 };
3957 static int *table_sup[] =
3958 { NULL, t360, t1200, t3in + 5 + 8, t3in + 5, t3in, t3in };
3960 static void __init register_devfs_entries(int drive)
3962 int base_minor = (drive < 4) ? drive : (124 + drive);
3964 if (UDP->cmos < NUMBER(default_drive_params)) {
3967 int minor = base_minor + (table_sup[UDP->cmos][i] << 2);
3969 devfs_mk_bdev(MKDEV(FLOPPY_MAJOR, minor),
3970 S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP |
3971 S_IWGRP, "floppy/%d%s", drive,
3972 table[table_sup[UDP->cmos][i]]);
3973 } while (table_sup[UDP->cmos][i++]);
3978 * Floppy Driver initialization
3979 * =============================
3982 /* Determine the floppy disk controller type */
3983 /* This routine was written by David C. Niemi */
3984 static char __init get_fdc_version(void)
3988 output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */
3991 if ((r = result()) <= 0x00)
3992 return FDC_NONE; /* No FDC present ??? */
3993 if ((r == 1) && (reply_buffer[0] == 0x80)) {
3994 printk(KERN_INFO "FDC %d is an 8272A\n", fdc);
3995 return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
3999 ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
4004 if (!fdc_configure()) {
4005 printk(KERN_INFO "FDC %d is an 82072\n", fdc);
4006 return FDC_82072; /* 82072 doesn't know CONFIGURE */
4009 output_byte(FD_PERPENDICULAR);
4010 if (need_more_output() == MORE_OUTPUT) {
4013 printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
4014 return FDC_82072A; /* 82072A as found on Sparcs. */
4017 output_byte(FD_UNLOCK);
4019 if ((r == 1) && (reply_buffer[0] == 0x80)) {
4020 printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
4021 return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
4024 if ((r != 1) || (reply_buffer[0] != 0x00)) {
4025 printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
4029 output_byte(FD_PARTID);
4032 printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
4036 if (reply_buffer[0] == 0x80) {
4037 printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);
4038 return FDC_82077; /* Revised 82077AA passes all the tests */
4040 switch (reply_buffer[0] >> 5) {
4042 /* Either a 82078-1 or a 82078SL running at 5Volt */
4043 printk(KERN_INFO "FDC %d is an 82078.\n", fdc);
4046 printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);
4049 printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
4052 printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",
4057 "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
4058 fdc, reply_buffer[0] >> 5);
4059 return FDC_82078_UNKN;
4061 } /* get_fdc_version */
4063 /* lilo configuration */
4065 static void __init floppy_set_flags(int *ints, int param, int param2)
4069 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4071 default_drive_params[i].params.flags |= param2;
4073 default_drive_params[i].params.flags &= ~param2;
4075 DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4078 static void __init daring(int *ints, int param, int param2)
4082 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4084 default_drive_params[i].params.select_delay = 0;
4085 default_drive_params[i].params.flags |=
4086 FD_SILENT_DCL_CLEAR;
4088 default_drive_params[i].params.select_delay =
4090 default_drive_params[i].params.flags &=
4091 ~FD_SILENT_DCL_CLEAR;
4094 DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4097 static void __init set_cmos(int *ints, int dummy, int dummy2)
4099 int current_drive = 0;
4102 DPRINT("wrong number of parameters for CMOS\n");
4105 current_drive = ints[1];
4106 if (current_drive < 0 || current_drive >= 8) {
4107 DPRINT("bad drive for set_cmos\n");
4111 if (current_drive >= 4 && !FDC2)
4115 DPRINT("setting CMOS code to %d\n", ints[2]);
4118 static struct param_table {
4120 void (*fn) (int *ints, int param, int param2);
4124 } config_params[] __initdata = {
4125 {"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4126 {"all_drives", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4127 {"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
4128 {"irq", NULL, &FLOPPY_IRQ, 6, 0},
4129 {"dma", NULL, &FLOPPY_DMA, 2, 0},
4130 {"daring", daring, NULL, 1, 0},
4132 {"two_fdc", NULL, &FDC2, 0x370, 0},
4133 {"one_fdc", NULL, &FDC2, 0, 0},
4135 {"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
4136 {"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
4137 {"messages", floppy_set_flags, NULL, 1, FTD_MSG},
4138 {"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
4139 {"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
4140 {"nodma", NULL, &can_use_virtual_dma, 1, 0},
4141 {"omnibook", NULL, &can_use_virtual_dma, 1, 0},
4142 {"yesdma", NULL, &can_use_virtual_dma, 0, 0},
4143 {"fifo_depth", NULL, &fifo_depth, 0xa, 0},
4144 {"nofifo", NULL, &no_fifo, 0x20, 0},
4145 {"usefifo", NULL, &no_fifo, 0, 0},
4146 {"cmos", set_cmos, NULL, 0, 0},
4147 {"slow", NULL, &slow_floppy, 1, 0},
4148 {"unexpected_interrupts", NULL, &print_unex, 1, 0},
4149 {"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
4150 {"L40SX", NULL, &print_unex, 0, 0}
4155 static int __init floppy_setup(char *str)
4161 str = get_options(str, ARRAY_SIZE(ints), ints);
4163 for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4164 if (strcmp(str, config_params[i].name) == 0) {
4168 param = config_params[i].def_param;
4169 if (config_params[i].fn)
4172 config_params[i].param2);
4173 if (config_params[i].var) {
4174 DPRINT("%s=%d\n", str, param);
4175 *config_params[i].var = param;
4182 DPRINT("unknown floppy option [%s]\n", str);
4184 DPRINT("allowed options are:");
4185 for (i = 0; i < ARRAY_SIZE(config_params); i++)
4186 printk(" %s", config_params[i].name);
4189 DPRINT("botched floppy option\n");
4190 DPRINT("Read Documentation/floppy.txt\n");
4194 static int have_no_fdc = -ENODEV;
4196 static ssize_t floppy_cmos_show(struct device *dev,
4197 struct device_attribute *attr, char *buf)
4199 struct platform_device *p;
4202 p = container_of(dev, struct platform_device,dev);
4204 return sprintf(buf, "%X\n", UDP->cmos);
4206 DEVICE_ATTR(cmos,S_IRUGO,floppy_cmos_show,NULL);
4208 static void floppy_device_release(struct device *dev)
4210 complete(&device_release);
4213 static struct platform_device floppy_device[N_DRIVE];
4215 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4217 int drive = (*part & 3) | ((*part & 0x80) >> 5);
4218 if (drive >= N_DRIVE ||
4219 !(allowed_drive_mask & (1 << drive)) ||
4220 fdc_state[FDC(drive)].version == FDC_NONE)
4222 if (((*part >> 2) & 0x1f) >= NUMBER(floppy_type))
4225 return get_disk(disks[drive]);
4228 static int __init floppy_init(void)
4235 for (dr = 0; dr < N_DRIVE; dr++) {
4236 disks[dr] = alloc_disk(1);
4242 disks[dr]->major = FLOPPY_MAJOR;
4243 disks[dr]->first_minor = TOMINOR(dr);
4244 disks[dr]->fops = &floppy_fops;
4245 sprintf(disks[dr]->disk_name, "fd%d", dr);
4247 init_timer(&motor_off_timer[dr]);
4248 motor_off_timer[dr].data = dr;
4249 motor_off_timer[dr].function = motor_off_callback;
4252 devfs_mk_dir("floppy");
4254 err = register_blkdev(FLOPPY_MAJOR, "fd");
4256 goto out_devfs_remove;
4258 floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
4259 if (!floppy_queue) {
4261 goto out_unreg_blkdev;
4263 blk_queue_max_sectors(floppy_queue, 64);
4265 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4266 floppy_find, NULL, NULL);
4268 for (i = 0; i < 256; i++)
4270 floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4272 floppy_sizes[i] = MAX_DISK_SIZE << 1;
4274 reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
4277 for (i = 0; i < N_FDC; i++) {
4282 #if defined(__sparc__) || defined(__mc68000__)
4283 /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
4287 FDCS->version = FDC_82072A;
4291 use_virtual_dma = can_use_virtual_dma & 1;
4292 #if defined(CONFIG_PPC64)
4293 if (check_legacy_ioport(FDC1)) {
4294 del_timer(&fd_timeout);
4296 goto out_unreg_region;
4299 fdc_state[0].address = FDC1;
4300 if (fdc_state[0].address == -1) {
4301 del_timer(&fd_timeout);
4303 goto out_unreg_region;
4306 fdc_state[1].address = FDC2;
4309 fdc = 0; /* reset fdc in case of unexpected interrupt */
4310 err = floppy_grab_irq_and_dma();
4312 del_timer(&fd_timeout);
4314 goto out_unreg_region;
4317 /* initialise drive state */
4318 for (drive = 0; drive < N_DRIVE; drive++) {
4321 USETF(FD_DISK_NEWCHANGE);
4322 USETF(FD_DISK_CHANGED);
4324 UDRS->fd_device = -1;
4325 floppy_track_buffer = NULL;
4326 max_buffer_sectors = 0;
4329 * Small 10 msec delay to let through any interrupt that
4330 * initialization might have triggered, to not
4331 * confuse detection:
4335 for (i = 0; i < N_FDC; i++) {
4337 FDCS->driver_version = FD_DRIVER_VERSION;
4338 for (unit = 0; unit < 4; unit++)
4339 FDCS->track[unit] = 0;
4340 if (FDCS->address == -1)
4343 if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
4344 /* free ioports reserved by floppy_grab_irq_and_dma() */
4345 release_region(FDCS->address + 2, 4);
4346 release_region(FDCS->address + 7, 1);
4348 FDCS->version = FDC_NONE;
4351 /* Try to determine the floppy controller type */
4352 FDCS->version = get_fdc_version();
4353 if (FDCS->version == FDC_NONE) {
4354 /* free ioports reserved by floppy_grab_irq_and_dma() */
4355 release_region(FDCS->address + 2, 4);
4356 release_region(FDCS->address + 7, 1);
4360 if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
4361 can_use_virtual_dma = 0;
4364 /* Not all FDCs seem to be able to handle the version command
4365 * properly, so force a reset for the standard FDC clones,
4366 * to avoid interrupt garbage.
4368 user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
4371 del_timer(&fd_timeout);
4373 floppy_release_irq_and_dma();
4376 DPRINT("no floppy controllers found\n");
4378 goto out_flush_work;
4381 for (drive = 0; drive < N_DRIVE; drive++) {
4382 if (!(allowed_drive_mask & (1 << drive)))
4384 if (fdc_state[FDC(drive)].version == FDC_NONE)
4387 floppy_device[drive].name = floppy_device_name;
4388 floppy_device[drive].id = drive;
4389 floppy_device[drive].dev.release = floppy_device_release;
4391 err = platform_device_register(&floppy_device[drive]);
4393 goto out_flush_work;
4395 device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
4396 /* to be cleaned up... */
4397 disks[drive]->private_data = (void *)(long)drive;
4398 disks[drive]->queue = floppy_queue;
4399 disks[drive]->flags |= GENHD_FL_REMOVABLE;
4400 disks[drive]->driverfs_dev = &floppy_device[drive].dev;
4401 add_disk(disks[drive]);
4407 flush_scheduled_work();
4409 floppy_release_irq_and_dma();
4411 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4412 blk_cleanup_queue(floppy_queue);
4414 unregister_blkdev(FLOPPY_MAJOR, "fd");
4416 devfs_remove("floppy");
4419 del_timer(&motor_off_timer[dr]);
4420 put_disk(disks[dr]);
4425 static DEFINE_SPINLOCK(floppy_usage_lock);
4427 static int floppy_grab_irq_and_dma(void)
4429 unsigned long flags;
4431 spin_lock_irqsave(&floppy_usage_lock, flags);
4432 if (usage_count++) {
4433 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4436 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4437 if (fd_request_irq()) {
4438 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4440 spin_lock_irqsave(&floppy_usage_lock, flags);
4442 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4445 if (fd_request_dma()) {
4446 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4449 spin_lock_irqsave(&floppy_usage_lock, flags);
4451 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4455 for (fdc = 0; fdc < N_FDC; fdc++) {
4456 if (FDCS->address != -1) {
4457 if (!request_region(FDCS->address + 2, 4, "floppy")) {
4458 DPRINT("Floppy io-port 0x%04lx in use\n",
4462 if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
4463 DPRINT("Floppy io-port 0x%04lx in use\n",
4467 /* address + 6 is reserved, and may be taken by IDE.
4468 * Unfortunately, Adaptec doesn't know this :-(, */
4471 for (fdc = 0; fdc < N_FDC; fdc++) {
4472 if (FDCS->address != -1) {
4474 fd_outb(FDCS->dor, FD_DOR);
4478 set_dor(0, ~0, 8); /* avoid immediate interrupt */
4480 for (fdc = 0; fdc < N_FDC; fdc++)
4481 if (FDCS->address != -1)
4482 fd_outb(FDCS->dor, FD_DOR);
4484 * The driver will try and free resources and relies on us
4485 * to know if they were allocated or not.
4488 irqdma_allocated = 1;
4491 release_region(FDCS->address + 2, 4);
4495 while (--fdc >= 0) {
4496 release_region(FDCS->address + 2, 4);
4497 release_region(FDCS->address + 7, 1);
4499 spin_lock_irqsave(&floppy_usage_lock, flags);
4501 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4505 static void floppy_release_irq_and_dma(void)
4508 #ifdef FLOPPY_SANITY_CHECK
4514 unsigned long tmpaddr;
4515 unsigned long flags;
4517 spin_lock_irqsave(&floppy_usage_lock, flags);
4518 if (--usage_count) {
4519 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4522 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4523 if (irqdma_allocated) {
4527 irqdma_allocated = 0;
4533 floppy_enable_hlt();
4535 if (floppy_track_buffer && max_buffer_sectors) {
4536 tmpsize = max_buffer_sectors * 1024;
4537 tmpaddr = (unsigned long)floppy_track_buffer;
4538 floppy_track_buffer = NULL;
4539 max_buffer_sectors = 0;
4540 buffer_min = buffer_max = -1;
4541 fd_dma_mem_free(tmpaddr, tmpsize);
4543 #ifdef FLOPPY_SANITY_CHECK
4545 for (drive = 0; drive < N_FDC * 4; drive++)
4546 if (timer_pending(motor_off_timer + drive))
4547 printk("motor off timer %d still active\n", drive);
4550 if (timer_pending(&fd_timeout))
4551 printk("floppy timer still active:%s\n", timeout_message);
4552 if (timer_pending(&fd_timer))
4553 printk("auxiliary floppy timer still active\n");
4554 if (floppy_work.pending)
4555 printk("work still pending\n");
4558 for (fdc = 0; fdc < N_FDC; fdc++)
4559 if (FDCS->address != -1) {
4560 release_region(FDCS->address + 2, 4);
4561 release_region(FDCS->address + 7, 1);
4568 static char *floppy;
4570 static void unregister_devfs_entries(int drive)
4574 if (UDP->cmos < NUMBER(default_drive_params)) {
4577 devfs_remove("floppy/%d%s", drive,
4578 table[table_sup[UDP->cmos][i]]);
4579 } while (table_sup[UDP->cmos][i++]);
4583 static void __init parse_floppy_cfg_string(char *cfg)
4588 for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != '\t'; cfg++) ;
4598 int init_module(void)
4601 parse_floppy_cfg_string(floppy);
4602 return floppy_init();
4605 void cleanup_module(void)
4609 init_completion(&device_release);
4610 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4611 unregister_blkdev(FLOPPY_MAJOR, "fd");
4613 for (drive = 0; drive < N_DRIVE; drive++) {
4614 del_timer_sync(&motor_off_timer[drive]);
4616 if ((allowed_drive_mask & (1 << drive)) &&
4617 fdc_state[FDC(drive)].version != FDC_NONE) {
4618 del_gendisk(disks[drive]);
4619 unregister_devfs_entries(drive);
4620 device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
4621 platform_device_unregister(&floppy_device[drive]);
4623 put_disk(disks[drive]);
4625 devfs_remove("floppy");
4627 del_timer_sync(&fd_timeout);
4628 del_timer_sync(&fd_timer);
4629 blk_cleanup_queue(floppy_queue);
4632 floppy_release_irq_and_dma();
4634 /* eject disk, if any */
4637 wait_for_completion(&device_release);
4640 module_param(floppy, charp, 0);
4641 module_param(FLOPPY_IRQ, int, 0);
4642 module_param(FLOPPY_DMA, int, 0);
4643 MODULE_AUTHOR("Alain L. Knaff");
4644 MODULE_SUPPORTED_DEVICE("fd");
4645 MODULE_LICENSE("GPL");
4649 __setup("floppy=", floppy_setup);
4650 module_init(floppy_init)
4653 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);