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/05/07 -- Russell King -- More portability cleanups; moved definition of
102 * interrupt and dma channel to asm/floppy.h. Cleaned up some formatting &
103 * use of '0' for NULL.
107 * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
112 * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
116 * 1999/08/13 -- Paul Slootman -- floppy stopped working on Alpha after 24
117 * days, 6 hours, 32 minutes and 32 seconds (i.e. MAXINT jiffies; ints were
118 * being used to store jiffies, which are unsigned longs).
122 * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
123 * - get rid of check_region
128 * 2001/08/26 -- Paul Gortmaker - fix insmod oops on machines with no
129 * floppy controller (lingering task on list after module is gone... boom.)
133 * 2002/02/07 -- Anton Altaparmakov - Fix io ports reservation to correct range
134 * (0x3f2-0x3f5, 0x3f7). This fix is a bit of a hack but the proper fix
135 * requires many non-obvious changes in arch dependent code.
138 /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
139 * Better audit of register_blkdev.
142 #define FLOPPY_SANITY_CHECK
143 #undef FLOPPY_SILENT_DCL_CLEAR
145 #define REALLY_SLOW_IO
148 #define DCL_DEBUG /* debug disk change line */
150 /* do print messages for unexpected interrupts */
151 static int print_unex = 1;
152 #include <linux/module.h>
153 #include <linux/sched.h>
154 #include <linux/fs.h>
155 #include <linux/kernel.h>
156 #include <linux/timer.h>
157 #include <linux/workqueue.h>
158 #include <linux/version.h>
160 #include <linux/fdreg.h>
163 * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
166 #include <linux/fd.h>
167 #include <linux/hdreg.h>
169 #include <linux/errno.h>
170 #include <linux/slab.h>
171 #include <linux/mm.h>
172 #include <linux/bio.h>
173 #include <linux/string.h>
174 #include <linux/fcntl.h>
175 #include <linux/delay.h>
176 #include <linux/mc146818rtc.h> /* CMOS defines */
177 #include <linux/ioport.h>
178 #include <linux/interrupt.h>
179 #include <linux/init.h>
180 #include <linux/devfs_fs_kernel.h>
181 #include <linux/device.h>
182 #include <linux/buffer_head.h> /* for invalidate_buffers() */
185 * PS/2 floppies have much slower step rates than regular floppies.
186 * It's been recommended that take about 1/4 of the default speed
187 * in some more extreme cases.
189 static int slow_floppy;
193 #include <asm/system.h>
195 #include <asm/uaccess.h>
197 static int FLOPPY_IRQ = 6;
198 static int FLOPPY_DMA = 2;
199 static int can_use_virtual_dma = 2;
201 * can use virtual DMA:
202 * 0 = use of virtual DMA disallowed by config
203 * 1 = use of virtual DMA prescribed by config
204 * 2 = no virtual DMA preference configured. By default try hard DMA,
205 * but fall back on virtual DMA when not enough memory available
208 static int use_virtual_dma;
212 * 1 using virtual DMA
213 * This variable is set to virtual when a DMA mem problem arises, and
214 * reset back in floppy_grab_irq_and_dma.
215 * It is not safe to reset it in other circumstances, because the floppy
216 * driver may have several buffers in use at once, and we do currently not
217 * record each buffers capabilities
220 static spinlock_t floppy_lock = SPIN_LOCK_UNLOCKED;
221 static struct completion device_release;
223 static unsigned short virtual_dma_port = 0x3f0;
224 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
225 static int set_dor(int fdc, char mask, char data);
226 static void register_devfs_entries(int drive) __init;
228 #define K_64 0x10000 /* 64KB */
230 /* the following is the mask of allowed drives. By default units 2 and
231 * 3 of both floppy controllers are disabled, because switching on the
232 * motor of these drives causes system hangs on some PCI computers. drive
233 * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
234 * a drive is allowed.
236 * NOTE: This must come before we include the arch floppy header because
237 * some ports reference this variable from there. -DaveM
240 static int allowed_drive_mask = 0x33;
242 #include <asm/floppy.h>
244 static int irqdma_allocated;
246 #define LOCAL_END_REQUEST
247 #define DEVICE_NAME "floppy"
249 #include <linux/blkdev.h>
250 #include <linux/blkpg.h>
251 #include <linux/cdrom.h> /* for the compatibility eject ioctl */
252 #include <linux/completion.h>
254 static struct request *current_req;
255 static struct request_queue *floppy_queue;
256 static void do_fd_request(request_queue_t * q);
258 #ifndef fd_get_dma_residue
259 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
262 /* Dma Memory related stuff */
264 #ifndef fd_dma_mem_free
265 #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
268 #ifndef fd_dma_mem_alloc
269 #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
272 static inline void fallback_on_nodma_alloc(char **addr, size_t l)
274 #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
276 return; /* we have the memory */
277 if (can_use_virtual_dma != 2)
278 return; /* no fallback allowed */
280 ("DMA memory shortage. Temporarily falling back on virtual DMA\n");
281 *addr = (char *)nodma_mem_alloc(l);
287 /* End dma memory related stuff */
289 static unsigned long fake_change;
290 static int initialising = 1;
292 #define ITYPE(x) (((x)>>2) & 0x1f)
293 #define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
294 #define UNIT(x) ((x) & 0x03) /* drive on fdc */
295 #define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
296 #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
297 /* reverse mapping from unit and fdc to drive */
298 #define DP (&drive_params[current_drive])
299 #define DRS (&drive_state[current_drive])
300 #define DRWE (&write_errors[current_drive])
301 #define FDCS (&fdc_state[fdc])
302 #define CLEARF(x) (clear_bit(x##_BIT, &DRS->flags))
303 #define SETF(x) (set_bit(x##_BIT, &DRS->flags))
304 #define TESTF(x) (test_bit(x##_BIT, &DRS->flags))
306 #define UDP (&drive_params[drive])
307 #define UDRS (&drive_state[drive])
308 #define UDRWE (&write_errors[drive])
309 #define UFDCS (&fdc_state[FDC(drive)])
310 #define UCLEARF(x) (clear_bit(x##_BIT, &UDRS->flags))
311 #define USETF(x) (set_bit(x##_BIT, &UDRS->flags))
312 #define UTESTF(x) (test_bit(x##_BIT, &UDRS->flags))
314 #define DPRINT(format, args...) printk(DEVICE_NAME "%d: " format, current_drive , ## args)
316 #define PH_HEAD(floppy,head) (((((floppy)->stretch & 2) >>1) ^ head) << 2)
317 #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
319 #define CLEARSTRUCT(x) memset((x), 0, sizeof(*(x)))
322 #define COMMAND raw_cmd->cmd[0]
323 #define DR_SELECT raw_cmd->cmd[1]
324 #define TRACK raw_cmd->cmd[2]
325 #define HEAD raw_cmd->cmd[3]
326 #define SECTOR raw_cmd->cmd[4]
327 #define SIZECODE raw_cmd->cmd[5]
328 #define SECT_PER_TRACK raw_cmd->cmd[6]
329 #define GAP raw_cmd->cmd[7]
330 #define SIZECODE2 raw_cmd->cmd[8]
334 #define F_SIZECODE raw_cmd->cmd[2]
335 #define F_SECT_PER_TRACK raw_cmd->cmd[3]
336 #define F_GAP raw_cmd->cmd[4]
337 #define F_FILL raw_cmd->cmd[5]
341 * Maximum disk size (in kilobytes). This default is used whenever the
342 * current disk size is unknown.
343 * [Now it is rather a minimum]
345 #define MAX_DISK_SIZE 4 /* 3984 */
348 * globals used by 'result()'
350 #define MAX_REPLIES 16
351 static unsigned char reply_buffer[MAX_REPLIES];
352 static int inr; /* size of reply buffer, when called from interrupt */
353 #define ST0 (reply_buffer[0])
354 #define ST1 (reply_buffer[1])
355 #define ST2 (reply_buffer[2])
356 #define ST3 (reply_buffer[0]) /* result of GETSTATUS */
357 #define R_TRACK (reply_buffer[3])
358 #define R_HEAD (reply_buffer[4])
359 #define R_SECTOR (reply_buffer[5])
360 #define R_SIZECODE (reply_buffer[6])
362 #define SEL_DLY (2*HZ/100)
365 * this struct defines the different floppy drive types.
368 struct floppy_drive_params params;
369 const char *name; /* name printed while booting */
370 } default_drive_params[] = {
371 /* NOTE: the time values in jiffies should be in msec!
373 | Maximum data rate supported by drive type
374 | | Head load time, msec
375 | | | Head unload time, msec (not used)
376 | | | | Step rate interval, usec
377 | | | | | Time needed for spinup time (jiffies)
378 | | | | | | Timeout for spinning down (jiffies)
379 | | | | | | | Spindown offset (where disk stops)
380 | | | | | | | | Select delay
381 | | | | | | | | | RPS
382 | | | | | | | | | | Max number of tracks
383 | | | | | | | | | | | Interrupt timeout
384 | | | | | | | | | | | | Max nonintlv. sectors
385 | | | | | | | | | | | | | -Max Errors- flags */
386 {{0, 500, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 80, 3*HZ, 20, {3,1,2,0,2}, 0,
387 0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
389 {{1, 300, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 40, 3*HZ, 17, {3,1,2,0,2}, 0,
390 0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
392 {{2, 500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6, 83, 3*HZ, 17, {3,1,2,0,2}, 0,
393 0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
395 {{3, 250, 16, 16, 3000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
396 0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
398 {{4, 500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
399 0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
401 {{5, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
402 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
404 {{6, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
405 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
406 /* | --autodetected formats--- | | |
407 * read_track | | Name printed when booting
409 * Frequency of disk change checks */
412 static struct floppy_drive_params drive_params[N_DRIVE];
413 static struct floppy_drive_struct drive_state[N_DRIVE];
414 static struct floppy_write_errors write_errors[N_DRIVE];
415 static struct timer_list motor_off_timer[N_DRIVE];
416 static struct gendisk *disks[N_DRIVE];
417 static struct block_device *opened_bdev[N_DRIVE];
418 static DECLARE_MUTEX(open_lock);
419 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
422 * This struct defines the different floppy types.
424 * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
425 * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
426 * tells if the disk is in Commodore 1581 format, which means side 0 sectors
427 * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
428 * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
429 * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
430 * side 0 is on physical side 0 (but with the misnamed sector IDs).
431 * 'stretch' should probably be renamed to something more general, like
432 * 'options'. Other parameters should be self-explanatory (see also
442 | | | | | | Data rate, | 0x40 for perp
443 | | | | | | | Spec1 (stepping rate, head unload
444 | | | | | | | | /fmt gap (gap2) */
445 static struct floppy_struct floppy_type[32] = {
446 { 0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL }, /* 0 no testing */
447 { 720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360" }, /* 1 360KB PC */
448 { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /* 2 1.2MB AT */
449 { 720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360" }, /* 3 360KB SS 3.5" */
450 { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720" }, /* 4 720KB 3.5" */
451 { 720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360" }, /* 5 360KB AT */
452 { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720" }, /* 6 720KB AT */
453 { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /* 7 1.44MB 3.5" */
454 { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /* 8 2.88MB 3.5" */
455 { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /* 9 3.12MB 3.5" */
457 { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25" */
458 { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5" */
459 { 820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410" }, /* 12 410KB 5.25" */
460 { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820" }, /* 13 820KB 3.5" */
461 { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25" */
462 { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5" */
463 { 840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420" }, /* 16 420KB 5.25" */
464 { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830" }, /* 17 830KB 3.5" */
465 { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25" */
466 { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5" */
468 { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880" }, /* 20 880KB 5.25" */
469 { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5" */
470 { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5" */
471 { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25" */
472 { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5" */
473 { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5" */
474 { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5" */
475 { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5" */
476 { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5" */
478 { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5" */
479 { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800" }, /* 30 800KB 3.5" */
480 { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5" */
483 #define NUMBER(x) (sizeof(x) / sizeof(*(x)))
484 #define SECTSIZE (_FD_SECTSIZE(*floppy))
486 /* Auto-detection: Disk type used until the next media change occurs. */
487 static struct floppy_struct *current_type[N_DRIVE];
490 * User-provided type information. current_type points to
491 * the respective entry of this array.
493 static struct floppy_struct user_params[N_DRIVE];
495 static sector_t floppy_sizes[256];
498 * The driver is trying to determine the correct media format
499 * while probing is set. rw_interrupt() clears it after a
504 /* Synchronization of FDC access. */
505 #define FD_COMMAND_NONE -1
506 #define FD_COMMAND_ERROR 2
507 #define FD_COMMAND_OKAY 3
509 static volatile int command_status = FD_COMMAND_NONE;
510 static unsigned long fdc_busy;
511 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
512 static DECLARE_WAIT_QUEUE_HEAD(command_done);
514 #define NO_SIGNAL (!interruptible || !signal_pending(current))
515 #define CALL(x) if ((x) == -EINTR) return -EINTR
516 #define ECALL(x) if ((ret = (x))) return ret;
517 #define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
518 #define WAIT(x) _WAIT((x),interruptible)
519 #define IWAIT(x) _WAIT((x),1)
521 /* Errors during formatting are counted here. */
522 static int format_errors;
524 /* Format request descriptor. */
525 static struct format_descr format_req;
528 * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
529 * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
530 * H is head unload time (1=16ms, 2=32ms, etc)
535 * Because these are written to by the DMA controller, they must
536 * not contain a 64k byte boundary crossing, or data will be
539 static char *floppy_track_buffer;
540 static int max_buffer_sectors;
543 typedef void (*done_f) (int);
544 static struct cont_t {
545 void (*interrupt) (void); /* this is called after the interrupt of the
547 void (*redo) (void); /* this is called to retry the operation */
548 void (*error) (void); /* this is called to tally an error */
549 done_f done; /* this is called to say if the operation has
550 * succeeded/failed */
553 static void floppy_ready(void);
554 static void floppy_start(void);
555 static void process_fd_request(void);
556 static void recalibrate_floppy(void);
557 static void floppy_shutdown(unsigned long);
559 static int floppy_grab_irq_and_dma(void);
560 static void floppy_release_irq_and_dma(void);
563 * The "reset" variable should be tested whenever an interrupt is scheduled,
564 * after the commands have been sent. This is to ensure that the driver doesn't
565 * get wedged when the interrupt doesn't come because of a failed command.
566 * reset doesn't need to be tested before sending commands, because
567 * output_byte is automatically disabled when reset is set.
569 #define CHECK_RESET { if (FDCS->reset){ reset_fdc(); return; } }
570 static void reset_fdc(void);
573 * These are global variables, as that's the easiest way to give
574 * information to interrupts. They are the data used for the current
578 #define NEED_1_RECAL -2
579 #define NEED_2_RECAL -3
581 static int usage_count;
583 /* buffer related variables */
584 static int buffer_track = -1;
585 static int buffer_drive = -1;
586 static int buffer_min = -1;
587 static int buffer_max = -1;
589 /* fdc related variables, should end up in a struct */
590 static struct floppy_fdc_state fdc_state[N_FDC];
591 static int fdc; /* current fdc */
593 static struct floppy_struct *_floppy = floppy_type;
594 static unsigned char current_drive;
595 static long current_count_sectors;
596 static unsigned char fsector_t; /* sector in track */
597 static unsigned char in_sector_offset; /* offset within physical sector,
598 * expressed in units of 512 bytes */
601 static inline int fd_eject(int drive)
608 static long unsigned debugtimer;
615 static inline void set_debugt(void)
618 debugtimer = jiffies;
622 static inline void debugt(const char *message)
625 if (DP->flags & DEBUGT)
626 printk("%s dtime=%lu\n", message, jiffies - debugtimer);
630 typedef void (*timeout_fn) (unsigned long);
631 static struct timer_list fd_timeout = TIMER_INITIALIZER(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 struct timer_list fd_timer = TIMER_INITIALIZER(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 spinlock_t floppy_hlt_lock = SPIN_LOCK_UNLOCKED;
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]);
1550 debugt("rw_command: ");
1558 if (!(flags & FD_RAW_INTR)) {
1561 } else if (flags & FD_RAW_NEED_DISK)
1565 static int blind_seek;
1568 * This is the routine called after every seek (or recalibrate) interrupt
1569 * from the floppy controller.
1571 static void seek_interrupt(void)
1574 debugt("seek interrupt:");
1576 if (inr != 2 || (ST0 & 0xF8) != 0x20) {
1577 DPRINT("seek failed\n");
1578 DRS->track = NEED_2_RECAL;
1583 if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
1585 if (DP->flags & FD_DEBUG) {
1587 ("clearing NEWCHANGE flag because of effective seek\n");
1588 DPRINT("jiffies=%lu\n", jiffies);
1591 CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
1592 DRS->select_date = jiffies;
1598 static void check_wp(void)
1600 if (TESTF(FD_VERIFY)) {
1601 /* check write protection */
1602 output_byte(FD_GETSTATUS);
1603 output_byte(UNIT(current_drive));
1604 if (result() != 1) {
1609 CLEARF(FD_NEED_TWADDLE);
1611 if (DP->flags & FD_DEBUG) {
1612 DPRINT("checking whether disk is write protected\n");
1613 DPRINT("wp=%x\n", ST3 & 0x40);
1617 SETF(FD_DISK_WRITABLE);
1619 CLEARF(FD_DISK_WRITABLE);
1623 static void seek_floppy(void)
1630 if (DP->flags & FD_DEBUG) {
1631 DPRINT("calling disk change from seek\n");
1635 if (!TESTF(FD_DISK_NEWCHANGE) &&
1636 disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1637 /* the media changed flag should be cleared after the seek.
1638 * If it isn't, this means that there is really no disk in
1641 SETF(FD_DISK_CHANGED);
1646 if (DRS->track <= NEED_1_RECAL) {
1647 recalibrate_floppy();
1649 } else if (TESTF(FD_DISK_NEWCHANGE) &&
1650 (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1651 (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
1652 /* we seek to clear the media-changed condition. Does anybody
1653 * know a more elegant way, which works on all drives? */
1655 track = raw_cmd->track - 1;
1657 if (DP->flags & FD_SILENT_DCL_CLEAR) {
1658 set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
1660 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1666 if (raw_cmd->track != DRS->track &&
1667 (raw_cmd->flags & FD_RAW_NEED_SEEK))
1668 track = raw_cmd->track;
1675 do_floppy = seek_interrupt;
1676 output_byte(FD_SEEK);
1677 output_byte(UNIT(current_drive));
1680 debugt("seek command:");
1684 static void recal_interrupt(void)
1687 debugt("recal interrupt:");
1691 else if (ST0 & ST0_ECE) {
1692 switch (DRS->track) {
1695 debugt("recal interrupt need 1 recal:");
1697 /* after a second recalibrate, we still haven't
1698 * reached track 0. Probably no drive. Raise an
1699 * error, as failing immediately might upset
1700 * computers possessed by the Devil :-) */
1706 debugt("recal interrupt need 2 recal:");
1708 /* If we already did a recalibrate,
1709 * and we are not at track 0, this
1710 * means we have moved. (The only way
1711 * not to move at recalibration is to
1712 * be already at track 0.) Clear the
1713 * new change flag */
1715 if (DP->flags & FD_DEBUG) {
1717 ("clearing NEWCHANGE flag because of second recalibrate\n");
1721 CLEARF(FD_DISK_NEWCHANGE);
1722 DRS->select_date = jiffies;
1726 debugt("recal interrupt default:");
1728 /* Recalibrate moves the head by at
1729 * most 80 steps. If after one
1730 * recalibrate we don't have reached
1731 * track 0, this might mean that we
1732 * started beyond track 80. Try
1734 DRS->track = NEED_1_RECAL;
1742 static void print_result(char *message, int inr)
1746 DPRINT("%s ", message);
1748 for (i = 0; i < inr; i++)
1749 printk("repl[%d]=%x ", i, reply_buffer[i]);
1753 /* interrupt handler. Note that this can be called externally on the Sparc */
1754 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1756 void (*handler) (void) = do_floppy;
1760 lasthandler = handler;
1761 interruptjiffies = jiffies;
1763 f = claim_dma_lock();
1765 release_dma_lock(f);
1767 floppy_enable_hlt();
1769 if (fdc >= N_FDC || FDCS->address == -1) {
1770 /* we don't even know which FDC is the culprit */
1771 printk("DOR0=%x\n", fdc_state[0].dor);
1772 printk("floppy interrupt on bizarre fdc %d\n", fdc);
1773 printk("handler=%p\n", handler);
1774 is_alive("bizarre fdc");
1779 /* We have to clear the reset flag here, because apparently on boxes
1780 * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
1781 * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
1782 * emission of the SENSEI's.
1783 * It is OK to emit floppy commands because we are in an interrupt
1784 * handler here, and thus we have to fear no interference of other
1788 do_print = !handler && print_unex && !initialising;
1792 print_result("unexpected interrupt", inr);
1796 output_byte(FD_SENSEI);
1799 print_result("sensei", inr);
1801 } while ((ST0 & 0x83) != UNIT(current_drive) && inr == 2
1805 schedule_bh(handler);
1808 is_alive("normal interrupt end");
1810 /* FIXME! Was it really for us? */
1814 static void recalibrate_floppy(void)
1817 debugt("recalibrate floppy:");
1819 do_floppy = recal_interrupt;
1820 output_byte(FD_RECALIBRATE);
1821 LAST_OUT(UNIT(current_drive));
1825 * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1827 static void reset_interrupt(void)
1830 debugt("reset interrupt:");
1832 result(); /* get the status ready for set_fdc */
1834 printk("reset set in interrupt, calling %p\n", cont->error);
1835 cont->error(); /* a reset just after a reset. BAD! */
1841 * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1842 * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1844 static void reset_fdc(void)
1846 unsigned long flags;
1848 do_floppy = reset_interrupt;
1852 /* Pseudo-DMA may intercept 'reset finished' interrupt. */
1853 /* Irrelevant for systems with true DMA (i386). */
1855 flags = claim_dma_lock();
1857 release_dma_lock(flags);
1859 if (FDCS->version >= FDC_82072A)
1860 fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
1862 fd_outb(FDCS->dor & ~0x04, FD_DOR);
1863 udelay(FD_RESET_DELAY);
1864 fd_outb(FDCS->dor, FD_DOR);
1868 static void show_floppy(void)
1873 printk("floppy driver state\n");
1874 printk("-------------------\n");
1875 printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",
1876 jiffies, interruptjiffies, jiffies - interruptjiffies,
1879 #ifdef FLOPPY_SANITY_CHECK
1880 printk("timeout_message=%s\n", timeout_message);
1881 printk("last output bytes:\n");
1882 for (i = 0; i < OLOGSIZE; i++)
1883 printk("%2x %2x %lu\n",
1884 output_log[(i + output_log_pos) % OLOGSIZE].data,
1885 output_log[(i + output_log_pos) % OLOGSIZE].status,
1886 output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1887 printk("last result at %lu\n", resultjiffies);
1888 printk("last redo_fd_request at %lu\n", lastredo);
1889 for (i = 0; i < resultsize; i++) {
1890 printk("%2x ", reply_buffer[i]);
1895 printk("status=%x\n", fd_inb(FD_STATUS));
1896 printk("fdc_busy=%lu\n", fdc_busy);
1898 printk("do_floppy=%p\n", do_floppy);
1899 if (floppy_work.pending)
1900 printk("floppy_work.func=%p\n", floppy_work.func);
1901 if (timer_pending(&fd_timer))
1902 printk("fd_timer.function=%p\n", fd_timer.function);
1903 if (timer_pending(&fd_timeout)) {
1904 printk("timer_function=%p\n", fd_timeout.function);
1905 printk("expires=%lu\n", fd_timeout.expires - jiffies);
1906 printk("now=%lu\n", jiffies);
1908 printk("cont=%p\n", cont);
1909 printk("current_req=%p\n", current_req);
1910 printk("command_status=%d\n", command_status);
1914 static void floppy_shutdown(unsigned long data)
1916 unsigned long flags;
1922 floppy_enable_hlt();
1924 flags = claim_dma_lock();
1926 release_dma_lock(flags);
1928 /* avoid dma going to a random drive after shutdown */
1931 DPRINT("floppy timeout called\n");
1935 cont->redo(); /* this will recall reset when needed */
1937 printk("no cont in shutdown!\n");
1938 process_fd_request();
1940 is_alive("floppy shutdown");
1943 /*typedef void (*timeout_fn)(unsigned long);*/
1945 /* start motor, check media-changed condition and write protection */
1946 static int start_motor(void (*function) (void))
1951 data = UNIT(current_drive);
1952 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1953 if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
1955 /* no read since this drive is running */
1956 DRS->first_read_date = 0;
1957 /* note motor start time if motor is not yet running */
1958 DRS->spinup_date = jiffies;
1959 data |= (0x10 << UNIT(current_drive));
1961 } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
1962 mask &= ~(0x10 << UNIT(current_drive));
1964 /* starts motor and selects floppy */
1965 del_timer(motor_off_timer + current_drive);
1966 set_dor(fdc, mask, data);
1968 /* wait_for_completion also schedules reset if needed. */
1969 return (fd_wait_for_completion(DRS->select_date + DP->select_delay,
1970 (timeout_fn) function));
1973 static void floppy_ready(void)
1976 if (start_motor(floppy_ready))
1982 if (DP->flags & FD_DEBUG) {
1983 DPRINT("calling disk change from floppy_ready\n");
1986 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1987 disk_change(current_drive) && !DP->select_delay)
1988 twaddle(); /* this clears the dcl on certain drive/controller
1991 #ifdef fd_chose_dma_mode
1992 if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1993 unsigned long flags = claim_dma_lock();
1994 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1995 release_dma_lock(flags);
1999 if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
2000 perpendicular_mode();
2001 fdc_specify(); /* must be done here because of hut, hlt ... */
2004 if ((raw_cmd->flags & FD_RAW_READ) ||
2005 (raw_cmd->flags & FD_RAW_WRITE))
2011 static void floppy_start(void)
2013 reschedule_timeout(current_reqD, "floppy start", 0);
2017 if (DP->flags & FD_DEBUG) {
2018 DPRINT("setting NEWCHANGE in floppy_start\n");
2021 SETF(FD_DISK_NEWCHANGE);
2026 * ========================================================================
2027 * here ends the bottom half. Exported routines are:
2028 * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
2029 * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
2030 * Initialization also uses output_byte, result, set_dor, floppy_interrupt
2032 * ========================================================================
2035 * General purpose continuations.
2036 * ==============================
2039 static void do_wakeup(void)
2041 reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
2043 command_status += 2;
2044 wake_up(&command_done);
2047 static struct cont_t wakeup_cont = {
2051 .done = (done_f) empty
2054 static struct cont_t intr_cont = {
2056 .redo = process_fd_request,
2058 .done = (done_f) empty
2061 static int wait_til_done(void (*handler) (void), int interruptible)
2065 schedule_bh(handler);
2067 if (command_status < 2 && NO_SIGNAL) {
2068 DECLARE_WAITQUEUE(wait, current);
2070 add_wait_queue(&command_done, &wait);
2072 set_current_state(interruptible ?
2073 TASK_INTERRUPTIBLE :
2074 TASK_UNINTERRUPTIBLE);
2076 if (command_status >= 2 || !NO_SIGNAL)
2079 is_alive("wait_til_done");
2084 set_current_state(TASK_RUNNING);
2085 remove_wait_queue(&command_done, &wait);
2088 if (command_status < 2) {
2096 command_status = FD_COMMAND_ERROR;
2097 if (command_status == FD_COMMAND_OKAY)
2101 command_status = FD_COMMAND_NONE;
2105 static void generic_done(int result)
2107 command_status = result;
2108 cont = &wakeup_cont;
2111 static void generic_success(void)
2116 static void generic_failure(void)
2121 static void success_and_wakeup(void)
2128 * formatting and rw support.
2129 * ==========================
2132 static int next_valid_format(void)
2136 probed_format = DRS->probed_format;
2138 if (probed_format >= 8 || !DP->autodetect[probed_format]) {
2139 DRS->probed_format = 0;
2142 if (floppy_type[DP->autodetect[probed_format]].sect) {
2143 DRS->probed_format = probed_format;
2150 static void bad_flp_intr(void)
2155 DRS->probed_format++;
2156 if (!next_valid_format())
2159 err_count = ++(*errors);
2160 INFBOUND(DRWE->badness, err_count);
2161 if (err_count > DP->max_errors.abort)
2163 if (err_count > DP->max_errors.reset)
2165 else if (err_count > DP->max_errors.recal)
2166 DRS->track = NEED_2_RECAL;
2169 static void set_floppy(int drive)
2171 int type = ITYPE(UDRS->fd_device);
2173 _floppy = floppy_type + type;
2175 _floppy = current_type[drive];
2179 * formatting support.
2180 * ===================
2182 static void format_interrupt(void)
2184 switch (interpret_errors()) {
2195 #define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
2196 #define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80) >>1))
2197 #define CT(x) ((x) | 0xc0)
2198 static void setup_format_params(int track)
2201 unsigned char track, head, sect, size;
2202 } *here = (struct fparm *)floppy_track_buffer;
2204 int count, head_shift, track_shift;
2206 raw_cmd = &default_raw_cmd;
2207 raw_cmd->track = track;
2209 raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2210 FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2211 raw_cmd->rate = _floppy->rate & 0x43;
2212 raw_cmd->cmd_count = NR_F;
2213 COMMAND = FM_MODE(_floppy, FD_FORMAT);
2214 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2215 F_SIZECODE = FD_SIZECODE(_floppy);
2216 F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2217 F_GAP = _floppy->fmt_gap;
2218 F_FILL = FD_FILL_BYTE;
2220 raw_cmd->kernel_data = floppy_track_buffer;
2221 raw_cmd->length = 4 * F_SECT_PER_TRACK;
2223 /* allow for about 30ms for data transport per track */
2224 head_shift = (F_SECT_PER_TRACK + 5) / 6;
2226 /* a ``cylinder'' is two tracks plus a little stepping time */
2227 track_shift = 2 * head_shift + 3;
2229 /* position of logical sector 1 on this track */
2230 n = (track_shift * format_req.track + head_shift * format_req.head)
2233 /* determine interleave */
2235 if (_floppy->fmt_gap < 0x22)
2238 /* initialize field */
2239 for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2240 here[count].track = format_req.track;
2241 here[count].head = format_req.head;
2242 here[count].sect = 0;
2243 here[count].size = F_SIZECODE;
2245 /* place logical sectors */
2246 for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2247 here[n].sect = count;
2248 n = (n + il) % F_SECT_PER_TRACK;
2249 if (here[n].sect) { /* sector busy, find next free sector */
2251 if (n >= F_SECT_PER_TRACK) {
2252 n -= F_SECT_PER_TRACK;
2253 while (here[n].sect)
2258 if (_floppy->stretch & FD_ZEROBASED) {
2259 for (count = 0; count < F_SECT_PER_TRACK; count++)
2264 static void redo_format(void)
2267 setup_format_params(format_req.track << STRETCH(_floppy));
2270 debugt("queue format request");
2274 static struct cont_t format_cont = {
2275 .interrupt = format_interrupt,
2276 .redo = redo_format,
2277 .error = bad_flp_intr,
2278 .done = generic_done
2281 static int do_format(int drive, struct format_descr *tmp_format_req)
2288 _floppy->track > DP->tracks ||
2289 tmp_format_req->track >= _floppy->track ||
2290 tmp_format_req->head >= _floppy->head ||
2291 (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2292 !_floppy->fmt_gap) {
2293 process_fd_request();
2296 format_req = *tmp_format_req;
2298 cont = &format_cont;
2299 errors = &format_errors;
2301 process_fd_request();
2306 * Buffer read/write and support
2307 * =============================
2310 static void floppy_end_request(struct request *req, int uptodate)
2312 unsigned int nr_sectors = current_count_sectors;
2314 /* current_count_sectors can be zero if transfer failed */
2316 nr_sectors = req->current_nr_sectors;
2317 if (end_that_request_first(req, uptodate, nr_sectors))
2319 add_disk_randomness(req->rq_disk);
2320 floppy_off((long)req->rq_disk->private_data);
2321 blkdev_dequeue_request(req);
2322 end_that_request_last(req);
2324 /* We're done with the request */
2328 /* new request_done. Can handle physical sectors which are smaller than a
2330 static void request_done(int uptodate)
2332 struct request_queue *q = floppy_queue;
2333 struct request *req = current_req;
2334 unsigned long flags;
2338 reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
2341 printk("floppy.c: no request in request_done\n");
2346 /* maintain values for invalidation on geometry
2348 block = current_count_sectors + req->sector;
2349 INFBOUND(DRS->maxblock, block);
2350 if (block > _floppy->sect)
2353 /* unlock chained buffers */
2354 spin_lock_irqsave(q->queue_lock, flags);
2355 floppy_end_request(req, 1);
2356 spin_unlock_irqrestore(q->queue_lock, flags);
2358 if (rq_data_dir(req) == WRITE) {
2359 /* record write error information */
2360 DRWE->write_errors++;
2361 if (DRWE->write_errors == 1) {
2362 DRWE->first_error_sector = req->sector;
2363 DRWE->first_error_generation = DRS->generation;
2365 DRWE->last_error_sector = req->sector;
2366 DRWE->last_error_generation = DRS->generation;
2368 spin_lock_irqsave(q->queue_lock, flags);
2369 floppy_end_request(req, 0);
2370 spin_unlock_irqrestore(q->queue_lock, flags);
2374 /* Interrupt handler evaluating the result of the r/w operation */
2375 static void rw_interrupt(void)
2377 int nr_sectors, ssize, eoc, heads;
2380 /* some Toshiba floppy controllers occasionnally seem to
2381 * return bogus interrupts after read/write operations, which
2382 * can be recognized by a bad head number (>= 2) */
2386 if (!DRS->first_read_date)
2387 DRS->first_read_date = jiffies;
2402 nr_sectors = (((R_TRACK - TRACK) * heads +
2403 R_HEAD - HEAD) * SECT_PER_TRACK +
2404 R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2406 #ifdef FLOPPY_SANITY_CHECK
2407 if (nr_sectors / ssize >
2408 (in_sector_offset + current_count_sectors + ssize - 1) / ssize) {
2409 DPRINT("long rw: %x instead of %lx\n",
2410 nr_sectors, current_count_sectors);
2411 printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
2412 printk("rh=%d h=%d\n", R_HEAD, HEAD);
2413 printk("rt=%d t=%d\n", R_TRACK, TRACK);
2414 printk("heads=%d eoc=%d\n", heads, eoc);
2415 printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
2417 printk("in_sector_offset=%d\n", in_sector_offset);
2421 nr_sectors -= in_sector_offset;
2422 INFBOUND(nr_sectors, 0);
2423 SUPBOUND(current_count_sectors, nr_sectors);
2425 switch (interpret_errors()) {
2430 if (!current_count_sectors) {
2437 if (!current_count_sectors) {
2441 current_type[current_drive] = _floppy;
2442 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2447 if (DP->flags & FTD_MSG)
2448 DPRINT("Auto-detected floppy type %s in fd%d\n",
2449 _floppy->name, current_drive);
2450 current_type[current_drive] = _floppy;
2451 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2455 if (CT(COMMAND) != FD_READ ||
2456 raw_cmd->kernel_data == current_req->buffer) {
2457 /* transfer directly from buffer */
2459 } else if (CT(COMMAND) == FD_READ) {
2460 buffer_track = raw_cmd->track;
2461 buffer_drive = current_drive;
2462 INFBOUND(buffer_max, nr_sectors + fsector_t);
2467 /* Compute maximal contiguous buffer size. */
2468 static int buffer_chain_size(void)
2475 base = bio_data(current_req->bio);
2478 rq_for_each_bio(bio, current_req) {
2479 bio_for_each_segment(bv, bio, i) {
2480 if (page_address(bv->bv_page) + bv->bv_offset !=
2491 /* Compute the maximal transfer size */
2492 static int transfer_size(int ssize, int max_sector, int max_size)
2494 SUPBOUND(max_sector, fsector_t + max_size);
2497 max_sector -= (max_sector % _floppy->sect) % ssize;
2499 /* transfer size, beginning not aligned */
2500 current_count_sectors = max_sector - fsector_t;
2506 * Move data from/to the track buffer to/from the buffer cache.
2508 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2510 int remaining; /* number of transferred 512-byte sectors */
2513 char *buffer, *dma_buffer;
2516 max_sector = transfer_size(ssize,
2517 min(max_sector, max_sector_2),
2518 current_req->nr_sectors);
2520 if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2521 buffer_max > fsector_t + current_req->nr_sectors)
2522 current_count_sectors = min_t(int, buffer_max - fsector_t,
2523 current_req->nr_sectors);
2525 remaining = current_count_sectors << 9;
2526 #ifdef FLOPPY_SANITY_CHECK
2527 if ((remaining >> 9) > current_req->nr_sectors &&
2528 CT(COMMAND) == FD_WRITE) {
2529 DPRINT("in copy buffer\n");
2530 printk("current_count_sectors=%ld\n", current_count_sectors);
2531 printk("remaining=%d\n", remaining >> 9);
2532 printk("current_req->nr_sectors=%ld\n",
2533 current_req->nr_sectors);
2534 printk("current_req->current_nr_sectors=%u\n",
2535 current_req->current_nr_sectors);
2536 printk("max_sector=%d\n", max_sector);
2537 printk("ssize=%d\n", ssize);
2541 buffer_max = max(max_sector, buffer_max);
2543 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2545 size = current_req->current_nr_sectors << 9;
2547 rq_for_each_bio(bio, current_req) {
2548 bio_for_each_segment(bv, bio, i) {
2553 SUPBOUND(size, remaining);
2555 buffer = page_address(bv->bv_page) + bv->bv_offset;
2556 #ifdef FLOPPY_SANITY_CHECK
2557 if (dma_buffer + size >
2558 floppy_track_buffer + (max_buffer_sectors << 10) ||
2559 dma_buffer < floppy_track_buffer) {
2560 DPRINT("buffer overrun in copy buffer %d\n",
2561 (int)((floppy_track_buffer -
2563 printk("fsector_t=%d buffer_min=%d\n",
2564 fsector_t, buffer_min);
2565 printk("current_count_sectors=%ld\n",
2566 current_count_sectors);
2567 if (CT(COMMAND) == FD_READ)
2569 if (CT(COMMAND) == FD_WRITE)
2573 if (((unsigned long)buffer) % 512)
2574 DPRINT("%p buffer not aligned\n", buffer);
2576 if (CT(COMMAND) == FD_READ)
2577 memcpy(buffer, dma_buffer, size);
2579 memcpy(dma_buffer, buffer, size);
2585 #ifdef FLOPPY_SANITY_CHECK
2588 max_sector -= remaining >> 9;
2589 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2595 static inline int check_dma_crossing(char *start,
2596 unsigned long length, char *message)
2598 if (CROSS_64KB(start, length)) {
2599 printk("DMA xfer crosses 64KB boundary in %s %p-%p\n",
2600 message, start, start + length);
2607 /* work around a bug in pseudo DMA
2608 * (on some FDCs) pseudo DMA does not stop when the CPU stops
2609 * sending data. Hence we need a different way to signal the
2610 * transfer length: We use SECT_PER_TRACK. Unfortunately, this
2611 * does not work with MT, hence we can only transfer one head at
2614 static void virtualdmabug_workaround(void)
2616 int hard_sectors, end_sector;
2618 if (CT(COMMAND) == FD_WRITE) {
2619 COMMAND &= ~0x80; /* switch off multiple track mode */
2621 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2622 end_sector = SECTOR + hard_sectors - 1;
2623 #ifdef FLOPPY_SANITY_CHECK
2624 if (end_sector > SECT_PER_TRACK) {
2625 printk("too many sectors %d > %d\n",
2626 end_sector, SECT_PER_TRACK);
2630 SECT_PER_TRACK = end_sector; /* make sure SECT_PER_TRACK points
2631 * to end of transfer */
2636 * Formulate a read/write request.
2637 * this routine decides where to load the data (directly to buffer, or to
2638 * tmp floppy area), how much data to load (the size of the buffer, the whole
2639 * track, or a single sector)
2640 * All floppy_track_buffer handling goes in here. If we ever add track buffer
2641 * allocation on the fly, it should be done here. No other part should need
2645 static int make_raw_rw_request(void)
2647 int aligned_sector_t;
2648 int max_sector, max_size, tracksize, ssize;
2650 if (max_buffer_sectors == 0) {
2651 printk("VFS: Block I/O scheduled on unopened device\n");
2655 set_fdc((long)current_req->rq_disk->private_data);
2657 raw_cmd = &default_raw_cmd;
2658 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2660 raw_cmd->cmd_count = NR_RW;
2661 if (rq_data_dir(current_req) == READ) {
2662 raw_cmd->flags |= FD_RAW_READ;
2663 COMMAND = FM_MODE(_floppy, FD_READ);
2664 } else if (rq_data_dir(current_req) == WRITE) {
2665 raw_cmd->flags |= FD_RAW_WRITE;
2666 COMMAND = FM_MODE(_floppy, FD_WRITE);
2668 DPRINT("make_raw_rw_request: unknown command\n");
2672 max_sector = _floppy->sect * _floppy->head;
2674 TRACK = (int)current_req->sector / max_sector;
2675 fsector_t = (int)current_req->sector % max_sector;
2676 if (_floppy->track && TRACK >= _floppy->track) {
2677 if (current_req->current_nr_sectors & 1) {
2678 current_count_sectors = 1;
2683 HEAD = fsector_t / _floppy->sect;
2685 if (((_floppy->stretch & (FD_SWAPSIDES | FD_ZEROBASED)) ||
2686 TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
2687 max_sector = _floppy->sect;
2689 /* 2M disks have phantom sectors on the first track */
2690 if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2691 max_sector = 2 * _floppy->sect / 3;
2692 if (fsector_t >= max_sector) {
2693 current_count_sectors =
2694 min_t(int, _floppy->sect - fsector_t,
2695 current_req->nr_sectors);
2700 SIZECODE = FD_SIZECODE(_floppy);
2701 raw_cmd->rate = _floppy->rate & 0x43;
2702 if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2709 raw_cmd->track = TRACK << STRETCH(_floppy);
2710 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2713 SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2714 SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
2715 ((_floppy->stretch & FD_ZEROBASED) ? 0 : 1);
2717 /* tracksize describes the size which can be filled up with sectors
2720 tracksize = _floppy->sect - _floppy->sect % ssize;
2721 if (tracksize < _floppy->sect) {
2723 if (tracksize <= fsector_t % _floppy->sect)
2726 /* if we are beyond tracksize, fill up using smaller sectors */
2727 while (tracksize <= fsector_t % _floppy->sect) {
2728 while (tracksize + ssize > _floppy->sect) {
2736 max_sector = HEAD * _floppy->sect + tracksize;
2737 } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2738 max_sector = _floppy->sect;
2739 } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2740 /* for virtual DMA bug workaround */
2741 max_sector = _floppy->sect;
2744 in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2745 aligned_sector_t = fsector_t - in_sector_offset;
2746 max_size = current_req->nr_sectors;
2747 if ((raw_cmd->track == buffer_track) &&
2748 (current_drive == buffer_drive) &&
2749 (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2750 /* data already in track buffer */
2751 if (CT(COMMAND) == FD_READ) {
2752 copy_buffer(1, max_sector, buffer_max);
2755 } else if (in_sector_offset || current_req->nr_sectors < ssize) {
2756 if (CT(COMMAND) == FD_WRITE) {
2757 if (fsector_t + current_req->nr_sectors > ssize &&
2758 fsector_t + current_req->nr_sectors < ssize + ssize)
2759 max_size = ssize + ssize;
2763 raw_cmd->flags &= ~FD_RAW_WRITE;
2764 raw_cmd->flags |= FD_RAW_READ;
2765 COMMAND = FM_MODE(_floppy, FD_READ);
2766 } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2767 unsigned long dma_limit;
2768 int direct, indirect;
2771 transfer_size(ssize, max_sector,
2772 max_buffer_sectors * 2) - fsector_t;
2775 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2776 * on a 64 bit machine!
2778 max_size = buffer_chain_size();
2781 ((unsigned long)current_req->buffer)) >> 9;
2782 if ((unsigned long)max_size > dma_limit) {
2783 max_size = dma_limit;
2785 /* 64 kb boundaries */
2786 if (CROSS_64KB(current_req->buffer, max_size << 9))
2788 ((unsigned long)current_req->buffer) %
2790 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2792 * We try to read tracks, but if we get too many errors, we
2793 * go back to reading just one sector at a time.
2795 * This means we should be able to read a sector even if there
2796 * are other bad sectors on this track.
2799 (indirect * 2 > direct * 3 &&
2800 *errors < DP->max_errors.read_track &&
2801 /*!TESTF(FD_NEED_TWADDLE) && */
2803 || (DP->read_track & (1 << DRS->probed_format)))))) {
2804 max_size = current_req->nr_sectors;
2806 raw_cmd->kernel_data = current_req->buffer;
2807 raw_cmd->length = current_count_sectors << 9;
2808 if (raw_cmd->length == 0) {
2810 ("zero dma transfer attempted from make_raw_request\n");
2811 DPRINT("indirect=%d direct=%d fsector_t=%d",
2812 indirect, direct, fsector_t);
2815 /* check_dma_crossing(raw_cmd->kernel_data,
2817 "end of make_raw_request [1]");*/
2819 virtualdmabug_workaround();
2824 if (CT(COMMAND) == FD_READ)
2825 max_size = max_sector; /* unbounded */
2827 /* claim buffer track if needed */
2828 if (buffer_track != raw_cmd->track || /* bad track */
2829 buffer_drive != current_drive || /* bad drive */
2830 fsector_t > buffer_max ||
2831 fsector_t < buffer_min ||
2832 ((CT(COMMAND) == FD_READ ||
2833 (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
2834 max_sector > 2 * max_buffer_sectors + buffer_min &&
2835 max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
2836 /* not enough space */
2839 buffer_drive = current_drive;
2840 buffer_max = buffer_min = aligned_sector_t;
2842 raw_cmd->kernel_data = floppy_track_buffer +
2843 ((aligned_sector_t - buffer_min) << 9);
2845 if (CT(COMMAND) == FD_WRITE) {
2846 /* copy write buffer to track buffer.
2847 * if we get here, we know that the write
2848 * is either aligned or the data already in the buffer
2849 * (buffer will be overwritten) */
2850 #ifdef FLOPPY_SANITY_CHECK
2851 if (in_sector_offset && buffer_track == -1)
2852 DPRINT("internal error offset !=0 on write\n");
2854 buffer_track = raw_cmd->track;
2855 buffer_drive = current_drive;
2856 copy_buffer(ssize, max_sector,
2857 2 * max_buffer_sectors + buffer_min);
2859 transfer_size(ssize, max_sector,
2860 2 * max_buffer_sectors + buffer_min -
2863 /* round up current_count_sectors to get dma xfer size */
2864 raw_cmd->length = in_sector_offset + current_count_sectors;
2865 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2866 raw_cmd->length <<= 9;
2867 #ifdef FLOPPY_SANITY_CHECK
2868 /*check_dma_crossing(raw_cmd->kernel_data, raw_cmd->length,
2869 "end of make_raw_request"); */
2870 if ((raw_cmd->length < current_count_sectors << 9) ||
2871 (raw_cmd->kernel_data != current_req->buffer &&
2872 CT(COMMAND) == FD_WRITE &&
2873 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2874 aligned_sector_t < buffer_min)) ||
2875 raw_cmd->length % (128 << SIZECODE) ||
2876 raw_cmd->length <= 0 || current_count_sectors <= 0) {
2877 DPRINT("fractionary current count b=%lx s=%lx\n",
2878 raw_cmd->length, current_count_sectors);
2879 if (raw_cmd->kernel_data != current_req->buffer)
2880 printk("addr=%d, length=%ld\n",
2881 (int)((raw_cmd->kernel_data -
2882 floppy_track_buffer) >> 9),
2883 current_count_sectors);
2884 printk("st=%d ast=%d mse=%d msi=%d\n",
2885 fsector_t, aligned_sector_t, max_sector, max_size);
2886 printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2887 printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2888 COMMAND, SECTOR, HEAD, TRACK);
2889 printk("buffer drive=%d\n", buffer_drive);
2890 printk("buffer track=%d\n", buffer_track);
2891 printk("buffer_min=%d\n", buffer_min);
2892 printk("buffer_max=%d\n", buffer_max);
2896 if (raw_cmd->kernel_data != current_req->buffer) {
2897 if (raw_cmd->kernel_data < floppy_track_buffer ||
2898 current_count_sectors < 0 ||
2899 raw_cmd->length < 0 ||
2900 raw_cmd->kernel_data + raw_cmd->length >
2901 floppy_track_buffer + (max_buffer_sectors << 10)) {
2902 DPRINT("buffer overrun in schedule dma\n");
2903 printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
2904 fsector_t, buffer_min, raw_cmd->length >> 9);
2905 printk("current_count_sectors=%ld\n",
2906 current_count_sectors);
2907 if (CT(COMMAND) == FD_READ)
2909 if (CT(COMMAND) == FD_WRITE)
2913 } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
2914 current_count_sectors > current_req->nr_sectors) {
2915 DPRINT("buffer overrun in direct transfer\n");
2917 } else if (raw_cmd->length < current_count_sectors << 9) {
2918 DPRINT("more sectors than bytes\n");
2919 printk("bytes=%ld\n", raw_cmd->length >> 9);
2920 printk("sectors=%ld\n", current_count_sectors);
2922 if (raw_cmd->length == 0) {
2923 DPRINT("zero dma transfer attempted from make_raw_request\n");
2928 virtualdmabug_workaround();
2932 static void redo_fd_request(void)
2934 #define REPEAT {request_done(0); continue; }
2939 if (current_drive < N_DRIVE)
2940 floppy_off(current_drive);
2944 struct request *req;
2946 spin_lock_irq(floppy_queue->queue_lock);
2947 req = elv_next_request(floppy_queue);
2948 spin_unlock_irq(floppy_queue->queue_lock);
2956 drive = (long)current_req->rq_disk->private_data;
2958 reschedule_timeout(current_reqD, "redo fd request", 0);
2961 raw_cmd = &default_raw_cmd;
2963 if (start_motor(redo_fd_request))
2965 disk_change(current_drive);
2966 if (test_bit(current_drive, &fake_change) ||
2967 TESTF(FD_DISK_CHANGED)) {
2968 DPRINT("disk absent or changed during operation\n");
2971 if (!_floppy) { /* Autodetection */
2973 DRS->probed_format = 0;
2974 if (next_valid_format()) {
2975 DPRINT("no autodetectable formats\n");
2982 floppy_type + DP->autodetect[DRS->probed_format];
2985 errors = &(current_req->errors);
2986 tmp = make_raw_rw_request();
2992 if (TESTF(FD_NEED_TWADDLE))
2994 schedule_bh(floppy_start);
2996 debugt("queue fd request");
3003 static struct cont_t rw_cont = {
3004 .interrupt = rw_interrupt,
3005 .redo = redo_fd_request,
3006 .error = bad_flp_intr,
3007 .done = request_done
3010 static void process_fd_request(void)
3013 schedule_bh(redo_fd_request);
3016 static void do_fd_request(request_queue_t * q)
3018 if (max_buffer_sectors == 0) {
3019 printk("VFS: do_fd_request called on non-open device\n");
3023 if (usage_count == 0) {
3024 printk("warning: usage count=0, current_req=%p exiting\n",
3026 printk("sect=%ld flags=%lx\n", (long)current_req->sector,
3027 current_req->flags);
3030 if (test_bit(0, &fdc_busy)) {
3031 /* fdc busy, this new request will be treated when the
3032 current one is done */
3033 is_alive("do fd request, old request running");
3036 lock_fdc(MAXTIMEOUT, 0);
3037 process_fd_request();
3038 is_alive("do fd request");
3041 static struct cont_t poll_cont = {
3042 .interrupt = success_and_wakeup,
3043 .redo = floppy_ready,
3044 .error = generic_failure,
3045 .done = generic_done
3048 static int poll_drive(int interruptible, int flag)
3051 /* no auto-sense, just clear dcl */
3052 raw_cmd = &default_raw_cmd;
3053 raw_cmd->flags = flag;
3055 raw_cmd->cmd_count = 0;
3058 if (DP->flags & FD_DEBUG) {
3059 DPRINT("setting NEWCHANGE in poll_drive\n");
3062 SETF(FD_DISK_NEWCHANGE);
3068 * User triggered reset
3069 * ====================
3072 static void reset_intr(void)
3074 printk("weird, reset interrupt called\n");
3077 static struct cont_t reset_cont = {
3078 .interrupt = reset_intr,
3079 .redo = success_and_wakeup,
3080 .error = generic_failure,
3081 .done = generic_done
3084 static int user_reset_fdc(int drive, int arg, int interruptible)
3089 LOCK_FDC(drive, interruptible);
3090 if (arg == FD_RESET_ALWAYS)
3096 process_fd_request();
3101 * Misc Ioctl's and support
3102 * ========================
3104 static inline int fd_copyout(void *param, const void *address,
3107 return copy_to_user(param, address, size) ? -EFAULT : 0;
3110 static inline int fd_copyin(void *param, void *address, unsigned long size)
3112 return copy_from_user(address, param, size) ? -EFAULT : 0;
3115 #define _COPYOUT(x) (copy_to_user((void *)param, &(x), sizeof(x)) ? -EFAULT : 0)
3116 #define _COPYIN(x) (copy_from_user(&(x), (void *)param, sizeof(x)) ? -EFAULT : 0)
3118 #define COPYOUT(x) ECALL(_COPYOUT(x))
3119 #define COPYIN(x) ECALL(_COPYIN(x))
3121 static inline const char *drive_name(int type, int drive)
3123 struct floppy_struct *floppy;
3126 floppy = floppy_type + type;
3128 if (UDP->native_format)
3129 floppy = floppy_type + UDP->native_format;
3134 return floppy->name;
3140 static void raw_cmd_done(int flag)
3145 raw_cmd->flags |= FD_RAW_FAILURE;
3146 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3148 raw_cmd->reply_count = inr;
3149 if (raw_cmd->reply_count > MAX_REPLIES)
3150 raw_cmd->reply_count = 0;
3151 for (i = 0; i < raw_cmd->reply_count; i++)
3152 raw_cmd->reply[i] = reply_buffer[i];
3154 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3155 unsigned long flags;
3156 flags = claim_dma_lock();
3157 raw_cmd->length = fd_get_dma_residue();
3158 release_dma_lock(flags);
3161 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3162 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3163 raw_cmd->flags |= FD_RAW_FAILURE;
3165 if (disk_change(current_drive))
3166 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3168 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3169 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3170 motor_off_callback(current_drive);
3172 if (raw_cmd->next &&
3173 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3174 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3175 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3176 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3177 raw_cmd = raw_cmd->next;
3184 static struct cont_t raw_cmd_cont = {
3185 .interrupt = success_and_wakeup,
3186 .redo = floppy_start,
3187 .error = generic_failure,
3188 .done = raw_cmd_done
3191 static inline int raw_cmd_copyout(int cmd, char *param,
3192 struct floppy_raw_cmd *ptr)
3198 param += sizeof(struct floppy_raw_cmd);
3199 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3200 if (ptr->length >= 0
3201 && ptr->length <= ptr->buffer_length)
3203 (ptr->data, ptr->kernel_data,
3204 ptr->buffer_length - ptr->length));
3211 static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3213 struct floppy_raw_cmd *next, *this;
3218 if (this->buffer_length) {
3219 fd_dma_mem_free((unsigned long)this->kernel_data,
3220 this->buffer_length);
3221 this->buffer_length = 0;
3229 static inline int raw_cmd_copyin(int cmd, char *param,
3230 struct floppy_raw_cmd **rcmd)
3232 struct floppy_raw_cmd *ptr;
3238 ptr = (struct floppy_raw_cmd *)
3239 kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3245 ptr->buffer_length = 0;
3246 param += sizeof(struct floppy_raw_cmd);
3247 if (ptr->cmd_count > 33)
3248 /* the command may now also take up the space
3249 * initially intended for the reply & the
3250 * reply count. Needed for long 82078 commands
3251 * such as RESTORE, which takes ... 17 command
3252 * bytes. Murphy's law #137: When you reserve
3253 * 16 bytes for a structure, you'll one day
3254 * discover that you really need 17...
3258 for (i = 0; i < 16; i++)
3260 ptr->resultcode = 0;
3261 ptr->kernel_data = 0;
3263 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3264 if (ptr->length <= 0)
3267 (char *)fd_dma_mem_alloc(ptr->length);
3268 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3269 if (!ptr->kernel_data)
3271 ptr->buffer_length = ptr->length;
3273 if (ptr->flags & FD_RAW_WRITE)
3274 ECALL(fd_copyin(ptr->data, ptr->kernel_data,
3276 rcmd = &(ptr->next);
3277 if (!(ptr->flags & FD_RAW_MORE))
3283 static int raw_cmd_ioctl(int cmd, void *param)
3285 int drive, ret, ret2;
3286 struct floppy_raw_cmd *my_raw_cmd;
3288 if (FDCS->rawcmd <= 1)
3290 for (drive = 0; drive < N_DRIVE; drive++) {
3291 if (FDC(drive) != fdc)
3293 if (drive == current_drive) {
3294 if (UDRS->fd_ref > 1) {
3298 } else if (UDRS->fd_ref) {
3307 ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3309 raw_cmd_free(&my_raw_cmd);
3313 raw_cmd = my_raw_cmd;
3314 cont = &raw_cmd_cont;
3315 ret = wait_til_done(floppy_start, 1);
3317 if (DP->flags & FD_DEBUG) {
3318 DPRINT("calling disk change from raw_cmd ioctl\n");
3322 if (ret != -EINTR && FDCS->reset)
3325 DRS->track = NO_TRACK;
3327 ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3330 raw_cmd_free(&my_raw_cmd);
3334 static int invalidate_drive(struct block_device *bdev)
3336 /* invalidate the buffer track to force a reread */
3337 set_bit((long)bdev->bd_disk->private_data, &fake_change);
3338 process_fd_request();
3339 check_disk_change(bdev);
3343 static inline void clear_write_error(int drive)
3348 static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
3349 int drive, int type, struct block_device *bdev)
3353 /* sanity checking for parameters. */
3356 g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3357 /* check if reserved bits are set */
3358 (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_ZEROBASED)) != 0)
3361 if (!capable(CAP_SYS_ADMIN))
3365 floppy_type[type] = *g;
3366 floppy_type[type].name = "user format";
3367 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3368 floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3369 floppy_type[type].size + 1;
3370 process_fd_request();
3371 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3372 struct block_device *bdev = opened_bdev[cnt];
3373 if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3375 __invalidate_device(bdev, 0);
3381 if (cmd != FDDEFPRM)
3382 /* notice a disk change immediately, else
3383 * we lose our settings immediately*/
3384 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3385 oldStretch = g->stretch;
3386 user_params[drive] = *g;
3387 if (buffer_drive == drive)
3388 SUPBOUND(buffer_max, user_params[drive].sect);
3389 current_type[drive] = &user_params[drive];
3390 floppy_sizes[drive] = user_params[drive].size;
3391 if (cmd == FDDEFPRM)
3392 DRS->keep_data = -1;
3395 /* invalidation. Invalidate only when needed, i.e.
3396 * when there are already sectors in the buffer cache
3397 * whose number will change. This is useful, because
3398 * mtools often changes the geometry of the disk after
3399 * looking at the boot block */
3400 if (DRS->maxblock > user_params[drive].sect ||
3402 ((user_params[drive].sect ^ oldStretch) &
3403 (FD_SWAPSIDES | FD_ZEROBASED)))
3404 invalidate_drive(bdev);
3406 process_fd_request();
3411 /* handle obsolete ioctl's */
3412 static int ioctl_table[] = {
3440 static inline int normalize_ioctl(int *cmd, int *size)
3444 for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3445 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3446 *size = _IOC_SIZE(*cmd);
3447 *cmd = ioctl_table[i];
3448 if (*size > _IOC_SIZE(*cmd)) {
3449 printk("ioctl not yet supported\n");
3458 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3461 *g = &floppy_type[type];
3464 CALL(poll_drive(0, 0));
3465 process_fd_request();
3466 *g = current_type[drive];
3473 static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
3474 unsigned long param)
3476 #define FD_IOCTL_ALLOWED ((filp) && (filp)->private_data)
3477 #define OUT(c,x) case c: outparam = (const char *) (x); break
3478 #define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
3480 int drive = (long)inode->i_bdev->bd_disk->private_data;
3481 int i, type = ITYPE(UDRS->fd_device);
3485 struct floppy_struct g; /* geometry */
3486 struct format_descr f;
3487 struct floppy_max_errors max_errors;
3488 struct floppy_drive_params dp;
3489 } inparam; /* parameters coming from user space */
3490 const char *outparam; /* parameters passed back to user space */
3492 /* convert compatibility eject ioctls into floppy eject ioctl.
3493 * We do this in order to provide a means to eject floppy disks before
3494 * installing the new fdutils package */
3495 if (cmd == CDROMEJECT || /* CD-ROM eject */
3496 cmd == 0x6470 /* SunOS floppy eject */ ) {
3497 DPRINT("obsolete eject ioctl\n");
3498 DPRINT("please use floppycontrol --eject\n");
3502 /* generic block device ioctls */
3504 /* the following have been inspired by the corresponding
3505 * code for other block devices. */
3506 struct floppy_struct *g;
3509 struct hd_geometry loc;
3510 ECALL(get_floppy_geometry(drive, type, &g));
3511 loc.heads = g->head;
3512 loc.sectors = g->sect;
3513 loc.cylinders = g->track;
3515 return _COPYOUT(loc);
3519 /* convert the old style command into a new style command */
3520 if ((cmd & 0xff00) == 0x0200) {
3521 ECALL(normalize_ioctl(&cmd, &size));
3525 /* permission checks */
3526 if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
3527 ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3531 CLEARSTRUCT(&inparam);
3532 if (_IOC_DIR(cmd) & _IOC_WRITE)
3533 ECALL(fd_copyin((void *)param, &inparam, size))
3537 if (UDRS->fd_ref != 1)
3538 /* somebody else has this drive open */
3542 /* do the actual eject. Fails on
3543 * non-Sparc architectures */
3544 ret = fd_eject(UNIT(drive));
3546 USETF(FD_DISK_CHANGED);
3548 process_fd_request();
3552 current_type[drive] = NULL;
3553 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3554 UDRS->keep_data = 0;
3555 return invalidate_drive(inode->i_bdev);
3558 return set_geometry(cmd, &inparam.g,
3559 drive, type, inode->i_bdev);
3561 ECALL(get_floppy_geometry(drive, type,
3562 (struct floppy_struct **)
3567 UDP->flags |= FTD_MSG;
3570 UDP->flags &= ~FTD_MSG;
3575 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3577 process_fd_request();
3578 if (ret & FD_VERIFY)
3580 if (!(ret & FD_DISK_WRITABLE))
3584 if (UDRS->fd_ref != 1)
3586 return do_format(drive, &inparam.f);
3590 return invalidate_drive(inode->i_bdev);
3592 case FDSETEMSGTRESH:
3593 UDP->max_errors.reporting =
3594 (unsigned short)(param & 0x0f);
3596 OUT(FDGETMAXERRS, &UDP->max_errors);
3597 IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
3600 outparam = drive_name(type, drive);
3601 SUPBOUND(size, strlen(outparam) + 1);
3604 IN(FDSETDRVPRM, UDP, dp);
3605 OUT(FDGETDRVPRM, UDP);
3609 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3610 process_fd_request();
3612 OUT(FDGETDRVSTAT, UDRS);
3615 return user_reset_fdc(drive, (int)param, 1);
3617 OUT(FDGETFDCSTAT, UFDCS);
3622 OUT(FDWERRORGET, UDRWE);
3629 CALL(i = raw_cmd_ioctl(cmd, (void *)param));
3630 process_fd_request();
3636 process_fd_request();
3643 if (_IOC_DIR(cmd) & _IOC_READ)
3644 return fd_copyout((void *)param, outparam, size);
3651 static void __init config_types(void)
3656 /* read drive info out of physical CMOS */
3659 UDP->cmos = FLOPPY0_TYPE;
3661 if (!UDP->cmos && FLOPPY1_TYPE)
3662 UDP->cmos = FLOPPY1_TYPE;
3665 /* additional physical CMOS drive detection should go here */
3667 for (drive = 0; drive < N_DRIVE; drive++) {
3668 unsigned int type = UDP->cmos;
3669 struct floppy_drive_params *params;
3670 const char *name = NULL;
3671 static char temparea[32];
3673 if (type < NUMBER(default_drive_params)) {
3674 params = &default_drive_params[type].params;
3676 name = default_drive_params[type].name;
3677 allowed_drive_mask |= 1 << drive;
3679 allowed_drive_mask &= ~(1 << drive);
3681 params = &default_drive_params[0].params;
3682 sprintf(temparea, "unknown type %d (usb?)", type);
3686 const char *prepend = ",";
3688 prepend = KERN_INFO "Floppy drive(s):";
3691 printk("%s fd%d is %s", prepend, drive, name);
3692 register_devfs_entries(drive);
3700 static int floppy_release(struct inode *inode, struct file *filp)
3702 int drive = (long)inode->i_bdev->bd_disk->private_data;
3705 if (UDRS->fd_ref < 0)
3707 else if (!UDRS->fd_ref--) {
3708 DPRINT("floppy_release with fd_ref == 0");
3712 opened_bdev[drive] = NULL;
3713 floppy_release_irq_and_dma();
3719 * floppy_open check for aliasing (/dev/fd0 can be the same as
3720 * /dev/PS0 etc), and disallows simultaneous access to the same
3721 * drive with different device numbers.
3723 static int floppy_open(struct inode *inode, struct file *filp)
3725 int drive = (long)inode->i_bdev->bd_disk->private_data;
3731 filp->private_data = (void *)0;
3733 old_dev = UDRS->fd_device;
3734 if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
3737 if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
3738 USETF(FD_DISK_CHANGED);
3742 if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
3745 if (floppy_grab_irq_and_dma())
3748 if (filp->f_flags & O_EXCL)
3753 opened_bdev[drive] = inode->i_bdev;
3757 if (!floppy_track_buffer) {
3758 /* if opening an ED drive, reserve a big buffer,
3759 * else reserve a small one */
3760 if ((UDP->cmos == 6) || (UDP->cmos == 5))
3761 try = 64; /* Only 48 actually useful */
3763 try = 32; /* Only 24 actually useful */
3765 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3766 if (!tmp && !floppy_track_buffer) {
3767 try >>= 1; /* buffer only one side */
3769 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3771 if (!tmp && !floppy_track_buffer) {
3772 fallback_on_nodma_alloc(&tmp, 2048 * try);
3774 if (!tmp && !floppy_track_buffer) {
3775 DPRINT("Unable to allocate DMA memory\n");
3778 if (floppy_track_buffer) {
3780 fd_dma_mem_free((unsigned long)tmp, try * 1024);
3782 buffer_min = buffer_max = -1;
3783 floppy_track_buffer = tmp;
3784 max_buffer_sectors = try;
3788 UDRS->fd_device = iminor(inode);
3789 set_capacity(disks[drive], floppy_sizes[iminor(inode)]);
3790 if (old_dev != -1 && old_dev != iminor(inode)) {
3791 if (buffer_drive == drive)
3795 /* Allow ioctls if we have write-permissions even if read-only open.
3796 * Needed so that programs such as fdrawcmd still can work on write
3797 * protected disks */
3798 if (filp->f_mode & 2
3799 || permission(filp->f_dentry->d_inode, 2, NULL) == 0)
3800 filp->private_data = (void *)8;
3802 if (UFDCS->rawcmd == 1)
3805 if (!(filp->f_flags & O_NDELAY)) {
3806 if (filp->f_mode & 3) {
3807 UDRS->last_checked = 0;
3808 check_disk_change(inode->i_bdev);
3809 if (UTESTF(FD_DISK_CHANGED))
3813 if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
3819 if (UDRS->fd_ref < 0)
3824 opened_bdev[drive] = NULL;
3825 floppy_release_irq_and_dma();
3832 * Check if the disk has been changed or if a change has been faked.
3834 static int check_floppy_change(struct gendisk *disk)
3836 int drive = (long)disk->private_data;
3838 if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
3841 if (UDP->checkfreq < (int)(jiffies - UDRS->last_checked)) {
3842 if (floppy_grab_irq_and_dma()) {
3848 process_fd_request();
3849 floppy_release_irq_and_dma();
3852 if (UTESTF(FD_DISK_CHANGED) ||
3853 UTESTF(FD_VERIFY) ||
3854 test_bit(drive, &fake_change) ||
3855 (!ITYPE(UDRS->fd_device) && !current_type[drive]))
3861 * This implements "read block 0" for floppy_revalidate().
3862 * Needed for format autodetection, checking whether there is
3863 * a disk in the drive, and whether that disk is writable.
3866 static int floppy_rb0_complete(struct bio *bio, unsigned int bytes_done,
3872 complete((struct completion *)bio->bi_private);
3876 static int __floppy_read_block_0(struct block_device *bdev)
3879 struct bio_vec bio_vec;
3880 struct completion complete;
3884 page = alloc_page(GFP_NOIO);
3886 process_fd_request();
3890 size = bdev->bd_block_size;
3895 bio.bi_io_vec = &bio_vec;
3896 bio_vec.bv_page = page;
3897 bio_vec.bv_len = size;
3898 bio_vec.bv_offset = 0;
3904 init_completion(&complete);
3905 bio.bi_private = &complete;
3906 bio.bi_end_io = floppy_rb0_complete;
3908 submit_bio(READ, &bio);
3909 generic_unplug_device(bdev_get_queue(bdev));
3910 process_fd_request();
3911 wait_for_completion(&complete);
3918 /* revalidate the floppy disk, i.e. trigger format autodetection by reading
3919 * the bootblock (block 0). "Autodetection" is also needed to check whether
3920 * there is a disk in the drive at all... Thus we also do it for fixed
3921 * geometry formats */
3922 static int floppy_revalidate(struct gendisk *disk)
3924 int drive = (long)disk->private_data;
3925 #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
3929 if (UTESTF(FD_DISK_CHANGED) ||
3930 UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
3931 if (usage_count == 0) {
3932 printk("VFS: revalidate called on non-open device.\n");
3936 cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
3937 if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
3938 process_fd_request(); /*already done by another thread */
3943 if (buffer_drive == drive)
3945 clear_bit(drive, &fake_change);
3946 UCLEARF(FD_DISK_CHANGED);
3951 res = __floppy_read_block_0(opened_bdev[drive]);
3954 poll_drive(0, FD_RAW_NEED_DISK);
3955 process_fd_request();
3958 set_capacity(disk, floppy_sizes[UDRS->fd_device]);
3962 static struct block_device_operations floppy_fops = {
3963 .owner = THIS_MODULE,
3964 .open = floppy_open,
3965 .release = floppy_release,
3967 .media_changed = check_floppy_change,
3968 .revalidate_disk = floppy_revalidate,
3970 static char *table[] = {
3971 "", "d360", "h1200", "u360", "u720", "h360", "h720",
3972 "u1440", "u2880", "CompaQ", "h1440", "u1680", "h410",
3973 "u820", "h1476", "u1722", "h420", "u830", "h1494", "u1743",
3974 "h880", "u1040", "u1120", "h1600", "u1760", "u1920",
3975 "u3200", "u3520", "u3840", "u1840", "u800", "u1600",
3978 static int t360[] = { 1, 0 },
3979 t1200[] = { 2, 5, 6, 10, 12, 14, 16, 18, 20, 23, 0 },
3980 t3in[] = { 8, 9, 26, 27, 28, 7, 11, 15, 19, 24, 25, 29, 31, 3, 4, 13,
3981 17, 21, 22, 30, 0 };
3982 static int *table_sup[] =
3983 { NULL, t360, t1200, t3in + 5 + 8, t3in + 5, t3in, t3in };
3985 static void __init register_devfs_entries(int drive)
3987 int base_minor = (drive < 4) ? drive : (124 + drive);
3989 if (UDP->cmos < NUMBER(default_drive_params)) {
3992 int minor = base_minor + (table_sup[UDP->cmos][i] << 2);
3994 devfs_mk_bdev(MKDEV(FLOPPY_MAJOR, minor),
3995 S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP |
3996 S_IWGRP, "floppy/%d%s", drive,
3997 table[table_sup[UDP->cmos][i]]);
3998 } while (table_sup[UDP->cmos][i++]);
4003 * Floppy Driver initialization
4004 * =============================
4007 /* Determine the floppy disk controller type */
4008 /* This routine was written by David C. Niemi */
4009 static char __init get_fdc_version(void)
4013 output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */
4016 if ((r = result()) <= 0x00)
4017 return FDC_NONE; /* No FDC present ??? */
4018 if ((r == 1) && (reply_buffer[0] == 0x80)) {
4019 printk(KERN_INFO "FDC %d is an 8272A\n", fdc);
4020 return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
4024 ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
4029 if (!fdc_configure()) {
4030 printk(KERN_INFO "FDC %d is an 82072\n", fdc);
4031 return FDC_82072; /* 82072 doesn't know CONFIGURE */
4034 output_byte(FD_PERPENDICULAR);
4035 if (need_more_output() == MORE_OUTPUT) {
4038 printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
4039 return FDC_82072A; /* 82072A as found on Sparcs. */
4042 output_byte(FD_UNLOCK);
4044 if ((r == 1) && (reply_buffer[0] == 0x80)) {
4045 printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
4046 return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
4049 if ((r != 1) || (reply_buffer[0] != 0x00)) {
4050 printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
4054 output_byte(FD_PARTID);
4057 printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
4061 if (reply_buffer[0] == 0x80) {
4062 printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);
4063 return FDC_82077; /* Revised 82077AA passes all the tests */
4065 switch (reply_buffer[0] >> 5) {
4067 /* Either a 82078-1 or a 82078SL running at 5Volt */
4068 printk(KERN_INFO "FDC %d is an 82078.\n", fdc);
4071 printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);
4074 printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
4077 printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",
4082 "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
4083 fdc, reply_buffer[0] >> 5);
4084 return FDC_82078_UNKN;
4086 } /* get_fdc_version */
4088 /* lilo configuration */
4090 static void __init floppy_set_flags(int *ints, int param, int param2)
4094 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4096 default_drive_params[i].params.flags |= param2;
4098 default_drive_params[i].params.flags &= ~param2;
4100 DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4103 static void __init daring(int *ints, int param, int param2)
4107 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4109 default_drive_params[i].params.select_delay = 0;
4110 default_drive_params[i].params.flags |=
4111 FD_SILENT_DCL_CLEAR;
4113 default_drive_params[i].params.select_delay =
4115 default_drive_params[i].params.flags &=
4116 ~FD_SILENT_DCL_CLEAR;
4119 DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4122 static void __init set_cmos(int *ints, int dummy, int dummy2)
4124 int current_drive = 0;
4127 DPRINT("wrong number of parameters for CMOS\n");
4130 current_drive = ints[1];
4131 if (current_drive < 0 || current_drive >= 8) {
4132 DPRINT("bad drive for set_cmos\n");
4136 if (current_drive >= 4 && !FDC2)
4140 DPRINT("setting CMOS code to %d\n", ints[2]);
4143 static struct param_table {
4145 void (*fn) (int *ints, int param, int param2);
4149 } config_params[] = {
4150 {"allowed_drive_mask", 0, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4151 {"all_drives", 0, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4152 {"asus_pci", 0, &allowed_drive_mask, 0x33, 0},
4153 {"irq", 0, &FLOPPY_IRQ, 6, 0},
4154 {"dma", 0, &FLOPPY_DMA, 2, 0},
4155 {"daring", daring, 0, 1, 0},
4157 {"two_fdc", 0, &FDC2, 0x370, 0},
4158 {"one_fdc", 0, &FDC2, 0, 0},
4160 {"thinkpad", floppy_set_flags, 0, 1, FD_INVERTED_DCL},
4161 {"broken_dcl", floppy_set_flags, 0, 1, FD_BROKEN_DCL},
4162 {"messages", floppy_set_flags, 0, 1, FTD_MSG},
4163 {"silent_dcl_clear", floppy_set_flags, 0, 1, FD_SILENT_DCL_CLEAR},
4164 {"debug", floppy_set_flags, 0, 1, FD_DEBUG},
4165 {"nodma", 0, &can_use_virtual_dma, 1, 0},
4166 {"omnibook", 0, &can_use_virtual_dma, 1, 0},
4167 {"yesdma", 0, &can_use_virtual_dma, 0, 0},
4168 {"fifo_depth", 0, &fifo_depth, 0xa, 0},
4169 {"nofifo", 0, &no_fifo, 0x20, 0},
4170 {"usefifo", 0, &no_fifo, 0, 0},
4171 {"cmos", set_cmos, 0, 0, 0},
4172 {"slow", 0, &slow_floppy, 1, 0},
4173 {"unexpected_interrupts", 0, &print_unex, 1, 0},
4174 {"no_unexpected_interrupts", 0, &print_unex, 0, 0},
4175 {"L40SX", 0, &print_unex, 0, 0}
4180 static int __init floppy_setup(char *str)
4186 str = get_options(str, ARRAY_SIZE(ints), ints);
4188 for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4189 if (strcmp(str, config_params[i].name) == 0) {
4193 param = config_params[i].def_param;
4194 if (config_params[i].fn)
4197 config_params[i].param2);
4198 if (config_params[i].var) {
4199 DPRINT("%s=%d\n", str, param);
4200 *config_params[i].var = param;
4207 DPRINT("unknown floppy option [%s]\n", str);
4209 DPRINT("allowed options are:");
4210 for (i = 0; i < ARRAY_SIZE(config_params); i++)
4211 printk(" %s", config_params[i].name);
4214 DPRINT("botched floppy option\n");
4215 DPRINT("Read linux/Documentation/floppy.txt\n");
4219 static int have_no_fdc = -ENODEV;
4221 static void floppy_device_release(struct device *dev)
4223 complete(&device_release);
4226 static struct platform_device floppy_device = {
4230 .release = floppy_device_release,
4234 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4236 int drive = (*part & 3) | ((*part & 0x80) >> 5);
4237 if (drive >= N_DRIVE ||
4238 !(allowed_drive_mask & (1 << drive)) ||
4239 fdc_state[FDC(drive)].version == FDC_NONE)
4241 if (((*part >> 2) & 0x1f) >= NUMBER(floppy_type))
4244 return get_disk(disks[drive]);
4247 int __init floppy_init(void)
4254 for (i = 0; i < N_DRIVE; i++) {
4255 disks[i] = alloc_disk(1);
4259 disks[i]->major = FLOPPY_MAJOR;
4260 disks[i]->first_minor = TOMINOR(i);
4261 disks[i]->fops = &floppy_fops;
4262 sprintf(disks[i]->disk_name, "fd%d", i);
4264 init_timer(&motor_off_timer[i]);
4265 motor_off_timer[i].data = i;
4266 motor_off_timer[i].function = motor_off_callback;
4269 devfs_mk_dir("floppy");
4270 if ((err = register_blkdev(FLOPPY_MAJOR, "fd")))
4273 floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
4274 blk_queue_max_sectors(floppy_queue, 64);
4275 if (!floppy_queue) {
4280 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4281 floppy_find, NULL, NULL);
4283 for (i = 0; i < 256; i++)
4285 floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4287 floppy_sizes[i] = MAX_DISK_SIZE << 1;
4289 reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
4292 for (i = 0; i < N_FDC; i++) {
4297 #if defined(__sparc__) || defined(__mc68000__)
4298 /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
4302 FDCS->version = FDC_82072A;
4306 use_virtual_dma = can_use_virtual_dma & 1;
4307 fdc_state[0].address = FDC1;
4308 if (fdc_state[0].address == -1) {
4313 fdc_state[1].address = FDC2;
4316 fdc = 0; /* reset fdc in case of unexpected interrupt */
4317 if (floppy_grab_irq_and_dma()) {
4322 /* initialise drive state */
4323 for (drive = 0; drive < N_DRIVE; drive++) {
4326 USETF(FD_DISK_NEWCHANGE);
4327 USETF(FD_DISK_CHANGED);
4329 UDRS->fd_device = -1;
4330 floppy_track_buffer = NULL;
4331 max_buffer_sectors = 0;
4334 for (i = 0; i < N_FDC; i++) {
4336 FDCS->driver_version = FD_DRIVER_VERSION;
4337 for (unit = 0; unit < 4; unit++)
4338 FDCS->track[unit] = 0;
4339 if (FDCS->address == -1)
4342 if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
4343 /* free ioports reserved by floppy_grab_irq_and_dma() */
4344 release_region(FDCS->address + 2, 4);
4345 release_region(FDCS->address + 7, 1);
4347 FDCS->version = FDC_NONE;
4350 /* Try to determine the floppy controller type */
4351 FDCS->version = get_fdc_version();
4352 if (FDCS->version == FDC_NONE) {
4353 /* free ioports reserved by floppy_grab_irq_and_dma() */
4354 release_region(FDCS->address + 2, 4);
4355 release_region(FDCS->address + 7, 1);
4359 if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
4360 can_use_virtual_dma = 0;
4363 /* Not all FDCs seem to be able to handle the version command
4364 * properly, so force a reset for the standard FDC clones,
4365 * to avoid interrupt garbage.
4367 user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
4370 del_timer(&fd_timeout);
4372 floppy_release_irq_and_dma();
4375 DPRINT("no floppy controllers found\n");
4376 flush_scheduled_work();
4378 floppy_release_irq_and_dma();
4383 for (drive = 0; drive < N_DRIVE; drive++) {
4384 if (!(allowed_drive_mask & (1 << drive)))
4386 if (fdc_state[FDC(drive)].version == FDC_NONE)
4388 /* to be cleaned up... */
4389 disks[drive]->private_data = (void *)(long)drive;
4390 disks[drive]->queue = floppy_queue;
4391 disks[drive]->flags |= GENHD_FL_REMOVABLE;
4392 add_disk(disks[drive]);
4395 platform_device_register(&floppy_device);
4399 del_timer(&fd_timeout);
4401 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4402 blk_cleanup_queue(floppy_queue);
4404 unregister_blkdev(FLOPPY_MAJOR, "fd");
4406 for (i = 0; i < N_DRIVE; i++)
4408 devfs_remove("floppy");
4417 static spinlock_t floppy_usage_lock = SPIN_LOCK_UNLOCKED;
4419 static int floppy_grab_irq_and_dma(void)
4421 unsigned long flags;
4423 spin_lock_irqsave(&floppy_usage_lock, flags);
4424 if (usage_count++) {
4425 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4428 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4429 if (fd_request_irq()) {
4430 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4432 spin_lock_irqsave(&floppy_usage_lock, flags);
4434 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4437 if (fd_request_dma()) {
4438 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4441 spin_lock_irqsave(&floppy_usage_lock, flags);
4443 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4447 for (fdc = 0; fdc < N_FDC; fdc++) {
4448 if (FDCS->address != -1) {
4449 if (!request_region(FDCS->address + 2, 4, "floppy")) {
4450 DPRINT("Floppy io-port 0x%04lx in use\n",
4454 if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
4455 DPRINT("Floppy io-port 0x%04lx in use\n",
4459 /* address + 6 is reserved, and may be taken by IDE.
4460 * Unfortunately, Adaptec doesn't know this :-(, */
4463 for (fdc = 0; fdc < N_FDC; fdc++) {
4464 if (FDCS->address != -1) {
4466 fd_outb(FDCS->dor, FD_DOR);
4470 set_dor(0, ~0, 8); /* avoid immediate interrupt */
4472 for (fdc = 0; fdc < N_FDC; fdc++)
4473 if (FDCS->address != -1)
4474 fd_outb(FDCS->dor, FD_DOR);
4476 * The driver will try and free resources and relies on us
4477 * to know if they were allocated or not.
4480 irqdma_allocated = 1;
4483 release_region(FDCS->address + 2, 4);
4487 while (--fdc >= 0) {
4488 release_region(FDCS->address + 2, 4);
4489 release_region(FDCS->address + 7, 1);
4491 spin_lock_irqsave(&floppy_usage_lock, flags);
4493 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4497 static void floppy_release_irq_and_dma(void)
4500 #ifdef FLOPPY_SANITY_CHECK
4506 unsigned long tmpaddr;
4507 unsigned long flags;
4509 spin_lock_irqsave(&floppy_usage_lock, flags);
4510 if (--usage_count) {
4511 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4514 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4515 if (irqdma_allocated) {
4519 irqdma_allocated = 0;
4525 floppy_enable_hlt();
4527 if (floppy_track_buffer && max_buffer_sectors) {
4528 tmpsize = max_buffer_sectors * 1024;
4529 tmpaddr = (unsigned long)floppy_track_buffer;
4530 floppy_track_buffer = NULL;
4531 max_buffer_sectors = 0;
4532 buffer_min = buffer_max = -1;
4533 fd_dma_mem_free(tmpaddr, tmpsize);
4535 #ifdef FLOPPY_SANITY_CHECK
4537 for (drive = 0; drive < N_FDC * 4; drive++)
4538 if (timer_pending(motor_off_timer + drive))
4539 printk("motor off timer %d still active\n", drive);
4542 if (timer_pending(&fd_timeout))
4543 printk("floppy timer still active:%s\n", timeout_message);
4544 if (timer_pending(&fd_timer))
4545 printk("auxiliary floppy timer still active\n");
4546 if (floppy_work.pending)
4547 printk("work still pending\n");
4550 for (fdc = 0; fdc < N_FDC; fdc++)
4551 if (FDCS->address != -1) {
4552 release_region(FDCS->address + 2, 4);
4553 release_region(FDCS->address + 7, 1);
4562 static void unregister_devfs_entries(int drive)
4566 if (UDP->cmos < NUMBER(default_drive_params)) {
4569 devfs_remove("floppy/%d%s", drive,
4570 table[table_sup[UDP->cmos][i]]);
4571 } while (table_sup[UDP->cmos][i++]);
4575 static void __init parse_floppy_cfg_string(char *cfg)
4580 for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != '\t'; cfg++) ;
4590 int init_module(void)
4592 printk(KERN_INFO "inserting floppy driver for " UTS_RELEASE "\n");
4595 parse_floppy_cfg_string(floppy);
4596 return floppy_init();
4599 void cleanup_module(void)
4603 init_completion(&device_release);
4604 platform_device_unregister(&floppy_device);
4605 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4606 unregister_blkdev(FLOPPY_MAJOR, "fd");
4608 for (drive = 0; drive < N_DRIVE; drive++) {
4609 del_timer_sync(&motor_off_timer[drive]);
4611 if ((allowed_drive_mask & (1 << drive)) &&
4612 fdc_state[FDC(drive)].version != FDC_NONE) {
4613 del_gendisk(disks[drive]);
4614 unregister_devfs_entries(drive);
4616 put_disk(disks[drive]);
4618 devfs_remove("floppy");
4620 del_timer_sync(&fd_timeout);
4621 del_timer_sync(&fd_timer);
4622 blk_cleanup_queue(floppy_queue);
4625 floppy_release_irq_and_dma();
4627 /* eject disk, if any */
4630 wait_for_completion(&device_release);
4633 MODULE_PARM(floppy, "s");
4634 MODULE_PARM(FLOPPY_IRQ, "i");
4635 MODULE_PARM(FLOPPY_DMA, "i");
4636 MODULE_AUTHOR("Alain L. Knaff");
4637 MODULE_SUPPORTED_DEVICE("fd");
4638 MODULE_LICENSE("GPL");
4642 __setup("floppy=", floppy_setup);
4643 module_init(floppy_init)
4646 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);