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
167 #include <linux/fd.h>
168 #include <linux/hdreg.h>
170 #include <linux/errno.h>
171 #include <linux/slab.h>
172 #include <linux/mm.h>
173 #include <linux/bio.h>
174 #include <linux/string.h>
175 #include <linux/fcntl.h>
176 #include <linux/delay.h>
177 #include <linux/mc146818rtc.h> /* CMOS defines */
178 #include <linux/ioport.h>
179 #include <linux/interrupt.h>
180 #include <linux/init.h>
181 #include <linux/devfs_fs_kernel.h>
182 #include <linux/device.h>
183 #include <linux/buffer_head.h> /* for invalidate_buffers() */
186 * PS/2 floppies have much slower step rates than regular floppies.
187 * It's been recommended that take about 1/4 of the default speed
188 * in some more extreme cases.
190 static int slow_floppy;
194 #include <asm/system.h>
196 #include <asm/uaccess.h>
198 static int FLOPPY_IRQ=6;
199 static int FLOPPY_DMA=2;
200 static int can_use_virtual_dma=2;
202 * can use virtual DMA:
203 * 0 = use of virtual DMA disallowed by config
204 * 1 = use of virtual DMA prescribed by config
205 * 2 = no virtual DMA preference configured. By default try hard DMA,
206 * but fall back on virtual DMA when not enough memory available
209 static int use_virtual_dma;
213 * 1 using virtual DMA
214 * This variable is set to virtual when a DMA mem problem arises, and
215 * reset back in floppy_grab_irq_and_dma.
216 * It is not safe to reset it in other circumstances, because the floppy
217 * driver may have several buffers in use at once, and we do currently not
218 * record each buffers capabilities
221 static spinlock_t floppy_lock = SPIN_LOCK_UNLOCKED;
222 static struct completion device_release;
224 static unsigned short virtual_dma_port=0x3f0;
225 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs * regs);
226 static int set_dor(int fdc, char mask, char data);
227 static void register_devfs_entries (int drive) __init;
229 #define K_64 0x10000 /* 64KB */
231 /* the following is the mask of allowed drives. By default units 2 and
232 * 3 of both floppy controllers are disabled, because switching on the
233 * motor of these drives causes system hangs on some PCI computers. drive
234 * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
235 * a drive is allowed.
237 * NOTE: This must come before we include the arch floppy header because
238 * some ports reference this variable from there. -DaveM
241 static int allowed_drive_mask = 0x33;
243 #include <asm/floppy.h>
245 static int irqdma_allocated;
247 #define LOCAL_END_REQUEST
248 #define DEVICE_NAME "floppy"
250 #include <linux/blkdev.h>
251 #include <linux/blkpg.h>
252 #include <linux/cdrom.h> /* for the compatibility eject ioctl */
253 #include <linux/completion.h>
255 static struct request *current_req;
256 static struct request_queue *floppy_queue;
257 static void do_fd_request(request_queue_t * q);
259 #ifndef fd_get_dma_residue
260 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
263 /* Dma Memory related stuff */
265 #ifndef fd_dma_mem_free
266 #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
269 #ifndef fd_dma_mem_alloc
270 #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
273 static inline void fallback_on_nodma_alloc(char **addr, size_t l)
275 #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
277 return; /* we have the memory */
278 if (can_use_virtual_dma != 2)
279 return; /* no fallback allowed */
280 printk("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*/
349 * globals used by 'result()'
351 #define MAX_REPLIES 16
352 static unsigned char reply_buffer[MAX_REPLIES];
353 static int inr; /* size of reply buffer, when called from interrupt */
354 #define ST0 (reply_buffer[0])
355 #define ST1 (reply_buffer[1])
356 #define ST2 (reply_buffer[2])
357 #define ST3 (reply_buffer[0]) /* result of GETSTATUS */
358 #define R_TRACK (reply_buffer[3])
359 #define R_HEAD (reply_buffer[4])
360 #define R_SECTOR (reply_buffer[5])
361 #define R_SIZECODE (reply_buffer[6])
363 #define SEL_DLY (2*HZ/100)
366 * this struct defines the different floppy drive types.
369 struct floppy_drive_params params;
370 const char *name; /* name printed while booting */
371 } default_drive_params[]= {
372 /* NOTE: the time values in jiffies should be in msec!
374 | Maximum data rate supported by drive type
375 | | Head load time, msec
376 | | | Head unload time, msec (not used)
377 | | | | Step rate interval, usec
378 | | | | | Time needed for spinup time (jiffies)
379 | | | | | | Timeout for spinning down (jiffies)
380 | | | | | | | Spindown offset (where disk stops)
381 | | | | | | | | Select delay
382 | | | | | | | | | RPS
383 | | | | | | | | | | Max number of tracks
384 | | | | | | | | | | | Interrupt timeout
385 | | | | | | | | | | | | Max nonintlv. sectors
386 | | | | | | | | | | | | | -Max Errors- flags */
387 {{0, 500, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 80, 3*HZ, 20, {3,1,2,0,2}, 0,
388 0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
390 {{1, 300, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 40, 3*HZ, 17, {3,1,2,0,2}, 0,
391 0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
393 {{2, 500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6, 83, 3*HZ, 17, {3,1,2,0,2}, 0,
394 0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
396 {{3, 250, 16, 16, 3000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
397 0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
399 {{4, 500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
400 0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
402 {{5, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
403 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
405 {{6, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
406 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
407 /* | --autodetected formats--- | | |
408 * read_track | | Name printed when booting
410 * Frequency of disk change checks */
413 static struct floppy_drive_params drive_params[N_DRIVE];
414 static struct floppy_drive_struct drive_state[N_DRIVE];
415 static struct floppy_write_errors write_errors[N_DRIVE];
416 static struct timer_list motor_off_timer[N_DRIVE];
417 static struct gendisk *disks[N_DRIVE];
418 static struct block_device *opened_bdev[N_DRIVE];
419 static DECLARE_MUTEX(open_lock);
420 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
423 * This struct defines the different floppy types.
425 * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
426 * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
427 * tells if the disk is in Commodore 1581 format, which means side 0 sectors
428 * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
429 * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
430 * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
431 * side 0 is on physical side 0 (but with the misnamed sector IDs).
432 * 'stretch' should probably be renamed to something more general, like
433 * 'options'. Other parameters should be self-explanatory (see also
443 | | | | | | Data rate, | 0x40 for perp
444 | | | | | | | Spec1 (stepping rate, head unload
445 | | | | | | | | /fmt gap (gap2) */
446 static struct floppy_struct floppy_type[32] = {
447 { 0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL }, /* 0 no testing */
448 { 720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360" }, /* 1 360KB PC */
449 { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /* 2 1.2MB AT */
450 { 720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360" }, /* 3 360KB SS 3.5" */
451 { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720" }, /* 4 720KB 3.5" */
452 { 720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360" }, /* 5 360KB AT */
453 { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720" }, /* 6 720KB AT */
454 { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /* 7 1.44MB 3.5" */
455 { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /* 8 2.88MB 3.5" */
456 { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /* 9 3.12MB 3.5" */
458 { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25" */
459 { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5" */
460 { 820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410" }, /* 12 410KB 5.25" */
461 { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820" }, /* 13 820KB 3.5" */
462 { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25" */
463 { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5" */
464 { 840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420" }, /* 16 420KB 5.25" */
465 { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830" }, /* 17 830KB 3.5" */
466 { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25" */
467 { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5" */
469 { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880" }, /* 20 880KB 5.25" */
470 { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5" */
471 { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5" */
472 { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25" */
473 { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5" */
474 { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5" */
475 { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5" */
476 { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5" */
477 { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5" */
479 { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5" */
480 { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800" }, /* 30 800KB 3.5" */
481 { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5" */
484 #define NUMBER(x) (sizeof(x) / sizeof(*(x)))
485 #define SECTSIZE (_FD_SECTSIZE(*floppy))
487 /* Auto-detection: Disk type used until the next media change occurs. */
488 static struct floppy_struct *current_type[N_DRIVE];
491 * User-provided type information. current_type points to
492 * the respective entry of this array.
494 static struct floppy_struct user_params[N_DRIVE];
496 static sector_t floppy_sizes[256];
499 * The driver is trying to determine the correct media format
500 * while probing is set. rw_interrupt() clears it after a
505 /* Synchronization of FDC access. */
506 #define FD_COMMAND_NONE -1
507 #define FD_COMMAND_ERROR 2
508 #define FD_COMMAND_OKAY 3
510 static volatile int command_status = FD_COMMAND_NONE;
511 static unsigned long fdc_busy;
512 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
513 static DECLARE_WAIT_QUEUE_HEAD(command_done);
515 #define NO_SIGNAL (!interruptible || !signal_pending(current))
516 #define CALL(x) if ((x) == -EINTR) return -EINTR
517 #define ECALL(x) if ((ret = (x))) return ret;
518 #define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
519 #define WAIT(x) _WAIT((x),interruptible)
520 #define IWAIT(x) _WAIT((x),1)
522 /* Errors during formatting are counted here. */
523 static int format_errors;
525 /* Format request descriptor. */
526 static struct format_descr format_req;
529 * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
530 * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
531 * H is head unload time (1=16ms, 2=32ms, etc)
536 * Because these are written to by the DMA controller, they must
537 * not contain a 64k byte boundary crossing, or data will be
540 static char *floppy_track_buffer;
541 static int max_buffer_sectors;
544 typedef void (*done_f)(int);
545 static struct cont_t {
546 void (*interrupt)(void); /* this is called after the interrupt of the
548 void (*redo)(void); /* this is called to retry the operation */
549 void (*error)(void); /* this is called to tally an error */
550 done_f done; /* this is called to say if the operation has
551 * succeeded/failed */
554 static void floppy_ready(void);
555 static void floppy_start(void);
556 static void process_fd_request(void);
557 static void recalibrate_floppy(void);
558 static void floppy_shutdown(unsigned long);
560 static int floppy_grab_irq_and_dma(void);
561 static void floppy_release_irq_and_dma(void);
564 * The "reset" variable should be tested whenever an interrupt is scheduled,
565 * after the commands have been sent. This is to ensure that the driver doesn't
566 * get wedged when the interrupt doesn't come because of a failed command.
567 * reset doesn't need to be tested before sending commands, because
568 * output_byte is automatically disabled when reset is set.
570 #define CHECK_RESET { if (FDCS->reset){ reset_fdc(); return; } }
571 static void reset_fdc(void);
574 * These are global variables, as that's the easiest way to give
575 * information to interrupts. They are the data used for the current
579 #define NEED_1_RECAL -2
580 #define NEED_2_RECAL -3
582 static int usage_count;
584 /* buffer related variables */
585 static int buffer_track = -1;
586 static int buffer_drive = -1;
587 static int buffer_min = -1;
588 static int buffer_max = -1;
590 /* fdc related variables, should end up in a struct */
591 static struct floppy_fdc_state fdc_state[N_FDC];
592 static int fdc; /* current fdc */
594 static struct floppy_struct *_floppy = floppy_type;
595 static unsigned char current_drive;
596 static long current_count_sectors;
597 static unsigned char fsector_t; /* sector in track */
598 static unsigned char in_sector_offset; /* offset within physical sector,
599 * expressed in units of 512 bytes */
602 static inline int fd_eject(int drive)
609 static long unsigned debugtimer;
616 static inline void set_debugt(void)
619 debugtimer = jiffies;
623 static inline void debugt(const char *message)
626 if (DP->flags & DEBUGT)
627 printk("%s dtime=%lu\n", message, jiffies-debugtimer);
631 typedef void (*timeout_fn)(unsigned long);
632 static struct timer_list fd_timeout = TIMER_INITIALIZER(floppy_shutdown, 0, 0);
634 static const char *timeout_message;
636 #ifdef FLOPPY_SANITY_CHECK
637 static void is_alive(const char *message)
639 /* this routine checks whether the floppy driver is "alive" */
640 if (test_bit(0, &fdc_busy) && command_status < 2
641 && !timer_pending(&fd_timeout)) {
642 DPRINT("timeout handler died: %s\n",message);
647 static void (*do_floppy)(void) = NULL;
649 #ifdef FLOPPY_SANITY_CHECK
653 static void (*lasthandler)(void);
654 static unsigned long interruptjiffies;
655 static unsigned long resultjiffies;
656 static int resultsize;
657 static unsigned long lastredo;
659 static struct output_log {
661 unsigned char status;
662 unsigned long jiffies;
663 } output_log[OLOGSIZE];
665 static int output_log_pos;
668 #define current_reqD -1
669 #define MAXTIMEOUT -2
671 static void __reschedule_timeout(int drive, const char *message, int marg)
673 if (drive == current_reqD)
674 drive = current_drive;
675 del_timer(&fd_timeout);
676 if (drive < 0 || drive > N_DRIVE) {
677 fd_timeout.expires = jiffies + 20UL*HZ;
680 fd_timeout.expires = jiffies + UDP->timeout;
681 add_timer(&fd_timeout);
682 if (UDP->flags & FD_DEBUG){
683 DPRINT("reschedule timeout ");
684 printk(message, marg);
687 timeout_message = message;
690 static void reschedule_timeout(int drive, const char *message, int marg)
694 spin_lock_irqsave(&floppy_lock, flags);
695 __reschedule_timeout(drive, message, marg);
696 spin_unlock_irqrestore(&floppy_lock, flags);
699 #define INFBOUND(a,b) (a)=max_t(int, a, b)
701 #define SUPBOUND(a,b) (a)=min_t(int, a, b)
705 * Bottom half floppy driver.
706 * ==========================
708 * This part of the file contains the code talking directly to the hardware,
709 * and also the main service loop (seek-configure-spinup-command)
714 * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
715 * and the last_checked date.
717 * last_checked is the date of the last check which showed 'no disk change'
718 * FD_DISK_CHANGE is set under two conditions:
719 * 1. The floppy has been changed after some i/o to that floppy already
721 * 2. No floppy disk is in the drive. This is done in order to ensure that
722 * requests are quickly flushed in case there is no disk in the drive. It
723 * follows that FD_DISK_CHANGE can only be cleared if there is a disk in
726 * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
727 * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
728 * each seek. If a disk is present, the disk change line should also be
729 * cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
730 * change line is set, this means either that no disk is in the drive, or
731 * that it has been removed since the last seek.
733 * This means that we really have a third possibility too:
734 * The floppy has been changed after the last seek.
737 static int disk_change(int drive)
740 #ifdef FLOPPY_SANITY_CHECK
741 if (jiffies - UDRS->select_date < UDP->select_delay)
742 DPRINT("WARNING disk change called early\n");
743 if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
744 (FDCS->dor & 3) != UNIT(drive) ||
746 DPRINT("probing disk change on unselected drive\n");
747 DPRINT("drive=%d fdc=%d dor=%x\n",drive, FDC(drive),
748 (unsigned int)FDCS->dor);
753 if (UDP->flags & FD_DEBUG){
754 DPRINT("checking disk change line for drive %d\n",drive);
755 DPRINT("jiffies=%lu\n", jiffies);
756 DPRINT("disk change line=%x\n",fd_inb(FD_DIR)&0x80);
757 DPRINT("flags=%lx\n",UDRS->flags);
760 if (UDP->flags & FD_BROKEN_DCL)
761 return UTESTF(FD_DISK_CHANGED);
762 if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80){
763 USETF(FD_VERIFY); /* verify write protection */
765 /* mark it changed */
766 USETF(FD_DISK_CHANGED);
769 /* invalidate its geometry */
770 if (UDRS->keep_data >= 0) {
771 if ((UDP->flags & FTD_MSG) &&
772 current_type[drive] != NULL)
773 DPRINT("Disk type is undefined after "
775 current_type[drive] = NULL;
776 floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
779 /*USETF(FD_DISK_NEWCHANGE);*/
782 UDRS->last_checked=jiffies;
783 UCLEARF(FD_DISK_NEWCHANGE);
788 static inline int is_selected(int dor, int unit)
790 return ((dor & (0x10 << unit)) && (dor &3) == unit);
793 static int set_dor(int fdc, char mask, char data)
795 register unsigned char drive, unit, newdor,olddor;
797 if (FDCS->address == -1)
801 newdor = (olddor & mask) | data;
802 if (newdor != olddor){
804 if (is_selected(olddor, unit) && !is_selected(newdor,unit)){
805 drive = REVDRIVE(fdc,unit);
807 if (UDP->flags & FD_DEBUG){
808 DPRINT("calling disk change from set_dor\n");
814 fd_outb(newdor, FD_DOR);
817 if (!is_selected(olddor, unit) && is_selected(newdor,unit)){
818 drive = REVDRIVE(fdc,unit);
819 UDRS->select_date = jiffies;
823 * We should propagate failures to grab the resources back
824 * nicely from here. Actually we ought to rewrite the fd
825 * driver some day too.
827 if (newdor & FLOPPY_MOTOR_MASK)
828 floppy_grab_irq_and_dma();
829 if (olddor & FLOPPY_MOTOR_MASK)
830 floppy_release_irq_and_dma();
834 static void twaddle(void)
836 if (DP->select_delay)
838 fd_outb(FDCS->dor & ~(0x10<<UNIT(current_drive)), FD_DOR);
839 fd_outb(FDCS->dor, FD_DOR);
840 DRS->select_date = jiffies;
843 /* reset all driver information about the current fdc. This is needed after
844 * a reset, and after a raw command. */
845 static void reset_fdc_info(int mode)
849 FDCS->spec1 = FDCS->spec2 = -1;
850 FDCS->need_configure = 1;
853 for (drive = 0; drive < N_DRIVE; drive++)
854 if (FDC(drive) == fdc &&
855 (mode || UDRS->track != NEED_1_RECAL))
856 UDRS->track = NEED_2_RECAL;
859 /* selects the fdc and drive, and enables the fdc's input/dma. */
860 static void set_fdc(int drive)
862 if (drive >= 0 && drive < N_DRIVE){
864 current_drive = drive;
866 if (fdc != 1 && fdc != 0) {
867 printk("bad fdc value\n");
872 set_dor(1-fdc, ~8, 0);
874 if (FDCS->rawcmd == 2)
876 if (fd_inb(FD_STATUS) != STATUS_READY)
880 /* locks the driver */
881 static int _lock_fdc(int drive, int interruptible, int line)
884 printk(KERN_ERR "Trying to lock fdc while usage count=0 at line %d\n", line);
887 if(floppy_grab_irq_and_dma()==-1)
890 if (test_and_set_bit(0, &fdc_busy)) {
891 DECLARE_WAITQUEUE(wait, current);
892 add_wait_queue(&fdc_wait, &wait);
895 set_current_state(TASK_INTERRUPTIBLE);
897 if (!test_and_set_bit(0, &fdc_busy))
903 remove_wait_queue(&fdc_wait, &wait);
908 set_current_state(TASK_RUNNING);
909 remove_wait_queue(&fdc_wait, &wait);
911 command_status = FD_COMMAND_NONE;
913 __reschedule_timeout(drive, "lock fdc", 0);
918 #define lock_fdc(drive,interruptible) _lock_fdc(drive,interruptible, __LINE__)
920 #define LOCK_FDC(drive,interruptible) \
921 if (lock_fdc(drive,interruptible)) return -EINTR;
924 /* unlocks the driver */
925 static inline void unlock_fdc(void)
930 if (!test_bit(0, &fdc_busy))
931 DPRINT("FDC access conflict!\n");
934 DPRINT("device interrupt still active at FDC release: %p!\n",
936 command_status = FD_COMMAND_NONE;
937 spin_lock_irqsave(&floppy_lock, flags);
938 del_timer(&fd_timeout);
940 clear_bit(0, &fdc_busy);
941 if (elv_next_request(floppy_queue))
942 do_fd_request(floppy_queue);
943 spin_unlock_irqrestore(&floppy_lock, flags);
944 floppy_release_irq_and_dma();
948 /* switches the motor off after a given timeout */
949 static void motor_off_callback(unsigned long nr)
951 unsigned char mask = ~(0x10 << UNIT(nr));
953 set_dor(FDC(nr), mask, 0);
956 /* schedules motor off */
957 static void floppy_off(unsigned int drive)
959 unsigned long volatile delta;
960 register int fdc=FDC(drive);
962 if (!(FDCS->dor & (0x10 << UNIT(drive))))
965 del_timer(motor_off_timer+drive);
967 /* make spindle stop in a position which minimizes spinup time
970 delta = jiffies - UDRS->first_read_date + HZ -
971 UDP->spindown_offset;
972 delta = ((delta * UDP->rps) % HZ) / UDP->rps;
973 motor_off_timer[drive].expires = jiffies + UDP->spindown - delta;
975 add_timer(motor_off_timer+drive);
979 * cycle through all N_DRIVE floppy drives, for disk change testing.
980 * stopping at current drive. This is done before any long operation, to
981 * be sure to have up to date disk change information.
983 static void scandrives(void)
985 int i, drive, saved_drive;
987 if (DP->select_delay)
990 saved_drive = current_drive;
991 for (i=0; i < N_DRIVE; i++){
992 drive = (saved_drive + i + 1) % N_DRIVE;
993 if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
994 continue; /* skip closed drives */
996 if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
997 (0x10 << UNIT(drive))))
998 /* switch the motor off again, if it was off to
1000 set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
1002 set_fdc(saved_drive);
1005 static void empty(void)
1009 static DECLARE_WORK(floppy_work, NULL, NULL);
1011 static void schedule_bh(void (*handler) (void))
1013 PREPARE_WORK(&floppy_work, (void (*)(void *))handler, NULL);
1014 schedule_work(&floppy_work);
1017 static struct timer_list fd_timer = TIMER_INITIALIZER(NULL, 0, 0);
1019 static void cancel_activity(void)
1021 unsigned long flags;
1023 spin_lock_irqsave(&floppy_lock, flags);
1025 PREPARE_WORK(&floppy_work, (void*)empty, NULL);
1026 del_timer(&fd_timer);
1027 spin_unlock_irqrestore(&floppy_lock, flags);
1030 /* this function makes sure that the disk stays in the drive during the
1032 static void fd_watchdog(void)
1035 if (DP->flags & FD_DEBUG){
1036 DPRINT("calling disk change from watchdog\n");
1040 if (disk_change(current_drive)){
1041 DPRINT("disk removed during i/o\n");
1046 del_timer(&fd_timer);
1047 fd_timer.function = (timeout_fn) fd_watchdog;
1048 fd_timer.expires = jiffies + HZ / 10;
1049 add_timer(&fd_timer);
1053 static void main_command_interrupt(void)
1055 del_timer(&fd_timer);
1059 /* waits for a delay (spinup or select) to pass */
1060 static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
1063 reset_fdc(); /* do the reset during sleep to win time
1064 * if we don't need to sleep, it's a good
1065 * occasion anyways */
1069 if ((signed) (jiffies - delay) < 0){
1070 del_timer(&fd_timer);
1071 fd_timer.function = function;
1072 fd_timer.expires = delay;
1073 add_timer(&fd_timer);
1079 static spinlock_t floppy_hlt_lock = SPIN_LOCK_UNLOCKED;
1080 static int hlt_disabled;
1081 static void floppy_disable_hlt(void)
1083 unsigned long flags;
1085 spin_lock_irqsave(&floppy_hlt_lock, flags);
1086 if (!hlt_disabled) {
1088 #ifdef HAVE_DISABLE_HLT
1092 spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1095 static void floppy_enable_hlt(void)
1097 unsigned long flags;
1099 spin_lock_irqsave(&floppy_hlt_lock, flags);
1102 #ifdef HAVE_DISABLE_HLT
1106 spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1110 static void setup_DMA(void)
1114 #ifdef FLOPPY_SANITY_CHECK
1115 if (raw_cmd->length == 0){
1118 printk("zero dma transfer size:");
1119 for (i=0; i < raw_cmd->cmd_count; i++)
1120 printk("%x,", raw_cmd->cmd[i]);
1126 if (((unsigned long) raw_cmd->kernel_data) % 512){
1127 printk("non aligned address: %p\n", raw_cmd->kernel_data);
1136 if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1137 (raw_cmd->flags & FD_RAW_READ)?
1138 DMA_MODE_READ : DMA_MODE_WRITE,
1139 FDCS->address) < 0) {
1140 release_dma_lock(f);
1145 release_dma_lock(f);
1148 fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1149 fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ)?
1150 DMA_MODE_READ : DMA_MODE_WRITE);
1151 fd_set_dma_addr(raw_cmd->kernel_data);
1152 fd_set_dma_count(raw_cmd->length);
1153 virtual_dma_port = FDCS->address;
1155 release_dma_lock(f);
1157 floppy_disable_hlt();
1160 static void show_floppy(void);
1162 /* waits until the fdc becomes ready */
1163 static int wait_til_ready(void)
1165 int counter, status;
1168 for (counter = 0; counter < 10000; counter++) {
1169 status = fd_inb(FD_STATUS);
1170 if (status & STATUS_READY)
1173 if (!initialising) {
1174 DPRINT("Getstatus times out (%x) on fdc %d\n",
1182 /* sends a command byte to the fdc */
1183 static int output_byte(char byte)
1187 if ((status = wait_til_ready()) < 0)
1189 if ((status & (STATUS_READY|STATUS_DIR|STATUS_DMA)) == STATUS_READY){
1190 fd_outb(byte,FD_DATA);
1191 #ifdef FLOPPY_SANITY_CHECK
1192 output_log[output_log_pos].data = byte;
1193 output_log[output_log_pos].status = status;
1194 output_log[output_log_pos].jiffies = jiffies;
1195 output_log_pos = (output_log_pos + 1) % OLOGSIZE;
1200 if (!initialising) {
1201 DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
1207 #define LAST_OUT(x) if (output_byte(x)<0){ reset_fdc();return;}
1209 /* gets the response from the fdc */
1210 static int result(void)
1214 for(i=0; i < MAX_REPLIES; i++) {
1215 if ((status = wait_til_ready()) < 0)
1217 status &= STATUS_DIR|STATUS_READY|STATUS_BUSY|STATUS_DMA;
1218 if ((status & ~STATUS_BUSY) == STATUS_READY){
1219 #ifdef FLOPPY_SANITY_CHECK
1220 resultjiffies = jiffies;
1225 if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY))
1226 reply_buffer[i] = fd_inb(FD_DATA);
1230 if (!initialising) {
1231 DPRINT("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
1239 #define MORE_OUTPUT -2
1240 /* does the fdc need more output? */
1241 static int need_more_output(void)
1244 if ((status = wait_til_ready()) < 0)
1246 if ((status & (STATUS_READY|STATUS_DIR|STATUS_DMA)) == STATUS_READY)
1251 /* Set perpendicular mode as required, based on data rate, if supported.
1252 * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
1254 static inline void perpendicular_mode(void)
1256 unsigned char perp_mode;
1258 if (raw_cmd->rate & 0x40){
1259 switch(raw_cmd->rate & 3){
1267 DPRINT("Invalid data rate for perpendicular mode!\n");
1269 FDCS->reset = 1; /* convenient way to return to
1270 * redo without to much hassle (deep
1277 if (FDCS->perp_mode == perp_mode)
1279 if (FDCS->version >= FDC_82077_ORIG) {
1280 output_byte(FD_PERPENDICULAR);
1281 output_byte(perp_mode);
1282 FDCS->perp_mode = perp_mode;
1283 } else if (perp_mode) {
1284 DPRINT("perpendicular mode not supported by this FDC.\n");
1286 } /* perpendicular_mode */
1288 static int fifo_depth = 0xa;
1291 static int fdc_configure(void)
1294 output_byte(FD_CONFIGURE);
1295 if (need_more_output() != MORE_OUTPUT)
1298 output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1299 output_byte(0); /* pre-compensation from track
1304 #define NOMINAL_DTR 500
1306 /* Issue a "SPECIFY" command to set the step rate time, head unload time,
1307 * head load time, and DMA disable flag to values needed by floppy.
1309 * The value "dtr" is the data transfer rate in Kbps. It is needed
1310 * to account for the data rate-based scaling done by the 82072 and 82077
1311 * FDC types. This parameter is ignored for other types of FDCs (i.e.
1314 * Note that changing the data transfer rate has a (probably deleterious)
1315 * effect on the parameters subject to scaling for 82072/82077 FDCs, so
1316 * fdc_specify is called again after each data transfer rate
1319 * srt: 1000 to 16000 in microseconds
1320 * hut: 16 to 240 milliseconds
1321 * hlt: 2 to 254 milliseconds
1323 * These values are rounded up to the next highest available delay time.
1325 static void fdc_specify(void)
1327 unsigned char spec1, spec2;
1328 unsigned long srt, hlt, hut;
1329 unsigned long dtr = NOMINAL_DTR;
1330 unsigned long scale_dtr = NOMINAL_DTR;
1331 int hlt_max_code = 0x7f;
1332 int hut_max_code = 0xf;
1334 if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
1336 FDCS->need_configure = 0;
1337 /*DPRINT("FIFO enabled\n");*/
1340 switch (raw_cmd->rate & 0x03) {
1346 if (FDCS->version >= FDC_82078) {
1347 /* chose the default rate table, not the one
1348 * where 1 = 2 Mbps */
1349 output_byte(FD_DRIVESPEC);
1350 if (need_more_output() == MORE_OUTPUT) {
1351 output_byte(UNIT(current_drive));
1361 if (FDCS->version >= FDC_82072) {
1363 hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
1364 hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
1367 /* Convert step rate from microseconds to milliseconds and 4 bits */
1368 srt = 16 - (DP->srt*scale_dtr/1000 + NOMINAL_DTR - 1)/NOMINAL_DTR;
1375 hlt = (DP->hlt*scale_dtr/2 + NOMINAL_DTR - 1)/NOMINAL_DTR;
1378 else if (hlt > 0x7f)
1381 hut = (DP->hut*scale_dtr/16 + NOMINAL_DTR - 1)/NOMINAL_DTR;
1387 spec1 = (srt << 4) | hut;
1388 spec2 = (hlt << 1) | (use_virtual_dma & 1);
1390 /* If these parameters did not change, just return with success */
1391 if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
1392 /* Go ahead and set spec1 and spec2 */
1393 output_byte(FD_SPECIFY);
1394 output_byte(FDCS->spec1 = spec1);
1395 output_byte(FDCS->spec2 = spec2);
1399 /* Set the FDC's data transfer rate on behalf of the specified drive.
1400 * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
1401 * of the specify command (i.e. using the fdc_specify function).
1403 static int fdc_dtr(void)
1405 /* If data rate not already set to desired value, set it. */
1406 if ((raw_cmd->rate & 3) == FDCS->dtr)
1410 fd_outb(raw_cmd->rate & 3, FD_DCR);
1412 /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1413 * need a stabilization period of several milliseconds to be
1414 * enforced after data rate changes before R/W operations.
1415 * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
1417 FDCS->dtr = raw_cmd->rate & 3;
1418 return(fd_wait_for_completion(jiffies+2UL*HZ/100,
1419 (timeout_fn) floppy_ready));
1422 static void tell_sector(void)
1424 printk(": track %d, head %d, sector %d, size %d",
1425 R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
1430 * OK, this error interpreting routine is called after a
1431 * DMA read/write has succeeded
1432 * or failed, so we check the results, and copy any buffers.
1433 * hhb: Added better error reporting.
1434 * ak: Made this into a separate routine.
1436 static int interpret_errors(void)
1441 DPRINT("-- FDC reply error");
1446 /* check IC to find cause of interrupt */
1447 switch (ST0 & ST0_INTR) {
1448 case 0x40: /* error occurred during command execution */
1450 return 0; /* occurs with pseudo-DMA */
1453 DPRINT("Drive is write protected\n");
1454 CLEARF(FD_DISK_WRITABLE);
1457 } else if (ST1 & ST1_ND) {
1458 SETF(FD_NEED_TWADDLE);
1459 } else if (ST1 & ST1_OR) {
1460 if (DP->flags & FTD_MSG)
1461 DPRINT("Over/Underrun - retrying\n");
1463 }else if (*errors >= DP->max_errors.reporting){
1465 if (ST0 & ST0_ECE) {
1466 printk("Recalibrate failed!");
1467 } else if (ST2 & ST2_CRC) {
1468 printk("data CRC error");
1470 } else if (ST1 & ST1_CRC) {
1471 printk("CRC error");
1473 } else if ((ST1 & (ST1_MAM|ST1_ND)) || (ST2 & ST2_MAM)) {
1475 printk("sector not found");
1478 printk("probe failed...");
1479 } else if (ST2 & ST2_WC) { /* seek error */
1480 printk("wrong cylinder");
1481 } else if (ST2 & ST2_BC) { /* cylinder marked as bad */
1482 printk("bad cylinder");
1484 printk("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x", ST0, ST1, ST2);
1490 if (ST2 & ST2_WC || ST2 & ST2_BC)
1491 /* wrong cylinder => recal */
1492 DRS->track = NEED_2_RECAL;
1494 case 0x80: /* invalid command given */
1495 DPRINT("Invalid FDC command given!\n");
1499 DPRINT("Abnormal termination caused by polling\n");
1502 default: /* (0) Normal command termination */
1508 * This routine is called when everything should be correctly set up
1509 * for the transfer (i.e. floppy motor is on, the correct floppy is
1510 * selected, and the head is sitting on the right track).
1512 static void setup_rw_floppy(void)
1514 int i,r, flags,dflags;
1515 unsigned long ready_date;
1516 timeout_fn function;
1518 flags = raw_cmd->flags;
1519 if (flags & (FD_RAW_READ | FD_RAW_WRITE))
1520 flags |= FD_RAW_INTR;
1522 if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)){
1523 ready_date = DRS->spinup_date + DP->spinup;
1524 /* If spinup will take a long time, rerun scandrives
1525 * again just before spinup completion. Beware that
1526 * after scandrives, we must again wait for selection.
1528 if ((signed) (ready_date - jiffies) > DP->select_delay){
1529 ready_date -= DP->select_delay;
1530 function = (timeout_fn) floppy_start;
1532 function = (timeout_fn) setup_rw_floppy;
1534 /* wait until the floppy is spinning fast enough */
1535 if (fd_wait_for_completion(ready_date,function))
1538 dflags = DRS->flags;
1540 if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
1543 if (flags & FD_RAW_INTR)
1544 do_floppy = main_command_interrupt;
1547 for (i=0; i< raw_cmd->cmd_count; i++)
1548 r|=output_byte(raw_cmd->cmd[i]);
1551 debugt("rw_command: ");
1559 if (!(flags & FD_RAW_INTR)){
1562 } else if (flags & FD_RAW_NEED_DISK)
1566 static int blind_seek;
1569 * This is the routine called after every seek (or recalibrate) interrupt
1570 * from the floppy controller.
1572 static void seek_interrupt(void)
1575 debugt("seek interrupt:");
1577 if (inr != 2 || (ST0 & 0xF8) != 0x20) {
1578 DPRINT("seek failed\n");
1579 DRS->track = NEED_2_RECAL;
1584 if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek){
1586 if (DP->flags & FD_DEBUG){
1587 DPRINT("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));
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) &&
1637 (raw_cmd->flags & FD_RAW_NEED_DISK)){
1638 /* the media changed flag should be cleared after the seek.
1639 * If it isn't, this means that there is really no disk in
1642 SETF(FD_DISK_CHANGED);
1647 if (DRS->track <= NEED_1_RECAL){
1648 recalibrate_floppy();
1650 } else if (TESTF(FD_DISK_NEWCHANGE) &&
1651 (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1652 (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
1653 /* we seek to clear the media-changed condition. Does anybody
1654 * know a more elegant way, which works on all drives? */
1656 track = raw_cmd->track - 1;
1658 if (DP->flags & FD_SILENT_DCL_CLEAR){
1659 set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
1661 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1667 if (raw_cmd->track != DRS->track &&
1668 (raw_cmd->flags & FD_RAW_NEED_SEEK))
1669 track = raw_cmd->track;
1676 do_floppy = seek_interrupt;
1677 output_byte(FD_SEEK);
1678 output_byte(UNIT(current_drive));
1681 debugt("seek command:");
1685 static void recal_interrupt(void)
1688 debugt("recal interrupt:");
1692 else if (ST0 & ST0_ECE) {
1696 debugt("recal interrupt need 1 recal:");
1698 /* after a second recalibrate, we still haven't
1699 * reached track 0. Probably no drive. Raise an
1700 * error, as failing immediately might upset
1701 * computers possessed by the Devil :-) */
1707 debugt("recal interrupt need 2 recal:");
1709 /* If we already did a recalibrate,
1710 * and we are not at track 0, this
1711 * means we have moved. (The only way
1712 * not to move at recalibration is to
1713 * be already at track 0.) Clear the
1714 * new change flag */
1716 if (DP->flags & FD_DEBUG){
1717 DPRINT("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;
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 && max_sensei);
1804 schedule_bh(handler);
1807 is_alive("normal interrupt end");
1809 /* FIXME! Was it really for us? */
1813 static void recalibrate_floppy(void)
1816 debugt("recalibrate floppy:");
1818 do_floppy = recal_interrupt;
1819 output_byte(FD_RECALIBRATE);
1820 LAST_OUT(UNIT(current_drive));
1824 * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1826 static void reset_interrupt(void)
1829 debugt("reset interrupt:");
1831 result(); /* get the status ready for set_fdc */
1833 printk("reset set in interrupt, calling %p\n", cont->error);
1834 cont->error(); /* a reset just after a reset. BAD! */
1840 * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1841 * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1843 static void reset_fdc(void)
1845 unsigned long flags;
1847 do_floppy = reset_interrupt;
1851 /* Pseudo-DMA may intercept 'reset finished' interrupt. */
1852 /* Irrelevant for systems with true DMA (i386). */
1854 flags=claim_dma_lock();
1856 release_dma_lock(flags);
1858 if (FDCS->version >= FDC_82072A)
1859 fd_outb(0x80 | (FDCS->dtr &3), FD_STATUS);
1861 fd_outb(FDCS->dor & ~0x04, FD_DOR);
1862 udelay(FD_RESET_DELAY);
1863 fd_outb(FDCS->dor, FD_DOR);
1867 static void show_floppy(void)
1872 printk("floppy driver state\n");
1873 printk("-------------------\n");
1874 printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",
1875 jiffies, interruptjiffies, jiffies-interruptjiffies, lasthandler);
1878 #ifdef FLOPPY_SANITY_CHECK
1879 printk("timeout_message=%s\n", timeout_message);
1880 printk("last output bytes:\n");
1881 for (i=0; i < OLOGSIZE; i++)
1882 printk("%2x %2x %lu\n",
1883 output_log[(i+output_log_pos) % OLOGSIZE].data,
1884 output_log[(i+output_log_pos) % OLOGSIZE].status,
1885 output_log[(i+output_log_pos) % OLOGSIZE].jiffies);
1886 printk("last result at %lu\n", resultjiffies);
1887 printk("last redo_fd_request at %lu\n", lastredo);
1888 for (i=0; i<resultsize; i++){
1889 printk("%2x ", reply_buffer[i]);
1894 printk("status=%x\n", fd_inb(FD_STATUS));
1895 printk("fdc_busy=%lu\n", fdc_busy);
1897 printk("do_floppy=%p\n", do_floppy);
1898 if (floppy_work.pending)
1899 printk("floppy_work.func=%p\n", floppy_work.func);
1900 if (timer_pending(&fd_timer))
1901 printk("fd_timer.function=%p\n", fd_timer.function);
1902 if (timer_pending(&fd_timeout)){
1903 printk("timer_function=%p\n",fd_timeout.function);
1904 printk("expires=%lu\n",fd_timeout.expires-jiffies);
1905 printk("now=%lu\n",jiffies);
1907 printk("cont=%p\n", cont);
1908 printk("current_req=%p\n", current_req);
1909 printk("command_status=%d\n", command_status);
1913 static void floppy_shutdown(unsigned long data)
1915 unsigned long flags;
1921 floppy_enable_hlt();
1923 flags=claim_dma_lock();
1925 release_dma_lock(flags);
1927 /* avoid dma going to a random drive after shutdown */
1930 DPRINT("floppy timeout called\n");
1934 cont->redo(); /* this will recall reset when needed */
1936 printk("no cont in shutdown!\n");
1937 process_fd_request();
1939 is_alive("floppy shutdown");
1941 /*typedef void (*timeout_fn)(unsigned long);*/
1943 /* start motor, check media-changed condition and write protection */
1944 static int start_motor(void (*function)(void) )
1949 data = UNIT(current_drive);
1950 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)){
1951 if (!(FDCS->dor & (0x10 << UNIT(current_drive)))){
1953 /* no read since this drive is running */
1954 DRS->first_read_date = 0;
1955 /* note motor start time if motor is not yet running */
1956 DRS->spinup_date = jiffies;
1957 data |= (0x10 << UNIT(current_drive));
1960 if (FDCS->dor & (0x10 << UNIT(current_drive)))
1961 mask &= ~(0x10 << UNIT(current_drive));
1963 /* starts motor and selects floppy */
1964 del_timer(motor_off_timer + current_drive);
1965 set_dor(fdc, mask, data);
1967 /* wait_for_completion also schedules reset if needed. */
1968 return(fd_wait_for_completion(DRS->select_date+DP->select_delay,
1969 (timeout_fn) function));
1972 static void floppy_ready(void)
1975 if (start_motor(floppy_ready)) return;
1976 if (fdc_dtr()) return;
1979 if (DP->flags & FD_DEBUG){
1980 DPRINT("calling disk change from floppy_ready\n");
1983 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1984 disk_change(current_drive) &&
1986 twaddle(); /* this clears the dcl on certain drive/controller
1989 #ifdef fd_chose_dma_mode
1990 if ((raw_cmd->flags & FD_RAW_READ) ||
1991 (raw_cmd->flags & FD_RAW_WRITE))
1993 unsigned long flags = claim_dma_lock();
1994 fd_chose_dma_mode(raw_cmd->kernel_data,
1996 release_dma_lock(flags);
2000 if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)){
2001 perpendicular_mode();
2002 fdc_specify(); /* must be done here because of hut, hlt ... */
2005 if ((raw_cmd->flags & FD_RAW_READ) ||
2006 (raw_cmd->flags & FD_RAW_WRITE))
2012 static void floppy_start(void)
2014 reschedule_timeout(current_reqD, "floppy start", 0);
2018 if (DP->flags & FD_DEBUG){
2019 DPRINT("setting NEWCHANGE in floppy_start\n");
2022 SETF(FD_DISK_NEWCHANGE);
2027 * ========================================================================
2028 * here ends the bottom half. Exported routines are:
2029 * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
2030 * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
2031 * Initialization also uses output_byte, result, set_dor, floppy_interrupt
2033 * ========================================================================
2036 * General purpose continuations.
2037 * ==============================
2040 static void do_wakeup(void)
2042 reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
2044 command_status += 2;
2045 wake_up(&command_done);
2048 static struct cont_t wakeup_cont = {
2052 .done = (done_f) empty
2056 static struct cont_t intr_cont = {
2058 .redo = process_fd_request,
2060 .done = (done_f) empty
2063 static int wait_til_done(void (*handler)(void), int interruptible)
2067 schedule_bh(handler);
2069 if (command_status < 2 && NO_SIGNAL) {
2070 DECLARE_WAITQUEUE(wait, current);
2072 add_wait_queue(&command_done, &wait);
2074 set_current_state(interruptible?
2076 TASK_UNINTERRUPTIBLE);
2078 if (command_status >= 2 || !NO_SIGNAL)
2081 is_alive("wait_til_done");
2086 set_current_state(TASK_RUNNING);
2087 remove_wait_queue(&command_done, &wait);
2090 if (command_status < 2){
2098 command_status = FD_COMMAND_ERROR;
2099 if (command_status == FD_COMMAND_OKAY)
2103 command_status = FD_COMMAND_NONE;
2107 static void generic_done(int result)
2109 command_status = result;
2110 cont = &wakeup_cont;
2113 static void generic_success(void)
2118 static void generic_failure(void)
2123 static void success_and_wakeup(void)
2131 * formatting and rw support.
2132 * ==========================
2135 static int next_valid_format(void)
2139 probed_format = DRS->probed_format;
2141 if (probed_format >= 8 ||
2142 !DP->autodetect[probed_format]){
2143 DRS->probed_format = 0;
2146 if (floppy_type[DP->autodetect[probed_format]].sect){
2147 DRS->probed_format = probed_format;
2154 static void bad_flp_intr(void)
2159 DRS->probed_format++;
2160 if (!next_valid_format())
2163 err_count = ++(*errors);
2164 INFBOUND(DRWE->badness, err_count);
2165 if (err_count > DP->max_errors.abort)
2167 if (err_count > DP->max_errors.reset)
2169 else if (err_count > DP->max_errors.recal)
2170 DRS->track = NEED_2_RECAL;
2173 static void set_floppy(int drive)
2175 int type = ITYPE(UDRS->fd_device);
2177 _floppy = floppy_type + type;
2179 _floppy = current_type[ drive ];
2183 * formatting support.
2184 * ===================
2186 static void format_interrupt(void)
2188 switch (interpret_errors()){
2199 #define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
2200 #define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80) >>1))
2201 #define CT(x) ((x) | 0xc0)
2202 static void setup_format_params(int track)
2205 unsigned char track,head,sect,size;
2206 } *here = (struct fparm *)floppy_track_buffer;
2208 int count,head_shift,track_shift;
2210 raw_cmd = &default_raw_cmd;
2211 raw_cmd->track = track;
2213 raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2214 FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2215 raw_cmd->rate = _floppy->rate & 0x43;
2216 raw_cmd->cmd_count = NR_F;
2217 COMMAND = FM_MODE(_floppy,FD_FORMAT);
2218 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy,format_req.head);
2219 F_SIZECODE = FD_SIZECODE(_floppy);
2220 F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2221 F_GAP = _floppy->fmt_gap;
2222 F_FILL = FD_FILL_BYTE;
2224 raw_cmd->kernel_data = floppy_track_buffer;
2225 raw_cmd->length = 4 * F_SECT_PER_TRACK;
2227 /* allow for about 30ms for data transport per track */
2228 head_shift = (F_SECT_PER_TRACK + 5) / 6;
2230 /* a ``cylinder'' is two tracks plus a little stepping time */
2231 track_shift = 2 * head_shift + 3;
2233 /* position of logical sector 1 on this track */
2234 n = (track_shift * format_req.track + head_shift * format_req.head)
2237 /* determine interleave */
2239 if (_floppy->fmt_gap < 0x22)
2242 /* initialize field */
2243 for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2244 here[count].track = format_req.track;
2245 here[count].head = format_req.head;
2246 here[count].sect = 0;
2247 here[count].size = F_SIZECODE;
2249 /* place logical sectors */
2250 for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2251 here[n].sect = count;
2252 n = (n+il) % F_SECT_PER_TRACK;
2253 if (here[n].sect) { /* sector busy, find next free sector */
2255 if (n>= F_SECT_PER_TRACK) {
2256 n-=F_SECT_PER_TRACK;
2257 while (here[n].sect) ++n;
2263 static void redo_format(void)
2266 setup_format_params(format_req.track << STRETCH(_floppy));
2269 debugt("queue format request");
2273 static struct cont_t format_cont = {
2274 .interrupt = format_interrupt,
2275 .redo = redo_format,
2276 .error = bad_flp_intr,
2277 .done = generic_done
2280 static int do_format(int drive, struct format_descr *tmp_format_req)
2287 _floppy->track > DP->tracks ||
2288 tmp_format_req->track >= _floppy->track ||
2289 tmp_format_req->head >= _floppy->head ||
2290 (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2291 !_floppy->fmt_gap) {
2292 process_fd_request();
2295 format_req = *tmp_format_req;
2297 cont = &format_cont;
2298 errors = &format_errors;
2300 process_fd_request();
2305 * Buffer read/write and support
2306 * =============================
2309 static void floppy_end_request(struct request *req, int uptodate)
2311 unsigned int nr_sectors = current_count_sectors;
2313 /* current_count_sectors can be zero if transfer failed */
2315 nr_sectors = req->current_nr_sectors;
2316 if (end_that_request_first(req, uptodate, nr_sectors))
2318 add_disk_randomness(req->rq_disk);
2319 floppy_off((long)req->rq_disk->private_data);
2320 blkdev_dequeue_request(req);
2321 end_that_request_last(req);
2323 /* 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 != base + size)
2490 /* Compute the maximal transfer size */
2491 static int transfer_size(int ssize, int max_sector, int max_size)
2493 SUPBOUND(max_sector, fsector_t + max_size);
2496 max_sector -= (max_sector % _floppy->sect) % ssize;
2498 /* transfer size, beginning not aligned */
2499 current_count_sectors = max_sector - fsector_t ;
2505 * Move data from/to the track buffer to/from the buffer cache.
2507 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2509 int remaining; /* number of transferred 512-byte sectors */
2512 char *buffer, *dma_buffer;
2515 max_sector = transfer_size(ssize,
2516 min(max_sector, max_sector_2),
2517 current_req->nr_sectors);
2519 if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2520 buffer_max > fsector_t + current_req->nr_sectors)
2521 current_count_sectors = min_t(int, buffer_max - fsector_t,
2522 current_req->nr_sectors);
2524 remaining = current_count_sectors << 9;
2525 #ifdef FLOPPY_SANITY_CHECK
2526 if ((remaining >> 9) > current_req->nr_sectors &&
2527 CT(COMMAND) == FD_WRITE){
2528 DPRINT("in copy buffer\n");
2529 printk("current_count_sectors=%ld\n", current_count_sectors);
2530 printk("remaining=%d\n", remaining >> 9);
2531 printk("current_req->nr_sectors=%ld\n",current_req->nr_sectors);
2532 printk("current_req->current_nr_sectors=%u\n",
2533 current_req->current_nr_sectors);
2534 printk("max_sector=%d\n", max_sector);
2535 printk("ssize=%d\n", ssize);
2539 buffer_max = max(max_sector, buffer_max);
2541 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2543 size = current_req->current_nr_sectors << 9;
2545 rq_for_each_bio(bio, current_req) {
2546 bio_for_each_segment(bv, bio, i) {
2551 SUPBOUND(size, remaining);
2553 buffer = page_address(bv->bv_page) + bv->bv_offset;
2554 #ifdef FLOPPY_SANITY_CHECK
2555 if (dma_buffer + size >
2556 floppy_track_buffer + (max_buffer_sectors << 10) ||
2557 dma_buffer < floppy_track_buffer){
2558 DPRINT("buffer overrun in copy buffer %d\n",
2559 (int) ((floppy_track_buffer - dma_buffer) >>9));
2560 printk("fsector_t=%d buffer_min=%d\n",
2561 fsector_t, buffer_min);
2562 printk("current_count_sectors=%ld\n",
2563 current_count_sectors);
2564 if (CT(COMMAND) == FD_READ)
2566 if (CT(COMMAND) == FD_READ)
2570 if (((unsigned long)buffer) % 512)
2571 DPRINT("%p buffer not aligned\n", buffer);
2573 if (CT(COMMAND) == FD_READ)
2574 memcpy(buffer, dma_buffer, size);
2576 memcpy(dma_buffer, buffer, size);
2582 #ifdef FLOPPY_SANITY_CHECK
2585 max_sector -= remaining >> 9;
2586 DPRINT("weirdness: remaining %d\n", remaining>>9);
2592 static inline int check_dma_crossing(char *start,
2593 unsigned long length, char *message)
2595 if (CROSS_64KB(start, length)) {
2596 printk("DMA xfer crosses 64KB boundary in %s %p-%p\n",
2597 message, start, start+length);
2604 /* work around a bug in pseudo DMA
2605 * (on some FDCs) pseudo DMA does not stop when the CPU stops
2606 * sending data. Hence we need a different way to signal the
2607 * transfer length: We use SECT_PER_TRACK. Unfortunately, this
2608 * does not work with MT, hence we can only transfer one head at
2611 static void virtualdmabug_workaround(void)
2613 int hard_sectors, end_sector;
2615 if(CT(COMMAND) == FD_WRITE) {
2616 COMMAND &= ~0x80; /* switch off multiple track mode */
2618 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2619 end_sector = SECTOR + hard_sectors - 1;
2620 #ifdef FLOPPY_SANITY_CHECK
2621 if(end_sector > SECT_PER_TRACK) {
2622 printk("too many sectors %d > %d\n",
2623 end_sector, SECT_PER_TRACK);
2627 SECT_PER_TRACK = end_sector; /* make sure SECT_PER_TRACK points
2628 * to end of transfer */
2633 * Formulate a read/write request.
2634 * this routine decides where to load the data (directly to buffer, or to
2635 * tmp floppy area), how much data to load (the size of the buffer, the whole
2636 * track, or a single sector)
2637 * All floppy_track_buffer handling goes in here. If we ever add track buffer
2638 * allocation on the fly, it should be done here. No other part should need
2642 static int make_raw_rw_request(void)
2644 int aligned_sector_t;
2645 int max_sector, max_size, tracksize, ssize;
2647 if(max_buffer_sectors == 0) {
2648 printk("VFS: Block I/O scheduled on unopened device\n");
2652 set_fdc((long)current_req->rq_disk->private_data);
2654 raw_cmd = &default_raw_cmd;
2655 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2657 raw_cmd->cmd_count = NR_RW;
2658 if (rq_data_dir(current_req) == READ) {
2659 raw_cmd->flags |= FD_RAW_READ;
2660 COMMAND = FM_MODE(_floppy,FD_READ);
2661 } else if (rq_data_dir(current_req) == WRITE){
2662 raw_cmd->flags |= FD_RAW_WRITE;
2663 COMMAND = FM_MODE(_floppy,FD_WRITE);
2665 DPRINT("make_raw_rw_request: unknown command\n");
2669 max_sector = _floppy->sect * _floppy->head;
2671 TRACK = (int)current_req->sector / max_sector;
2672 fsector_t = (int)current_req->sector % max_sector;
2673 if (_floppy->track && TRACK >= _floppy->track) {
2674 if (current_req->current_nr_sectors & 1) {
2675 current_count_sectors = 1;
2680 HEAD = fsector_t / _floppy->sect;
2682 if (((_floppy->stretch & FD_SWAPSIDES) || TESTF(FD_NEED_TWADDLE)) &&
2683 fsector_t < _floppy->sect)
2684 max_sector = _floppy->sect;
2686 /* 2M disks have phantom sectors on the first track */
2687 if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)){
2688 max_sector = 2 * _floppy->sect / 3;
2689 if (fsector_t >= max_sector){
2690 current_count_sectors = min_t(int, _floppy->sect - fsector_t,
2691 current_req->nr_sectors);
2696 SIZECODE = FD_SIZECODE(_floppy);
2697 raw_cmd->rate = _floppy->rate & 0x43;
2698 if ((_floppy->rate & FD_2M) &&
2707 raw_cmd->track = TRACK << STRETCH(_floppy);
2708 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy,HEAD);
2711 SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2712 SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) + 1;
2714 /* tracksize describes the size which can be filled up with sectors
2717 tracksize = _floppy->sect - _floppy->sect % ssize;
2718 if (tracksize < _floppy->sect){
2720 if (tracksize <= fsector_t % _floppy->sect)
2723 /* if we are beyond tracksize, fill up using smaller sectors */
2724 while (tracksize <= fsector_t % _floppy->sect){
2725 while(tracksize + ssize > _floppy->sect){
2729 SECTOR++; SECT_PER_TRACK ++;
2732 max_sector = HEAD * _floppy->sect + tracksize;
2733 } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2734 max_sector = _floppy->sect;
2735 } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2736 /* for virtual DMA bug workaround */
2737 max_sector = _floppy->sect;
2740 in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2741 aligned_sector_t = fsector_t - in_sector_offset;
2742 max_size = current_req->nr_sectors;
2743 if ((raw_cmd->track == buffer_track) &&
2744 (current_drive == buffer_drive) &&
2745 (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2746 /* data already in track buffer */
2747 if (CT(COMMAND) == FD_READ) {
2748 copy_buffer(1, max_sector, buffer_max);
2751 } else if (in_sector_offset || current_req->nr_sectors < ssize){
2752 if (CT(COMMAND) == FD_WRITE){
2753 if (fsector_t + current_req->nr_sectors > ssize &&
2754 fsector_t + current_req->nr_sectors < ssize + ssize)
2755 max_size = ssize + ssize;
2759 raw_cmd->flags &= ~FD_RAW_WRITE;
2760 raw_cmd->flags |= FD_RAW_READ;
2761 COMMAND = FM_MODE(_floppy,FD_READ);
2762 } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2763 unsigned long dma_limit;
2764 int direct, indirect;
2766 indirect= transfer_size(ssize,max_sector,max_buffer_sectors*2) -
2770 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2771 * on a 64 bit machine!
2773 max_size = buffer_chain_size();
2774 dma_limit = (MAX_DMA_ADDRESS - ((unsigned long) current_req->buffer)) >> 9;
2775 if ((unsigned long) max_size > dma_limit) {
2776 max_size = dma_limit;
2778 /* 64 kb boundaries */
2779 if (CROSS_64KB(current_req->buffer, max_size << 9))
2781 ((unsigned long)current_req->buffer) % K_64)>>9;
2782 direct = transfer_size(ssize,max_sector,max_size) - fsector_t;
2784 * We try to read tracks, but if we get too many errors, we
2785 * go back to reading just one sector at a time.
2787 * This means we should be able to read a sector even if there
2788 * are other bad sectors on this track.
2791 (indirect * 2 > direct * 3 &&
2792 *errors < DP->max_errors.read_track &&
2793 /*!TESTF(FD_NEED_TWADDLE) &&*/
2794 ((!probing || (DP->read_track&(1<<DRS->probed_format)))))){
2795 max_size = current_req->nr_sectors;
2797 raw_cmd->kernel_data = current_req->buffer;
2798 raw_cmd->length = current_count_sectors << 9;
2799 if (raw_cmd->length == 0){
2800 DPRINT("zero dma transfer attempted from make_raw_request\n");
2801 DPRINT("indirect=%d direct=%d fsector_t=%d",
2802 indirect, direct, fsector_t);
2805 /* check_dma_crossing(raw_cmd->kernel_data,
2807 "end of make_raw_request [1]");*/
2809 virtualdmabug_workaround();
2814 if (CT(COMMAND) == FD_READ)
2815 max_size = max_sector; /* unbounded */
2817 /* claim buffer track if needed */
2818 if (buffer_track != raw_cmd->track || /* bad track */
2819 buffer_drive !=current_drive || /* bad drive */
2820 fsector_t > buffer_max ||
2821 fsector_t < buffer_min ||
2822 ((CT(COMMAND) == FD_READ ||
2823 (!in_sector_offset && current_req->nr_sectors >= ssize))&&
2824 max_sector > 2 * max_buffer_sectors + buffer_min &&
2825 max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
2826 /* not enough space */){
2828 buffer_drive = current_drive;
2829 buffer_max = buffer_min = aligned_sector_t;
2831 raw_cmd->kernel_data = floppy_track_buffer +
2832 ((aligned_sector_t-buffer_min)<<9);
2834 if (CT(COMMAND) == FD_WRITE){
2835 /* copy write buffer to track buffer.
2836 * if we get here, we know that the write
2837 * is either aligned or the data already in the buffer
2838 * (buffer will be overwritten) */
2839 #ifdef FLOPPY_SANITY_CHECK
2840 if (in_sector_offset && buffer_track == -1)
2841 DPRINT("internal error offset !=0 on write\n");
2843 buffer_track = raw_cmd->track;
2844 buffer_drive = current_drive;
2845 copy_buffer(ssize, max_sector, 2*max_buffer_sectors+buffer_min);
2847 transfer_size(ssize, max_sector,
2848 2*max_buffer_sectors+buffer_min-aligned_sector_t);
2850 /* round up current_count_sectors to get dma xfer size */
2851 raw_cmd->length = in_sector_offset+current_count_sectors;
2852 raw_cmd->length = ((raw_cmd->length -1)|(ssize-1))+1;
2853 raw_cmd->length <<= 9;
2854 #ifdef FLOPPY_SANITY_CHECK
2855 /*check_dma_crossing(raw_cmd->kernel_data, raw_cmd->length,
2856 "end of make_raw_request");*/
2857 if ((raw_cmd->length < current_count_sectors << 9) ||
2858 (raw_cmd->kernel_data != current_req->buffer &&
2859 CT(COMMAND) == FD_WRITE &&
2860 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2861 aligned_sector_t < buffer_min)) ||
2862 raw_cmd->length % (128 << SIZECODE) ||
2863 raw_cmd->length <= 0 || current_count_sectors <= 0){
2864 DPRINT("fractionary current count b=%lx s=%lx\n",
2865 raw_cmd->length, current_count_sectors);
2866 if (raw_cmd->kernel_data != current_req->buffer)
2867 printk("addr=%d, length=%ld\n",
2868 (int) ((raw_cmd->kernel_data -
2869 floppy_track_buffer) >> 9),
2870 current_count_sectors);
2871 printk("st=%d ast=%d mse=%d msi=%d\n",
2872 fsector_t, aligned_sector_t, max_sector, max_size);
2873 printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2874 printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2875 COMMAND, SECTOR, HEAD, TRACK);
2876 printk("buffer drive=%d\n", buffer_drive);
2877 printk("buffer track=%d\n", buffer_track);
2878 printk("buffer_min=%d\n", buffer_min);
2879 printk("buffer_max=%d\n", buffer_max);
2883 if (raw_cmd->kernel_data != current_req->buffer){
2884 if (raw_cmd->kernel_data < floppy_track_buffer ||
2885 current_count_sectors < 0 ||
2886 raw_cmd->length < 0 ||
2887 raw_cmd->kernel_data + raw_cmd->length >
2888 floppy_track_buffer + (max_buffer_sectors << 10)){
2889 DPRINT("buffer overrun in schedule dma\n");
2890 printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
2891 fsector_t, buffer_min,
2892 raw_cmd->length >> 9);
2893 printk("current_count_sectors=%ld\n",
2894 current_count_sectors);
2895 if (CT(COMMAND) == FD_READ)
2897 if (CT(COMMAND) == FD_READ)
2901 } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
2902 current_count_sectors > current_req->nr_sectors){
2903 DPRINT("buffer overrun in direct transfer\n");
2905 } else if (raw_cmd->length < current_count_sectors << 9){
2906 DPRINT("more sectors than bytes\n");
2907 printk("bytes=%ld\n", raw_cmd->length >> 9);
2908 printk("sectors=%ld\n", current_count_sectors);
2910 if (raw_cmd->length == 0){
2911 DPRINT("zero dma transfer attempted from make_raw_request\n");
2916 virtualdmabug_workaround();
2920 static void redo_fd_request(void)
2922 #define REPEAT {request_done(0); continue; }
2927 if (current_drive < N_DRIVE)
2928 floppy_off(current_drive);
2932 struct request *req;
2934 spin_lock_irq(floppy_queue->queue_lock);
2935 req = elv_next_request(floppy_queue);
2936 spin_unlock_irq(floppy_queue->queue_lock);
2944 drive = (long)current_req->rq_disk->private_data;
2946 reschedule_timeout(current_reqD, "redo fd request", 0);
2949 raw_cmd = & default_raw_cmd;
2951 if (start_motor(redo_fd_request)) return;
2952 disk_change(current_drive);
2953 if (test_bit(current_drive, &fake_change) ||
2954 TESTF(FD_DISK_CHANGED)){
2955 DPRINT("disk absent or changed during operation\n");
2958 if (!_floppy) { /* Autodetection */
2960 DRS->probed_format = 0;
2961 if (next_valid_format()){
2962 DPRINT("no autodetectable formats\n");
2968 _floppy = floppy_type+DP->autodetect[DRS->probed_format];
2971 errors = & (current_req->errors);
2972 tmp = make_raw_rw_request();
2978 if (TESTF(FD_NEED_TWADDLE))
2980 schedule_bh(floppy_start);
2982 debugt("queue fd request");
2989 static struct cont_t rw_cont = {
2990 .interrupt = rw_interrupt,
2991 .redo = redo_fd_request,
2992 .error = bad_flp_intr,
2993 .done = request_done
2996 static void process_fd_request(void)
2999 schedule_bh(redo_fd_request);
3002 static void do_fd_request(request_queue_t * q)
3004 if(max_buffer_sectors == 0) {
3005 printk("VFS: do_fd_request called on non-open device\n");
3009 if (usage_count == 0) {
3010 printk("warning: usage count=0, current_req=%p exiting\n", current_req);
3011 printk("sect=%ld flags=%lx\n", (long)current_req->sector, current_req->flags);
3014 if (test_bit(0, &fdc_busy)) {
3015 /* fdc busy, this new request will be treated when the
3016 current one is done */
3017 is_alive("do fd request, old request running");
3020 lock_fdc(MAXTIMEOUT,0);
3021 process_fd_request();
3022 is_alive("do fd request");
3025 static struct cont_t poll_cont = {
3026 .interrupt = success_and_wakeup,
3027 .redo = floppy_ready,
3028 .error = generic_failure,
3029 .done = generic_done
3032 static int poll_drive(int interruptible, int flag)
3035 /* no auto-sense, just clear dcl */
3036 raw_cmd = &default_raw_cmd;
3037 raw_cmd->flags= flag;
3039 raw_cmd->cmd_count=0;
3042 if (DP->flags & FD_DEBUG){
3043 DPRINT("setting NEWCHANGE in poll_drive\n");
3046 SETF(FD_DISK_NEWCHANGE);
3052 * User triggered reset
3053 * ====================
3056 static void reset_intr(void)
3058 printk("weird, reset interrupt called\n");
3061 static struct cont_t reset_cont = {
3062 .interrupt = reset_intr,
3063 .redo = success_and_wakeup,
3064 .error = generic_failure,
3065 .done = generic_done
3068 static int user_reset_fdc(int drive, int arg, int interruptible)
3073 LOCK_FDC(drive,interruptible);
3074 if (arg == FD_RESET_ALWAYS)
3080 process_fd_request();
3085 * Misc Ioctl's and support
3086 * ========================
3088 static inline int fd_copyout(void *param, const void *address, unsigned long size)
3090 return copy_to_user(param,address, size) ? -EFAULT : 0;
3093 static inline int fd_copyin(void *param, void *address, unsigned long size)
3095 return copy_from_user(address, param, size) ? -EFAULT : 0;
3098 #define _COPYOUT(x) (copy_to_user((void *)param, &(x), sizeof(x)) ? -EFAULT : 0)
3099 #define _COPYIN(x) (copy_from_user(&(x), (void *)param, sizeof(x)) ? -EFAULT : 0)
3101 #define COPYOUT(x) ECALL(_COPYOUT(x))
3102 #define COPYIN(x) ECALL(_COPYIN(x))
3104 static inline const char *drive_name(int type, int drive)
3106 struct floppy_struct *floppy;
3109 floppy = floppy_type + type;
3111 if (UDP->native_format)
3112 floppy = floppy_type + UDP->native_format;
3117 return floppy->name;
3124 static void raw_cmd_done(int flag)
3129 raw_cmd->flags |= FD_RAW_FAILURE;
3130 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3132 raw_cmd->reply_count = inr;
3133 if (raw_cmd->reply_count > MAX_REPLIES)
3134 raw_cmd->reply_count=0;
3135 for (i=0; i< raw_cmd->reply_count; i++)
3136 raw_cmd->reply[i] = reply_buffer[i];
3138 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE))
3140 unsigned long flags;
3141 flags=claim_dma_lock();
3142 raw_cmd->length = fd_get_dma_residue();
3143 release_dma_lock(flags);
3146 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3147 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3148 raw_cmd->flags |= FD_RAW_FAILURE;
3150 if (disk_change(current_drive))
3151 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3153 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3154 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3155 motor_off_callback(current_drive);
3157 if (raw_cmd->next &&
3158 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3159 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3160 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3161 !(raw_cmd->flags &FD_RAW_STOP_IF_SUCCESS))) {
3162 raw_cmd = raw_cmd->next;
3170 static struct cont_t raw_cmd_cont = {
3171 .interrupt = success_and_wakeup,
3172 .redo = floppy_start,
3173 .error = generic_failure,
3174 .done = raw_cmd_done
3177 static inline int raw_cmd_copyout(int cmd, char *param,
3178 struct floppy_raw_cmd *ptr)
3184 param += sizeof(struct floppy_raw_cmd);
3185 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length){
3186 if (ptr->length>=0 && ptr->length<=ptr->buffer_length)
3187 ECALL(fd_copyout(ptr->data,
3189 ptr->buffer_length -
3198 static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3200 struct floppy_raw_cmd *next,*this;
3205 if (this->buffer_length) {
3206 fd_dma_mem_free((unsigned long)this->kernel_data,
3207 this->buffer_length);
3208 this->buffer_length = 0;
3217 static inline int raw_cmd_copyin(int cmd, char *param,
3218 struct floppy_raw_cmd **rcmd)
3220 struct floppy_raw_cmd *ptr;
3226 ptr = (struct floppy_raw_cmd *)
3227 kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3233 ptr->buffer_length = 0;
3234 param += sizeof(struct floppy_raw_cmd);
3235 if (ptr->cmd_count > 33)
3236 /* the command may now also take up the space
3237 * initially intended for the reply & the
3238 * reply count. Needed for long 82078 commands
3239 * such as RESTORE, which takes ... 17 command
3240 * bytes. Murphy's law #137: When you reserve
3241 * 16 bytes for a structure, you'll one day
3242 * discover that you really need 17...
3246 for (i=0; i< 16; i++)
3248 ptr->resultcode = 0;
3249 ptr->kernel_data = 0;
3251 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3252 if (ptr->length <= 0)
3254 ptr->kernel_data =(char*)fd_dma_mem_alloc(ptr->length);
3255 fallback_on_nodma_alloc(&ptr->kernel_data,
3257 if (!ptr->kernel_data)
3259 ptr->buffer_length = ptr->length;
3261 if (ptr->flags & FD_RAW_WRITE)
3262 ECALL(fd_copyin(ptr->data, ptr->kernel_data,
3264 rcmd = & (ptr->next);
3265 if (!(ptr->flags & FD_RAW_MORE))
3272 static int raw_cmd_ioctl(int cmd, void *param)
3274 int drive, ret, ret2;
3275 struct floppy_raw_cmd *my_raw_cmd;
3277 if (FDCS->rawcmd <= 1)
3279 for (drive= 0; drive < N_DRIVE; drive++){
3280 if (FDC(drive) != fdc)
3282 if (drive == current_drive){
3283 if (UDRS->fd_ref > 1){
3287 } else if (UDRS->fd_ref){
3296 ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3298 raw_cmd_free(&my_raw_cmd);
3302 raw_cmd = my_raw_cmd;
3303 cont = &raw_cmd_cont;
3304 ret=wait_til_done(floppy_start,1);
3306 if (DP->flags & FD_DEBUG){
3307 DPRINT("calling disk change from raw_cmd ioctl\n");
3311 if (ret != -EINTR && FDCS->reset)
3314 DRS->track = NO_TRACK;
3316 ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3319 raw_cmd_free(&my_raw_cmd);
3323 static int invalidate_drive(struct block_device *bdev)
3325 /* invalidate the buffer track to force a reread */
3326 set_bit((long)bdev->bd_disk->private_data, &fake_change);
3327 process_fd_request();
3328 check_disk_change(bdev);
3333 static inline void clear_write_error(int drive)
3338 static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
3339 int drive, int type, struct block_device *bdev)
3343 /* sanity checking for parameters.*/
3347 g->track > UDP->tracks>>STRETCH(g) ||
3348 /* check if reserved bits are set */
3349 (g->stretch&~(FD_STRETCH|FD_SWAPSIDES)) != 0)
3352 if (!capable(CAP_SYS_ADMIN))
3356 floppy_type[type] = *g;
3357 floppy_type[type].name="user format";
3358 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3359 floppy_sizes[cnt]= floppy_sizes[cnt+0x80]=
3360 floppy_type[type].size+1;
3361 process_fd_request();
3362 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3363 struct block_device *bdev = opened_bdev[cnt];
3364 if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3366 __invalidate_device(bdev, 0);
3371 if (cmd != FDDEFPRM)
3372 /* notice a disk change immediately, else
3373 * we lose our settings immediately*/
3374 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3375 user_params[drive] = *g;
3376 if (buffer_drive == drive)
3377 SUPBOUND(buffer_max, user_params[drive].sect);
3378 current_type[drive] = &user_params[drive];
3379 floppy_sizes[drive] = user_params[drive].size;
3380 if (cmd == FDDEFPRM)
3381 DRS->keep_data = -1;
3384 /* invalidation. Invalidate only when needed, i.e.
3385 * when there are already sectors in the buffer cache
3386 * whose number will change. This is useful, because
3387 * mtools often changes the geometry of the disk after
3388 * looking at the boot block */
3389 if (DRS->maxblock > user_params[drive].sect || DRS->maxtrack)
3390 invalidate_drive(bdev);
3392 process_fd_request();
3397 /* handle obsolete ioctl's */
3398 static int ioctl_table[]= {
3426 static inline int normalize_ioctl(int *cmd, int *size)
3430 for (i=0; i < ARRAY_SIZE(ioctl_table); i++) {
3431 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)){
3432 *size = _IOC_SIZE(*cmd);
3433 *cmd = ioctl_table[i];
3434 if (*size > _IOC_SIZE(*cmd)) {
3435 printk("ioctl not yet supported\n");
3444 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3447 *g = &floppy_type[type];
3450 CALL(poll_drive(0,0));
3451 process_fd_request();
3452 *g = current_type[drive];
3459 static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
3460 unsigned long param)
3462 #define FD_IOCTL_ALLOWED ((filp) && (filp)->private_data)
3463 #define OUT(c,x) case c: outparam = (const char *) (x); break
3464 #define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
3466 int drive = (long)inode->i_bdev->bd_disk->private_data;
3467 int i, type = ITYPE(UDRS->fd_device);
3471 struct floppy_struct g; /* geometry */
3472 struct format_descr f;
3473 struct floppy_max_errors max_errors;
3474 struct floppy_drive_params dp;
3475 } inparam; /* parameters coming from user space */
3476 const char *outparam; /* parameters passed back to user space */
3479 /* convert compatibility eject ioctls into floppy eject ioctl.
3480 * We do this in order to provide a means to eject floppy disks before
3481 * installing the new fdutils package */
3482 if (cmd == CDROMEJECT || /* CD-ROM eject */
3483 cmd == 0x6470 /* SunOS floppy eject */) {
3484 DPRINT("obsolete eject ioctl\n");
3485 DPRINT("please use floppycontrol --eject\n");
3489 /* generic block device ioctls */
3491 /* the following have been inspired by the corresponding
3492 * code for other block devices. */
3493 struct floppy_struct *g;
3496 struct hd_geometry loc;
3497 ECALL(get_floppy_geometry(drive, type, &g));
3498 loc.heads = g->head;
3499 loc.sectors = g->sect;
3500 loc.cylinders = g->track;
3502 return _COPYOUT(loc);
3506 /* convert the old style command into a new style command */
3507 if ((cmd & 0xff00) == 0x0200) {
3508 ECALL(normalize_ioctl(&cmd, &size));
3512 /* permission checks */
3513 if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
3514 ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3518 CLEARSTRUCT(&inparam);
3519 if (_IOC_DIR(cmd) & _IOC_WRITE)
3520 ECALL(fd_copyin((void *)param, &inparam, size))
3524 if (UDRS->fd_ref != 1)
3525 /* somebody else has this drive open */
3529 /* do the actual eject. Fails on
3530 * non-Sparc architectures */
3531 ret=fd_eject(UNIT(drive));
3533 USETF(FD_DISK_CHANGED);
3535 process_fd_request();
3539 current_type[drive] = NULL;
3540 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3541 UDRS->keep_data = 0;
3542 return invalidate_drive(inode->i_bdev);
3545 return set_geometry(cmd, & inparam.g,
3546 drive, type, inode->i_bdev);
3548 ECALL(get_floppy_geometry(drive, type,
3549 (struct floppy_struct**)
3554 UDP->flags |= FTD_MSG;
3557 UDP->flags &= ~FTD_MSG;
3562 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3564 process_fd_request();
3565 if (ret & FD_VERIFY)
3567 if (!(ret & FD_DISK_WRITABLE))
3571 if (UDRS->fd_ref != 1)
3573 return do_format(drive, &inparam.f);
3577 return invalidate_drive(inode->i_bdev);
3579 case FDSETEMSGTRESH:
3580 UDP->max_errors.reporting =
3581 (unsigned short) (param & 0x0f);
3583 OUT(FDGETMAXERRS, &UDP->max_errors);
3584 IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
3587 outparam = drive_name(type,drive);
3588 SUPBOUND(size,strlen(outparam)+1);
3591 IN(FDSETDRVPRM, UDP, dp);
3592 OUT(FDGETDRVPRM, UDP);
3596 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3597 process_fd_request();
3599 OUT(FDGETDRVSTAT, UDRS);
3602 return user_reset_fdc(drive, (int)param, 1);
3604 OUT(FDGETFDCSTAT,UFDCS);
3609 OUT(FDWERRORGET,UDRWE);
3616 CALL(i = raw_cmd_ioctl(cmd,(void *) param));
3617 process_fd_request();
3623 process_fd_request();
3630 if (_IOC_DIR(cmd) & _IOC_READ)
3631 return fd_copyout((void *)param, outparam, size);
3638 static void __init config_types(void)
3643 /* read drive info out of physical CMOS */
3646 UDP->cmos = FLOPPY0_TYPE;
3648 if (!UDP->cmos && FLOPPY1_TYPE)
3649 UDP->cmos = FLOPPY1_TYPE;
3652 /* additional physical CMOS drive detection should go here */
3654 for (drive=0; drive < N_DRIVE; drive++){
3655 unsigned int type = UDP->cmos;
3656 struct floppy_drive_params *params;
3657 const char *name = NULL;
3658 static char temparea[32];
3660 if (type < NUMBER(default_drive_params)) {
3661 params = &default_drive_params[type].params;
3663 name = default_drive_params[type].name;
3664 allowed_drive_mask |= 1 << drive;
3667 allowed_drive_mask &= ~(1 << drive);
3669 params = &default_drive_params[0].params;
3670 sprintf(temparea, "unknown type %d (usb?)", type);
3674 const char * prepend = ",";
3676 prepend = KERN_INFO "Floppy drive(s):";
3679 printk("%s fd%d is %s", prepend, drive, name);
3680 register_devfs_entries (drive);
3688 static int floppy_release(struct inode * inode, struct file * filp)
3690 int drive = (long)inode->i_bdev->bd_disk->private_data;
3693 if (UDRS->fd_ref < 0)
3695 else if (!UDRS->fd_ref--) {
3696 DPRINT("floppy_release with fd_ref == 0");
3700 opened_bdev[drive] = NULL;
3701 floppy_release_irq_and_dma();
3707 * floppy_open check for aliasing (/dev/fd0 can be the same as
3708 * /dev/PS0 etc), and disallows simultaneous access to the same
3709 * drive with different device numbers.
3711 static int floppy_open(struct inode * inode, struct file * filp)
3713 int drive = (long)inode->i_bdev->bd_disk->private_data;
3719 filp->private_data = (void*) 0;
3721 old_dev = UDRS->fd_device;
3722 if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
3725 if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)){
3726 USETF(FD_DISK_CHANGED);
3730 if (UDRS->fd_ref == -1 ||
3731 (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
3734 if (floppy_grab_irq_and_dma())
3737 if (filp->f_flags & O_EXCL)
3742 opened_bdev[drive] = inode->i_bdev;
3746 if (!floppy_track_buffer){
3747 /* if opening an ED drive, reserve a big buffer,
3748 * else reserve a small one */
3749 if ((UDP->cmos == 6) || (UDP->cmos == 5))
3750 try = 64; /* Only 48 actually useful */
3752 try = 32; /* Only 24 actually useful */
3754 tmp=(char *)fd_dma_mem_alloc(1024 * try);
3755 if (!tmp && !floppy_track_buffer) {
3756 try >>= 1; /* buffer only one side */
3758 tmp= (char *)fd_dma_mem_alloc(1024*try);
3760 if (!tmp && !floppy_track_buffer) {
3761 fallback_on_nodma_alloc(&tmp, 2048 * try);
3763 if (!tmp && !floppy_track_buffer) {
3764 DPRINT("Unable to allocate DMA memory\n");
3767 if (floppy_track_buffer) {
3769 fd_dma_mem_free((unsigned long)tmp,try*1024);
3771 buffer_min = buffer_max = -1;
3772 floppy_track_buffer = tmp;
3773 max_buffer_sectors = try;
3777 UDRS->fd_device = iminor(inode);
3778 set_capacity(disks[drive], floppy_sizes[iminor(inode)]);
3779 if (old_dev != -1 && old_dev != iminor(inode)) {
3780 if (buffer_drive == drive)
3784 /* Allow ioctls if we have write-permissions even if read-only open.
3785 * Needed so that programs such as fdrawcmd still can work on write
3786 * protected disks */
3787 if ((filp->f_mode & 2) ||
3788 (inode->i_sb && (permission(inode,2, NULL) == 0)))
3789 filp->private_data = (void*) 8;
3791 if (UFDCS->rawcmd == 1)
3794 if (!(filp->f_flags & O_NDELAY)) {
3795 if (filp->f_mode & 3) {
3796 UDRS->last_checked = 0;
3797 check_disk_change(inode->i_bdev);
3798 if (UTESTF(FD_DISK_CHANGED))
3802 if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
3808 if (UDRS->fd_ref < 0)
3813 opened_bdev[drive] = NULL;
3814 floppy_release_irq_and_dma();
3821 * Check if the disk has been changed or if a change has been faked.
3823 static int check_floppy_change(struct gendisk *disk)
3825 int drive = (long)disk->private_data;
3827 if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
3830 if (UDP->checkfreq < (int)(jiffies - UDRS->last_checked)) {
3831 if(floppy_grab_irq_and_dma()) {
3837 process_fd_request();
3838 floppy_release_irq_and_dma();
3841 if (UTESTF(FD_DISK_CHANGED) ||
3842 UTESTF(FD_VERIFY) ||
3843 test_bit(drive, &fake_change) ||
3844 (!ITYPE(UDRS->fd_device) && !current_type[drive]))
3850 * This implements "read block 0" for floppy_revalidate().
3851 * Needed for format autodetection, checking whether there is
3852 * a disk in the drive, and whether that disk is writable.
3855 static int floppy_rb0_complete(struct bio *bio, unsigned int bytes_done, int err)
3860 complete((struct completion*)bio->bi_private);
3864 static int __floppy_read_block_0(struct block_device *bdev)
3867 struct bio_vec bio_vec;
3868 struct completion complete;
3872 page = alloc_page(GFP_NOIO);
3874 process_fd_request();
3878 size = bdev->bd_block_size;
3883 bio.bi_io_vec = &bio_vec;
3884 bio_vec.bv_page = page;
3885 bio_vec.bv_len = size;
3886 bio_vec.bv_offset = 0;
3892 init_completion(&complete);
3893 bio.bi_private = &complete;
3894 bio.bi_end_io = floppy_rb0_complete;
3896 submit_bio(READ, &bio);
3897 generic_unplug_device(bdev_get_queue(bdev));
3898 process_fd_request();
3899 wait_for_completion(&complete);
3906 /* revalidate the floppy disk, i.e. trigger format autodetection by reading
3907 * the bootblock (block 0). "Autodetection" is also needed to check whether
3908 * there is a disk in the drive at all... Thus we also do it for fixed
3909 * geometry formats */
3910 static int floppy_revalidate(struct gendisk *disk)
3912 int drive=(long)disk->private_data;
3913 #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
3917 if (UTESTF(FD_DISK_CHANGED) ||
3918 UTESTF(FD_VERIFY) ||
3919 test_bit(drive, &fake_change) ||
3921 if(usage_count == 0) {
3922 printk("VFS: revalidate called on non-open device.\n");
3926 cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
3927 if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)){
3928 process_fd_request(); /*already done by another thread*/
3933 if (buffer_drive == drive)
3935 clear_bit(drive, &fake_change);
3936 UCLEARF(FD_DISK_CHANGED);
3941 res = __floppy_read_block_0(opened_bdev[drive]);
3944 poll_drive(0, FD_RAW_NEED_DISK);
3945 process_fd_request();
3948 set_capacity(disk, floppy_sizes[UDRS->fd_device]);
3952 static struct block_device_operations floppy_fops = {
3953 .owner = THIS_MODULE,
3954 .open = floppy_open,
3955 .release = floppy_release,
3957 .media_changed = check_floppy_change,
3958 .revalidate_disk= floppy_revalidate,
3960 static char *table[] =
3961 {"", "d360", "h1200", "u360", "u720", "h360", "h720",
3962 "u1440", "u2880", "CompaQ", "h1440", "u1680", "h410",
3963 "u820", "h1476", "u1722", "h420", "u830", "h1494", "u1743",
3964 "h880", "u1040", "u1120", "h1600", "u1760", "u1920",
3965 "u3200", "u3520", "u3840", "u1840", "u800", "u1600",
3968 static int t360[] = {1,0}, t1200[] = {2,5,6,10,12,14,16,18,20,23,0},
3969 t3in[] = {8,9,26,27,28, 7,11,15,19,24,25,29,31, 3,4,13,17,21,22,30,0};
3970 static int *table_sup[] =
3971 {NULL, t360, t1200, t3in+5+8, t3in+5, t3in, t3in};
3973 static void __init register_devfs_entries (int drive)
3975 int base_minor = (drive < 4) ? drive : (124 + drive);
3977 if (UDP->cmos < NUMBER(default_drive_params)) {
3980 int minor = base_minor + (table_sup[UDP->cmos][i] << 2);
3982 devfs_mk_bdev(MKDEV(FLOPPY_MAJOR, minor),
3983 S_IFBLK|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP,
3985 drive, table[table_sup[UDP->cmos][i]]);
3986 } while (table_sup[UDP->cmos][i++]);
3991 * Floppy Driver initialization
3992 * =============================
3995 /* Determine the floppy disk controller type */
3996 /* This routine was written by David C. Niemi */
3997 static char __init get_fdc_version(void)
4001 output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */
4004 if ((r = result()) <= 0x00)
4005 return FDC_NONE; /* No FDC present ??? */
4006 if ((r==1) && (reply_buffer[0] == 0x80)){
4007 printk(KERN_INFO "FDC %d is an 8272A\n",fdc);
4008 return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
4011 printk("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
4016 if (!fdc_configure()) {
4017 printk(KERN_INFO "FDC %d is an 82072\n",fdc);
4018 return FDC_82072; /* 82072 doesn't know CONFIGURE */
4021 output_byte(FD_PERPENDICULAR);
4022 if (need_more_output() == MORE_OUTPUT) {
4025 printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
4026 return FDC_82072A; /* 82072A as found on Sparcs. */
4029 output_byte(FD_UNLOCK);
4031 if ((r == 1) && (reply_buffer[0] == 0x80)){
4032 printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
4033 return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
4036 if ((r != 1) || (reply_buffer[0] != 0x00)) {
4037 printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
4041 output_byte(FD_PARTID);
4044 printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
4048 if (reply_buffer[0] == 0x80) {
4049 printk(KERN_INFO "FDC %d is a post-1991 82077\n",fdc);
4050 return FDC_82077; /* Revised 82077AA passes all the tests */
4052 switch (reply_buffer[0] >> 5) {
4054 /* Either a 82078-1 or a 82078SL running at 5Volt */
4055 printk(KERN_INFO "FDC %d is an 82078.\n",fdc);
4058 printk(KERN_INFO "FDC %d is a 44pin 82078\n",fdc);
4061 printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
4064 printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n", fdc);
4067 printk(KERN_INFO "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
4068 fdc, reply_buffer[0] >> 5);
4069 return FDC_82078_UNKN;
4071 } /* get_fdc_version */
4073 /* lilo configuration */
4075 static void __init floppy_set_flags(int *ints,int param, int param2)
4079 for (i=0; i < ARRAY_SIZE(default_drive_params); i++){
4081 default_drive_params[i].params.flags |= param2;
4083 default_drive_params[i].params.flags &= ~param2;
4085 DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4088 static void __init daring(int *ints,int param, int param2)
4092 for (i=0; i < ARRAY_SIZE(default_drive_params); i++){
4094 default_drive_params[i].params.select_delay = 0;
4095 default_drive_params[i].params.flags |= FD_SILENT_DCL_CLEAR;
4097 default_drive_params[i].params.select_delay = 2*HZ/100;
4098 default_drive_params[i].params.flags &= ~FD_SILENT_DCL_CLEAR;
4101 DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4104 static void __init set_cmos(int *ints, int dummy, int dummy2)
4106 int current_drive=0;
4109 DPRINT("wrong number of parameters for CMOS\n");
4112 current_drive = ints[1];
4113 if (current_drive < 0 || current_drive >= 8){
4114 DPRINT("bad drive for set_cmos\n");
4118 if (current_drive >= 4 && !FDC2)
4122 DPRINT("setting CMOS code to %d\n", ints[2]);
4125 static struct param_table {
4127 void (*fn)(int *ints, int param, int param2);
4132 { "allowed_drive_mask", 0, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4133 { "all_drives", 0, &allowed_drive_mask, 0xff, 0 }, /* obsolete */
4134 { "asus_pci", 0, &allowed_drive_mask, 0x33, 0},
4136 { "irq", 0, &FLOPPY_IRQ, 6, 0 },
4137 { "dma", 0, &FLOPPY_DMA, 2, 0 },
4139 { "daring", daring, 0, 1, 0},
4141 { "two_fdc", 0, &FDC2, 0x370, 0 },
4142 { "one_fdc", 0, &FDC2, 0, 0 },
4144 { "thinkpad", floppy_set_flags, 0, 1, FD_INVERTED_DCL },
4145 { "broken_dcl", floppy_set_flags, 0, 1, FD_BROKEN_DCL },
4146 { "messages", floppy_set_flags, 0, 1, FTD_MSG },
4147 { "silent_dcl_clear", floppy_set_flags, 0, 1, FD_SILENT_DCL_CLEAR },
4148 { "debug", floppy_set_flags, 0, 1, FD_DEBUG },
4150 { "nodma", 0, &can_use_virtual_dma, 1, 0 },
4151 { "omnibook", 0, &can_use_virtual_dma, 1, 0 },
4152 { "yesdma", 0, &can_use_virtual_dma, 0, 0 },
4154 { "fifo_depth", 0, &fifo_depth, 0xa, 0 },
4155 { "nofifo", 0, &no_fifo, 0x20, 0 },
4156 { "usefifo", 0, &no_fifo, 0, 0 },
4158 { "cmos", set_cmos, 0, 0, 0 },
4159 { "slow", 0, &slow_floppy, 1, 0 },
4161 { "unexpected_interrupts", 0, &print_unex, 1, 0 },
4162 { "no_unexpected_interrupts", 0, &print_unex, 0, 0 },
4163 { "L40SX", 0, &print_unex, 0, 0 }
4168 static int __init floppy_setup(char *str)
4174 str = get_options(str,ARRAY_SIZE(ints),ints);
4176 for (i=0; i< ARRAY_SIZE(config_params); i++){
4177 if (strcmp(str,config_params[i].name) == 0){
4181 param = config_params[i].def_param;
4182 if (config_params[i].fn)
4185 config_params[i].param2);
4186 if (config_params[i].var) {
4187 DPRINT("%s=%d\n", str, param);
4188 *config_params[i].var = param;
4195 DPRINT("unknown floppy option [%s]\n", str);
4197 DPRINT("allowed options are:");
4198 for (i=0; i< ARRAY_SIZE(config_params); i++)
4199 printk(" %s",config_params[i].name);
4202 DPRINT("botched floppy option\n");
4203 DPRINT("Read linux/Documentation/floppy.txt\n");
4207 static int have_no_fdc= -ENODEV;
4209 static void floppy_device_release(struct device *dev)
4211 complete(&device_release);
4214 static struct platform_device floppy_device = {
4218 .release = floppy_device_release,
4222 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4224 int drive = (*part&3) | ((*part&0x80) >> 5);
4225 if (drive >= N_DRIVE ||
4226 !(allowed_drive_mask & (1 << drive)) ||
4227 fdc_state[FDC(drive)].version == FDC_NONE)
4229 if (((*part >> 2) & 0x1f) >= NUMBER(floppy_type))
4232 return get_disk(disks[drive]);
4235 int __init floppy_init(void)
4242 for (i=0; i<N_DRIVE; i++) {
4243 disks[i] = alloc_disk(1);
4248 devfs_mk_dir ("floppy");
4249 if ((err = register_blkdev(FLOPPY_MAJOR,"fd")))
4252 floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
4253 blk_queue_max_sectors(floppy_queue, 64);
4254 if (!floppy_queue) {
4259 for (i=0; i<N_DRIVE; i++) {
4260 disks[i]->major = FLOPPY_MAJOR;
4261 disks[i]->first_minor = TOMINOR(i);
4262 disks[i]->fops = &floppy_fops;
4263 sprintf(disks[i]->disk_name, "fd%d", i);
4266 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4267 floppy_find, NULL, NULL);
4269 for (i=0; i<256; i++)
4271 floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4273 floppy_sizes[i] = MAX_DISK_SIZE << 1;
4275 reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
4278 for (i = 0; i < N_FDC; i++) {
4283 #if defined(__sparc__) || defined(__mc68000__)
4284 /*sparcs/sun3x don't have a DOR reset which we can fall back on to*/
4288 FDCS->version = FDC_82072A;
4292 use_virtual_dma = can_use_virtual_dma & 1;
4293 fdc_state[0].address = FDC1;
4294 if (fdc_state[0].address == -1) {
4299 fdc_state[1].address = FDC2;
4302 fdc = 0; /* reset fdc in case of unexpected interrupt */
4303 if (floppy_grab_irq_and_dma()){
4308 /* initialise drive state */
4309 for (drive = 0; drive < N_DRIVE; drive++) {
4312 USETF(FD_DISK_NEWCHANGE);
4313 USETF(FD_DISK_CHANGED);
4315 UDRS->fd_device = -1;
4316 floppy_track_buffer = NULL;
4317 max_buffer_sectors = 0;
4320 for (i = 0; i < N_FDC; i++) {
4322 FDCS->driver_version = FD_DRIVER_VERSION;
4323 for (unit=0; unit<4; unit++)
4324 FDCS->track[unit] = 0;
4325 if (FDCS->address == -1)
4328 if (user_reset_fdc(-1,FD_RESET_ALWAYS,0)){
4329 /* free ioports reserved by floppy_grab_irq_and_dma() */
4330 release_region(FDCS->address+2, 4);
4331 release_region(FDCS->address+7, 1);
4333 FDCS->version = FDC_NONE;
4336 /* Try to determine the floppy controller type */
4337 FDCS->version = get_fdc_version();
4338 if (FDCS->version == FDC_NONE){
4339 /* free ioports reserved by floppy_grab_irq_and_dma() */
4340 release_region(FDCS->address+2, 4);
4341 release_region(FDCS->address+7, 1);
4345 if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
4346 can_use_virtual_dma = 0;
4349 /* Not all FDCs seem to be able to handle the version command
4350 * properly, so force a reset for the standard FDC clones,
4351 * to avoid interrupt garbage.
4353 user_reset_fdc(-1,FD_RESET_ALWAYS,0);
4356 del_timer(&fd_timeout);
4358 floppy_release_irq_and_dma();
4361 DPRINT("no floppy controllers found\n");
4362 flush_scheduled_work();
4364 floppy_release_irq_and_dma();
4369 for (drive = 0; drive < N_DRIVE; drive++) {
4370 init_timer(&motor_off_timer[drive]);
4371 motor_off_timer[drive].data = drive;
4372 motor_off_timer[drive].function = motor_off_callback;
4373 if (!(allowed_drive_mask & (1 << drive)))
4375 if (fdc_state[FDC(drive)].version == FDC_NONE)
4377 /* to be cleaned up... */
4378 disks[drive]->private_data = (void*)(long)drive;
4379 disks[drive]->queue = floppy_queue;
4380 add_disk(disks[drive]);
4383 platform_device_register(&floppy_device);
4387 del_timer(&fd_timeout);
4389 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4390 blk_cleanup_queue(floppy_queue);
4392 unregister_blkdev(FLOPPY_MAJOR,"fd");
4394 for (i=0; i<N_DRIVE; i++)
4396 devfs_remove("floppy");
4405 static spinlock_t floppy_usage_lock = SPIN_LOCK_UNLOCKED;
4407 static int floppy_grab_irq_and_dma(void)
4409 unsigned long flags;
4411 spin_lock_irqsave(&floppy_usage_lock, flags);
4413 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4416 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4417 if (fd_request_irq()) {
4418 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4420 spin_lock_irqsave(&floppy_usage_lock, flags);
4422 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4425 if (fd_request_dma()) {
4426 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4429 spin_lock_irqsave(&floppy_usage_lock, flags);
4431 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4435 for (fdc=0; fdc< N_FDC; fdc++){
4436 if (FDCS->address != -1){
4437 if (!request_region(FDCS->address+2, 4, "floppy")) {
4438 DPRINT("Floppy io-port 0x%04lx in use\n", FDCS->address + 2);
4441 if (!request_region(FDCS->address+7, 1, "floppy DIR")) {
4442 DPRINT("Floppy io-port 0x%04lx in use\n", FDCS->address + 7);
4445 /* address + 6 is reserved, and may be taken by IDE.
4446 * Unfortunately, Adaptec doesn't know this :-(, */
4449 for (fdc=0; fdc< N_FDC; fdc++){
4450 if (FDCS->address != -1){
4452 fd_outb(FDCS->dor, FD_DOR);
4456 set_dor(0, ~0, 8); /* avoid immediate interrupt */
4458 for (fdc = 0; fdc < N_FDC; fdc++)
4459 if (FDCS->address != -1)
4460 fd_outb(FDCS->dor, FD_DOR);
4462 * The driver will try and free resources and relies on us
4463 * to know if they were allocated or not.
4466 irqdma_allocated = 1;
4469 release_region(FDCS->address + 2, 4);
4474 release_region(FDCS->address + 2, 4);
4475 release_region(FDCS->address + 7, 1);
4477 spin_lock_irqsave(&floppy_usage_lock, flags);
4479 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4483 static void floppy_release_irq_and_dma(void)
4486 #ifdef FLOPPY_SANITY_CHECK
4492 unsigned long tmpaddr;
4493 unsigned long flags;
4495 spin_lock_irqsave(&floppy_usage_lock, flags);
4497 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4500 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4501 if(irqdma_allocated)
4512 floppy_enable_hlt();
4514 if (floppy_track_buffer && max_buffer_sectors) {
4515 tmpsize = max_buffer_sectors*1024;
4516 tmpaddr = (unsigned long)floppy_track_buffer;
4517 floppy_track_buffer = NULL;
4518 max_buffer_sectors = 0;
4519 buffer_min = buffer_max = -1;
4520 fd_dma_mem_free(tmpaddr, tmpsize);
4523 #ifdef FLOPPY_SANITY_CHECK
4525 for (drive=0; drive < N_FDC * 4; drive++)
4526 if (timer_pending(motor_off_timer + drive))
4527 printk("motor off timer %d still active\n", drive);
4530 if (timer_pending(&fd_timeout))
4531 printk("floppy timer still active:%s\n", timeout_message);
4532 if (timer_pending(&fd_timer))
4533 printk("auxiliary floppy timer still active\n");
4534 if (floppy_work.pending)
4535 printk("work still pending\n");
4538 for (fdc = 0; fdc < N_FDC; fdc++)
4539 if (FDCS->address != -1) {
4540 release_region(FDCS->address+2, 4);
4541 release_region(FDCS->address+7, 1);
4551 static void unregister_devfs_entries (int drive)
4555 if (UDP->cmos < NUMBER(default_drive_params)) {
4558 devfs_remove("floppy/%d%s", drive, table[table_sup[UDP->cmos][i]]);
4559 } while (table_sup[UDP->cmos][i++]);
4563 static void __init parse_floppy_cfg_string(char *cfg)
4568 for(ptr = cfg;*cfg && *cfg != ' ' && *cfg != '\t'; cfg++);
4578 int init_module(void)
4580 printk(KERN_INFO "inserting floppy driver for " UTS_RELEASE "\n");
4583 parse_floppy_cfg_string(floppy);
4584 return floppy_init();
4587 void cleanup_module(void)
4591 init_completion(&device_release);
4592 platform_device_unregister(&floppy_device);
4593 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4594 unregister_blkdev(FLOPPY_MAJOR, "fd");
4596 for (drive = 0; drive < N_DRIVE; drive++) {
4597 del_timer_sync(&motor_off_timer[drive]);
4599 if ((allowed_drive_mask & (1 << drive)) &&
4600 fdc_state[FDC(drive)].version != FDC_NONE) {
4601 del_gendisk(disks[drive]);
4602 unregister_devfs_entries(drive);
4604 put_disk(disks[drive]);
4606 devfs_remove("floppy");
4608 del_timer_sync(&fd_timeout);
4609 del_timer_sync(&fd_timer);
4610 blk_cleanup_queue(floppy_queue);
4613 floppy_release_irq_and_dma();
4615 /* eject disk, if any */
4618 wait_for_completion(&device_release);
4621 MODULE_PARM(floppy,"s");
4622 MODULE_PARM(FLOPPY_IRQ,"i");
4623 MODULE_PARM(FLOPPY_DMA,"i");
4624 MODULE_AUTHOR("Alain L. Knaff");
4625 MODULE_SUPPORTED_DEVICE("fd");
4626 MODULE_LICENSE("GPL");
4630 __setup ("floppy=", floppy_setup);
4631 module_init(floppy_init)
4634 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);