[PATCH] Represent laptop_mode as jiffies internally
[linux-2.6/verdex.git] / drivers / block / floppy.c
blobfb2d0be7cdebb21444f6b978f7c0ea4d82895579
1 /*
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
7 */
8 /*
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
28 * etc.
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
45 * recording support.
47 * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
49 * TODO: Errors are still not counted properly.
52 /* 1992/9/20
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
65 * work.
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
73 * disk types.
77 * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
78 * format bug fixes, but unfortunately some new bugs too...
81 /* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
82 * errors to allow safe writing by specialized programs.
85 /* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
86 * by defining bit 1 of the "stretch" parameter to mean put sectors on the
87 * opposite side of the disk, leaving the sector IDs alone (i.e. Commodore's
88 * drives are "upside-down").
92 * 1995/8/26 -- Andreas Busse -- added Mips support.
96 * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
97 * features to asm/floppy.h.
101 * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
105 * 1998/05/07 -- Russell King -- More portability cleanups; moved definition of
106 * interrupt and dma channel to asm/floppy.h. Cleaned up some formatting &
107 * use of '0' for NULL.
111 * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
112 * failures.
116 * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
120 * 1999/08/13 -- Paul Slootman -- floppy stopped working on Alpha after 24
121 * days, 6 hours, 32 minutes and 32 seconds (i.e. MAXINT jiffies; ints were
122 * being used to store jiffies, which are unsigned longs).
126 * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
127 * - get rid of check_region
128 * - s/suser/capable/
132 * 2001/08/26 -- Paul Gortmaker - fix insmod oops on machines with no
133 * floppy controller (lingering task on list after module is gone... boom.)
137 * 2002/02/07 -- Anton Altaparmakov - Fix io ports reservation to correct range
138 * (0x3f2-0x3f5, 0x3f7). This fix is a bit of a hack but the proper fix
139 * requires many non-obvious changes in arch dependent code.
142 /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
143 * Better audit of register_blkdev.
146 #define FLOPPY_SANITY_CHECK
147 #undef FLOPPY_SILENT_DCL_CLEAR
149 #define REALLY_SLOW_IO
151 #define DEBUGT 2
152 #define DCL_DEBUG /* debug disk change line */
154 /* do print messages for unexpected interrupts */
155 static int print_unex = 1;
156 #include <linux/module.h>
157 #include <linux/sched.h>
158 #include <linux/fs.h>
159 #include <linux/kernel.h>
160 #include <linux/timer.h>
161 #include <linux/workqueue.h>
162 #define FDPATCHES
163 #include <linux/fdreg.h>
165 #include <linux/fd.h>
166 #include <linux/hdreg.h>
168 #include <linux/errno.h>
169 #include <linux/slab.h>
170 #include <linux/mm.h>
171 #include <linux/bio.h>
172 #include <linux/string.h>
173 #include <linux/fcntl.h>
174 #include <linux/delay.h>
175 #include <linux/mc146818rtc.h> /* CMOS defines */
176 #include <linux/ioport.h>
177 #include <linux/interrupt.h>
178 #include <linux/init.h>
179 #include <linux/devfs_fs_kernel.h>
180 #include <linux/platform_device.h>
181 #include <linux/buffer_head.h> /* for invalidate_buffers() */
182 #include <linux/mutex.h>
185 * PS/2 floppies have much slower step rates than regular floppies.
186 * It's been recommended that take about 1/4 of the default speed
187 * in some more extreme cases.
189 static int slow_floppy;
191 #include <asm/dma.h>
192 #include <asm/irq.h>
193 #include <asm/system.h>
194 #include <asm/io.h>
195 #include <asm/uaccess.h>
197 static int FLOPPY_IRQ = 6;
198 static int FLOPPY_DMA = 2;
199 static int can_use_virtual_dma = 2;
200 /* =======
201 * can use virtual DMA:
202 * 0 = use of virtual DMA disallowed by config
203 * 1 = use of virtual DMA prescribed by config
204 * 2 = no virtual DMA preference configured. By default try hard DMA,
205 * but fall back on virtual DMA when not enough memory available
208 static int use_virtual_dma;
209 /* =======
210 * use virtual DMA
211 * 0 using hard DMA
212 * 1 using virtual DMA
213 * This variable is set to virtual when a DMA mem problem arises, and
214 * reset back in floppy_grab_irq_and_dma.
215 * It is not safe to reset it in other circumstances, because the floppy
216 * driver may have several buffers in use at once, and we do currently not
217 * record each buffers capabilities
220 static DEFINE_SPINLOCK(floppy_lock);
221 static struct completion device_release;
223 static unsigned short virtual_dma_port = 0x3f0;
224 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
225 static int set_dor(int fdc, char mask, char data);
226 static void register_devfs_entries(int drive) __init;
228 #define K_64 0x10000 /* 64KB */
230 /* the following is the mask of allowed drives. By default units 2 and
231 * 3 of both floppy controllers are disabled, because switching on the
232 * motor of these drives causes system hangs on some PCI computers. drive
233 * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
234 * a drive is allowed.
236 * NOTE: This must come before we include the arch floppy header because
237 * some ports reference this variable from there. -DaveM
240 static int allowed_drive_mask = 0x33;
242 #include <asm/floppy.h>
244 static int irqdma_allocated;
246 #define DEVICE_NAME "floppy"
248 #include <linux/blkdev.h>
249 #include <linux/blkpg.h>
250 #include <linux/cdrom.h> /* for the compatibility eject ioctl */
251 #include <linux/completion.h>
253 static struct request *current_req;
254 static struct request_queue *floppy_queue;
255 static void do_fd_request(request_queue_t * q);
257 #ifndef fd_get_dma_residue
258 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
259 #endif
261 /* Dma Memory related stuff */
263 #ifndef fd_dma_mem_free
264 #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
265 #endif
267 #ifndef fd_dma_mem_alloc
268 #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
269 #endif
271 static inline void fallback_on_nodma_alloc(char **addr, size_t l)
273 #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
274 if (*addr)
275 return; /* we have the memory */
276 if (can_use_virtual_dma != 2)
277 return; /* no fallback allowed */
278 printk
279 ("DMA memory shortage. Temporarily falling back on virtual DMA\n");
280 *addr = (char *)nodma_mem_alloc(l);
281 #else
282 return;
283 #endif
286 /* End dma memory related stuff */
288 static unsigned long fake_change;
289 static int initialising = 1;
291 #define ITYPE(x) (((x)>>2) & 0x1f)
292 #define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
293 #define UNIT(x) ((x) & 0x03) /* drive on fdc */
294 #define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
295 #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
296 /* reverse mapping from unit and fdc to drive */
297 #define DP (&drive_params[current_drive])
298 #define DRS (&drive_state[current_drive])
299 #define DRWE (&write_errors[current_drive])
300 #define FDCS (&fdc_state[fdc])
301 #define CLEARF(x) (clear_bit(x##_BIT, &DRS->flags))
302 #define SETF(x) (set_bit(x##_BIT, &DRS->flags))
303 #define TESTF(x) (test_bit(x##_BIT, &DRS->flags))
305 #define UDP (&drive_params[drive])
306 #define UDRS (&drive_state[drive])
307 #define UDRWE (&write_errors[drive])
308 #define UFDCS (&fdc_state[FDC(drive)])
309 #define UCLEARF(x) (clear_bit(x##_BIT, &UDRS->flags))
310 #define USETF(x) (set_bit(x##_BIT, &UDRS->flags))
311 #define UTESTF(x) (test_bit(x##_BIT, &UDRS->flags))
313 #define DPRINT(format, args...) printk(DEVICE_NAME "%d: " format, current_drive , ## args)
315 #define PH_HEAD(floppy,head) (((((floppy)->stretch & 2) >>1) ^ head) << 2)
316 #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
318 #define CLEARSTRUCT(x) memset((x), 0, sizeof(*(x)))
320 /* read/write */
321 #define COMMAND raw_cmd->cmd[0]
322 #define DR_SELECT raw_cmd->cmd[1]
323 #define TRACK raw_cmd->cmd[2]
324 #define HEAD raw_cmd->cmd[3]
325 #define SECTOR raw_cmd->cmd[4]
326 #define SIZECODE raw_cmd->cmd[5]
327 #define SECT_PER_TRACK raw_cmd->cmd[6]
328 #define GAP raw_cmd->cmd[7]
329 #define SIZECODE2 raw_cmd->cmd[8]
330 #define NR_RW 9
332 /* format */
333 #define F_SIZECODE raw_cmd->cmd[2]
334 #define F_SECT_PER_TRACK raw_cmd->cmd[3]
335 #define F_GAP raw_cmd->cmd[4]
336 #define F_FILL raw_cmd->cmd[5]
337 #define NR_F 6
340 * Maximum disk size (in kilobytes). This default is used whenever the
341 * current disk size is unknown.
342 * [Now it is rather a minimum]
344 #define MAX_DISK_SIZE 4 /* 3984 */
347 * globals used by 'result()'
349 #define MAX_REPLIES 16
350 static unsigned char reply_buffer[MAX_REPLIES];
351 static int inr; /* size of reply buffer, when called from interrupt */
352 #define ST0 (reply_buffer[0])
353 #define ST1 (reply_buffer[1])
354 #define ST2 (reply_buffer[2])
355 #define ST3 (reply_buffer[0]) /* result of GETSTATUS */
356 #define R_TRACK (reply_buffer[3])
357 #define R_HEAD (reply_buffer[4])
358 #define R_SECTOR (reply_buffer[5])
359 #define R_SIZECODE (reply_buffer[6])
361 #define SEL_DLY (2*HZ/100)
364 * this struct defines the different floppy drive types.
366 static struct {
367 struct floppy_drive_params params;
368 const char *name; /* name printed while booting */
369 } default_drive_params[] = {
370 /* NOTE: the time values in jiffies should be in msec!
371 CMOS drive type
372 | Maximum data rate supported by drive type
373 | | Head load time, msec
374 | | | Head unload time, msec (not used)
375 | | | | Step rate interval, usec
376 | | | | | Time needed for spinup time (jiffies)
377 | | | | | | Timeout for spinning down (jiffies)
378 | | | | | | | Spindown offset (where disk stops)
379 | | | | | | | | Select delay
380 | | | | | | | | | RPS
381 | | | | | | | | | | Max number of tracks
382 | | | | | | | | | | | Interrupt timeout
383 | | | | | | | | | | | | Max nonintlv. sectors
384 | | | | | | | | | | | | | -Max Errors- flags */
385 {{0, 500, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 80, 3*HZ, 20, {3,1,2,0,2}, 0,
386 0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
388 {{1, 300, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 40, 3*HZ, 17, {3,1,2,0,2}, 0,
389 0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
391 {{2, 500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6, 83, 3*HZ, 17, {3,1,2,0,2}, 0,
392 0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
394 {{3, 250, 16, 16, 3000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
395 0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
397 {{4, 500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
398 0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
400 {{5, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
401 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
403 {{6, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
404 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
405 /* | --autodetected formats--- | | |
406 * read_track | | Name printed when booting
407 * | Native format
408 * Frequency of disk change checks */
411 static struct floppy_drive_params drive_params[N_DRIVE];
412 static struct floppy_drive_struct drive_state[N_DRIVE];
413 static struct floppy_write_errors write_errors[N_DRIVE];
414 static struct timer_list motor_off_timer[N_DRIVE];
415 static struct gendisk *disks[N_DRIVE];
416 static struct block_device *opened_bdev[N_DRIVE];
417 static DEFINE_MUTEX(open_lock);
418 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
421 * This struct defines the different floppy types.
423 * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
424 * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
425 * tells if the disk is in Commodore 1581 format, which means side 0 sectors
426 * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
427 * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
428 * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
429 * side 0 is on physical side 0 (but with the misnamed sector IDs).
430 * 'stretch' should probably be renamed to something more general, like
431 * 'options'. Other parameters should be self-explanatory (see also
432 * setfdprm(8)).
435 Size
436 | Sectors per track
437 | | Head
438 | | | Tracks
439 | | | | Stretch
440 | | | | | Gap 1 size
441 | | | | | | Data rate, | 0x40 for perp
442 | | | | | | | Spec1 (stepping rate, head unload
443 | | | | | | | | /fmt gap (gap2) */
444 static struct floppy_struct floppy_type[32] = {
445 { 0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL }, /* 0 no testing */
446 { 720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360" }, /* 1 360KB PC */
447 { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /* 2 1.2MB AT */
448 { 720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360" }, /* 3 360KB SS 3.5" */
449 { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720" }, /* 4 720KB 3.5" */
450 { 720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360" }, /* 5 360KB AT */
451 { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720" }, /* 6 720KB AT */
452 { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /* 7 1.44MB 3.5" */
453 { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /* 8 2.88MB 3.5" */
454 { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /* 9 3.12MB 3.5" */
456 { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25" */
457 { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5" */
458 { 820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410" }, /* 12 410KB 5.25" */
459 { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820" }, /* 13 820KB 3.5" */
460 { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25" */
461 { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5" */
462 { 840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420" }, /* 16 420KB 5.25" */
463 { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830" }, /* 17 830KB 3.5" */
464 { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25" */
465 { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5" */
467 { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880" }, /* 20 880KB 5.25" */
468 { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5" */
469 { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5" */
470 { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25" */
471 { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5" */
472 { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5" */
473 { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5" */
474 { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5" */
475 { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5" */
477 { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5" */
478 { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800" }, /* 30 800KB 3.5" */
479 { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5" */
482 #define SECTSIZE (_FD_SECTSIZE(*floppy))
484 /* Auto-detection: Disk type used until the next media change occurs. */
485 static struct floppy_struct *current_type[N_DRIVE];
488 * User-provided type information. current_type points to
489 * the respective entry of this array.
491 static struct floppy_struct user_params[N_DRIVE];
493 static sector_t floppy_sizes[256];
495 static char floppy_device_name[] = "floppy";
498 * The driver is trying to determine the correct media format
499 * while probing is set. rw_interrupt() clears it after a
500 * successful access.
502 static int probing;
504 /* Synchronization of FDC access. */
505 #define FD_COMMAND_NONE -1
506 #define FD_COMMAND_ERROR 2
507 #define FD_COMMAND_OKAY 3
509 static volatile int command_status = FD_COMMAND_NONE;
510 static unsigned long fdc_busy;
511 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
512 static DECLARE_WAIT_QUEUE_HEAD(command_done);
514 #define NO_SIGNAL (!interruptible || !signal_pending(current))
515 #define CALL(x) if ((x) == -EINTR) return -EINTR
516 #define ECALL(x) if ((ret = (x))) return ret;
517 #define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
518 #define WAIT(x) _WAIT((x),interruptible)
519 #define IWAIT(x) _WAIT((x),1)
521 /* Errors during formatting are counted here. */
522 static int format_errors;
524 /* Format request descriptor. */
525 static struct format_descr format_req;
528 * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
529 * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
530 * H is head unload time (1=16ms, 2=32ms, etc)
534 * Track buffer
535 * Because these are written to by the DMA controller, they must
536 * not contain a 64k byte boundary crossing, or data will be
537 * corrupted/lost.
539 static char *floppy_track_buffer;
540 static int max_buffer_sectors;
542 static int *errors;
543 typedef void (*done_f) (int);
544 static struct cont_t {
545 void (*interrupt) (void); /* this is called after the interrupt of the
546 * main command */
547 void (*redo) (void); /* this is called to retry the operation */
548 void (*error) (void); /* this is called to tally an error */
549 done_f done; /* this is called to say if the operation has
550 * succeeded/failed */
551 } *cont;
553 static void floppy_ready(void);
554 static void floppy_start(void);
555 static void process_fd_request(void);
556 static void recalibrate_floppy(void);
557 static void floppy_shutdown(unsigned long);
559 static int floppy_grab_irq_and_dma(void);
560 static void floppy_release_irq_and_dma(void);
563 * The "reset" variable should be tested whenever an interrupt is scheduled,
564 * after the commands have been sent. This is to ensure that the driver doesn't
565 * get wedged when the interrupt doesn't come because of a failed command.
566 * reset doesn't need to be tested before sending commands, because
567 * output_byte is automatically disabled when reset is set.
569 #define CHECK_RESET { if (FDCS->reset){ reset_fdc(); return; } }
570 static void reset_fdc(void);
573 * These are global variables, as that's the easiest way to give
574 * information to interrupts. They are the data used for the current
575 * request.
577 #define NO_TRACK -1
578 #define NEED_1_RECAL -2
579 #define NEED_2_RECAL -3
581 static int usage_count;
583 /* buffer related variables */
584 static int buffer_track = -1;
585 static int buffer_drive = -1;
586 static int buffer_min = -1;
587 static int buffer_max = -1;
589 /* fdc related variables, should end up in a struct */
590 static struct floppy_fdc_state fdc_state[N_FDC];
591 static int fdc; /* current fdc */
593 static struct floppy_struct *_floppy = floppy_type;
594 static unsigned char current_drive;
595 static long current_count_sectors;
596 static unsigned char fsector_t; /* sector in track */
597 static unsigned char in_sector_offset; /* offset within physical sector,
598 * expressed in units of 512 bytes */
600 #ifndef fd_eject
601 static inline int fd_eject(int drive)
603 return -EINVAL;
605 #endif
608 * Debugging
609 * =========
611 #ifdef DEBUGT
612 static long unsigned debugtimer;
614 static inline void set_debugt(void)
616 debugtimer = jiffies;
619 static inline void debugt(const char *message)
621 if (DP->flags & DEBUGT)
622 printk("%s dtime=%lu\n", message, jiffies - debugtimer);
624 #else
625 static inline void set_debugt(void) { }
626 static inline void debugt(const char *message) { }
627 #endif /* DEBUGT */
629 typedef void (*timeout_fn) (unsigned long);
630 static DEFINE_TIMER(fd_timeout, floppy_shutdown, 0, 0);
632 static const char *timeout_message;
634 #ifdef FLOPPY_SANITY_CHECK
635 static void is_alive(const char *message)
637 /* this routine checks whether the floppy driver is "alive" */
638 if (test_bit(0, &fdc_busy) && command_status < 2
639 && !timer_pending(&fd_timeout)) {
640 DPRINT("timeout handler died: %s\n", message);
643 #endif
645 static void (*do_floppy) (void) = NULL;
647 #ifdef FLOPPY_SANITY_CHECK
649 #define OLOGSIZE 20
651 static void (*lasthandler) (void);
652 static unsigned long interruptjiffies;
653 static unsigned long resultjiffies;
654 static int resultsize;
655 static unsigned long lastredo;
657 static struct output_log {
658 unsigned char data;
659 unsigned char status;
660 unsigned long jiffies;
661 } output_log[OLOGSIZE];
663 static int output_log_pos;
664 #endif
666 #define current_reqD -1
667 #define MAXTIMEOUT -2
669 static void __reschedule_timeout(int drive, const char *message, int marg)
671 if (drive == current_reqD)
672 drive = current_drive;
673 del_timer(&fd_timeout);
674 if (drive < 0 || drive > N_DRIVE) {
675 fd_timeout.expires = jiffies + 20UL * HZ;
676 drive = 0;
677 } else
678 fd_timeout.expires = jiffies + UDP->timeout;
679 add_timer(&fd_timeout);
680 if (UDP->flags & FD_DEBUG) {
681 DPRINT("reschedule timeout ");
682 printk(message, marg);
683 printk("\n");
685 timeout_message = message;
688 static void reschedule_timeout(int drive, const char *message, int marg)
690 unsigned long flags;
692 spin_lock_irqsave(&floppy_lock, flags);
693 __reschedule_timeout(drive, message, marg);
694 spin_unlock_irqrestore(&floppy_lock, flags);
697 #define INFBOUND(a,b) (a)=max_t(int, a, b)
699 #define SUPBOUND(a,b) (a)=min_t(int, a, b)
702 * Bottom half floppy driver.
703 * ==========================
705 * This part of the file contains the code talking directly to the hardware,
706 * and also the main service loop (seek-configure-spinup-command)
710 * disk change.
711 * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
712 * and the last_checked date.
714 * last_checked is the date of the last check which showed 'no disk change'
715 * FD_DISK_CHANGE is set under two conditions:
716 * 1. The floppy has been changed after some i/o to that floppy already
717 * took place.
718 * 2. No floppy disk is in the drive. This is done in order to ensure that
719 * requests are quickly flushed in case there is no disk in the drive. It
720 * follows that FD_DISK_CHANGE can only be cleared if there is a disk in
721 * the drive.
723 * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
724 * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
725 * each seek. If a disk is present, the disk change line should also be
726 * cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
727 * change line is set, this means either that no disk is in the drive, or
728 * that it has been removed since the last seek.
730 * This means that we really have a third possibility too:
731 * The floppy has been changed after the last seek.
734 static int disk_change(int drive)
736 int fdc = FDC(drive);
737 #ifdef FLOPPY_SANITY_CHECK
738 if (jiffies - UDRS->select_date < UDP->select_delay)
739 DPRINT("WARNING disk change called early\n");
740 if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
741 (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
742 DPRINT("probing disk change on unselected drive\n");
743 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
744 (unsigned int)FDCS->dor);
746 #endif
748 #ifdef DCL_DEBUG
749 if (UDP->flags & FD_DEBUG) {
750 DPRINT("checking disk change line for drive %d\n", drive);
751 DPRINT("jiffies=%lu\n", jiffies);
752 DPRINT("disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
753 DPRINT("flags=%lx\n", UDRS->flags);
755 #endif
756 if (UDP->flags & FD_BROKEN_DCL)
757 return UTESTF(FD_DISK_CHANGED);
758 if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
759 USETF(FD_VERIFY); /* verify write protection */
760 if (UDRS->maxblock) {
761 /* mark it changed */
762 USETF(FD_DISK_CHANGED);
765 /* invalidate its geometry */
766 if (UDRS->keep_data >= 0) {
767 if ((UDP->flags & FTD_MSG) &&
768 current_type[drive] != NULL)
769 DPRINT("Disk type is undefined after "
770 "disk change\n");
771 current_type[drive] = NULL;
772 floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
775 /*USETF(FD_DISK_NEWCHANGE); */
776 return 1;
777 } else {
778 UDRS->last_checked = jiffies;
779 UCLEARF(FD_DISK_NEWCHANGE);
781 return 0;
784 static inline int is_selected(int dor, int unit)
786 return ((dor & (0x10 << unit)) && (dor & 3) == unit);
789 static int set_dor(int fdc, char mask, char data)
791 register unsigned char drive, unit, newdor, olddor;
793 if (FDCS->address == -1)
794 return -1;
796 olddor = FDCS->dor;
797 newdor = (olddor & mask) | data;
798 if (newdor != olddor) {
799 unit = olddor & 0x3;
800 if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
801 drive = REVDRIVE(fdc, unit);
802 #ifdef DCL_DEBUG
803 if (UDP->flags & FD_DEBUG) {
804 DPRINT("calling disk change from set_dor\n");
806 #endif
807 disk_change(drive);
809 FDCS->dor = newdor;
810 fd_outb(newdor, FD_DOR);
812 unit = newdor & 0x3;
813 if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
814 drive = REVDRIVE(fdc, unit);
815 UDRS->select_date = jiffies;
819 * We should propagate failures to grab the resources back
820 * nicely from here. Actually we ought to rewrite the fd
821 * driver some day too.
823 if (newdor & FLOPPY_MOTOR_MASK)
824 floppy_grab_irq_and_dma();
825 if (olddor & FLOPPY_MOTOR_MASK)
826 floppy_release_irq_and_dma();
827 return olddor;
830 static void twaddle(void)
832 if (DP->select_delay)
833 return;
834 fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
835 fd_outb(FDCS->dor, FD_DOR);
836 DRS->select_date = jiffies;
839 /* reset all driver information about the current fdc. This is needed after
840 * a reset, and after a raw command. */
841 static void reset_fdc_info(int mode)
843 int drive;
845 FDCS->spec1 = FDCS->spec2 = -1;
846 FDCS->need_configure = 1;
847 FDCS->perp_mode = 1;
848 FDCS->rawcmd = 0;
849 for (drive = 0; drive < N_DRIVE; drive++)
850 if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
851 UDRS->track = NEED_2_RECAL;
854 /* selects the fdc and drive, and enables the fdc's input/dma. */
855 static void set_fdc(int drive)
857 if (drive >= 0 && drive < N_DRIVE) {
858 fdc = FDC(drive);
859 current_drive = drive;
861 if (fdc != 1 && fdc != 0) {
862 printk("bad fdc value\n");
863 return;
865 set_dor(fdc, ~0, 8);
866 #if N_FDC > 1
867 set_dor(1 - fdc, ~8, 0);
868 #endif
869 if (FDCS->rawcmd == 2)
870 reset_fdc_info(1);
871 if (fd_inb(FD_STATUS) != STATUS_READY)
872 FDCS->reset = 1;
875 /* locks the driver */
876 static int _lock_fdc(int drive, int interruptible, int line)
878 if (!usage_count) {
879 printk(KERN_ERR
880 "Trying to lock fdc while usage count=0 at line %d\n",
881 line);
882 return -1;
884 if (floppy_grab_irq_and_dma() == -1)
885 return -EBUSY;
887 if (test_and_set_bit(0, &fdc_busy)) {
888 DECLARE_WAITQUEUE(wait, current);
889 add_wait_queue(&fdc_wait, &wait);
891 for (;;) {
892 set_current_state(TASK_INTERRUPTIBLE);
894 if (!test_and_set_bit(0, &fdc_busy))
895 break;
897 schedule();
899 if (!NO_SIGNAL) {
900 remove_wait_queue(&fdc_wait, &wait);
901 return -EINTR;
905 set_current_state(TASK_RUNNING);
906 remove_wait_queue(&fdc_wait, &wait);
908 command_status = FD_COMMAND_NONE;
910 __reschedule_timeout(drive, "lock fdc", 0);
911 set_fdc(drive);
912 return 0;
915 #define lock_fdc(drive,interruptible) _lock_fdc(drive,interruptible, __LINE__)
917 #define LOCK_FDC(drive,interruptible) \
918 if (lock_fdc(drive,interruptible)) return -EINTR;
920 /* unlocks the driver */
921 static inline void unlock_fdc(void)
923 unsigned long flags;
925 raw_cmd = NULL;
926 if (!test_bit(0, &fdc_busy))
927 DPRINT("FDC access conflict!\n");
929 if (do_floppy)
930 DPRINT("device interrupt still active at FDC release: %p!\n",
931 do_floppy);
932 command_status = FD_COMMAND_NONE;
933 spin_lock_irqsave(&floppy_lock, flags);
934 del_timer(&fd_timeout);
935 cont = NULL;
936 clear_bit(0, &fdc_busy);
937 if (elv_next_request(floppy_queue))
938 do_fd_request(floppy_queue);
939 spin_unlock_irqrestore(&floppy_lock, flags);
940 floppy_release_irq_and_dma();
941 wake_up(&fdc_wait);
944 /* switches the motor off after a given timeout */
945 static void motor_off_callback(unsigned long nr)
947 unsigned char mask = ~(0x10 << UNIT(nr));
949 set_dor(FDC(nr), mask, 0);
952 /* schedules motor off */
953 static void floppy_off(unsigned int drive)
955 unsigned long volatile delta;
956 register int fdc = FDC(drive);
958 if (!(FDCS->dor & (0x10 << UNIT(drive))))
959 return;
961 del_timer(motor_off_timer + drive);
963 /* make spindle stop in a position which minimizes spinup time
964 * next time */
965 if (UDP->rps) {
966 delta = jiffies - UDRS->first_read_date + HZ -
967 UDP->spindown_offset;
968 delta = ((delta * UDP->rps) % HZ) / UDP->rps;
969 motor_off_timer[drive].expires =
970 jiffies + UDP->spindown - delta;
972 add_timer(motor_off_timer + drive);
976 * cycle through all N_DRIVE floppy drives, for disk change testing.
977 * stopping at current drive. This is done before any long operation, to
978 * be sure to have up to date disk change information.
980 static void scandrives(void)
982 int i, drive, saved_drive;
984 if (DP->select_delay)
985 return;
987 saved_drive = current_drive;
988 for (i = 0; i < N_DRIVE; i++) {
989 drive = (saved_drive + i + 1) % N_DRIVE;
990 if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
991 continue; /* skip closed drives */
992 set_fdc(drive);
993 if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
994 (0x10 << UNIT(drive))))
995 /* switch the motor off again, if it was off to
996 * begin with */
997 set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
999 set_fdc(saved_drive);
1002 static void empty(void)
1006 static DECLARE_WORK(floppy_work, NULL, NULL);
1008 static void schedule_bh(void (*handler) (void))
1010 PREPARE_WORK(&floppy_work, (void (*)(void *))handler, NULL);
1011 schedule_work(&floppy_work);
1014 static DEFINE_TIMER(fd_timer, NULL, 0, 0);
1016 static void cancel_activity(void)
1018 unsigned long flags;
1020 spin_lock_irqsave(&floppy_lock, flags);
1021 do_floppy = NULL;
1022 PREPARE_WORK(&floppy_work, (void *)empty, NULL);
1023 del_timer(&fd_timer);
1024 spin_unlock_irqrestore(&floppy_lock, flags);
1027 /* this function makes sure that the disk stays in the drive during the
1028 * transfer */
1029 static void fd_watchdog(void)
1031 #ifdef DCL_DEBUG
1032 if (DP->flags & FD_DEBUG) {
1033 DPRINT("calling disk change from watchdog\n");
1035 #endif
1037 if (disk_change(current_drive)) {
1038 DPRINT("disk removed during i/o\n");
1039 cancel_activity();
1040 cont->done(0);
1041 reset_fdc();
1042 } else {
1043 del_timer(&fd_timer);
1044 fd_timer.function = (timeout_fn) fd_watchdog;
1045 fd_timer.expires = jiffies + HZ / 10;
1046 add_timer(&fd_timer);
1050 static void main_command_interrupt(void)
1052 del_timer(&fd_timer);
1053 cont->interrupt();
1056 /* waits for a delay (spinup or select) to pass */
1057 static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
1059 if (FDCS->reset) {
1060 reset_fdc(); /* do the reset during sleep to win time
1061 * if we don't need to sleep, it's a good
1062 * occasion anyways */
1063 return 1;
1066 if ((signed)(jiffies - delay) < 0) {
1067 del_timer(&fd_timer);
1068 fd_timer.function = function;
1069 fd_timer.expires = delay;
1070 add_timer(&fd_timer);
1071 return 1;
1073 return 0;
1076 static DEFINE_SPINLOCK(floppy_hlt_lock);
1077 static int hlt_disabled;
1078 static void floppy_disable_hlt(void)
1080 unsigned long flags;
1082 spin_lock_irqsave(&floppy_hlt_lock, flags);
1083 if (!hlt_disabled) {
1084 hlt_disabled = 1;
1085 #ifdef HAVE_DISABLE_HLT
1086 disable_hlt();
1087 #endif
1089 spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1092 static void floppy_enable_hlt(void)
1094 unsigned long flags;
1096 spin_lock_irqsave(&floppy_hlt_lock, flags);
1097 if (hlt_disabled) {
1098 hlt_disabled = 0;
1099 #ifdef HAVE_DISABLE_HLT
1100 enable_hlt();
1101 #endif
1103 spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1106 static void setup_DMA(void)
1108 unsigned long f;
1110 #ifdef FLOPPY_SANITY_CHECK
1111 if (raw_cmd->length == 0) {
1112 int i;
1114 printk("zero dma transfer size:");
1115 for (i = 0; i < raw_cmd->cmd_count; i++)
1116 printk("%x,", raw_cmd->cmd[i]);
1117 printk("\n");
1118 cont->done(0);
1119 FDCS->reset = 1;
1120 return;
1122 if (((unsigned long)raw_cmd->kernel_data) % 512) {
1123 printk("non aligned address: %p\n", raw_cmd->kernel_data);
1124 cont->done(0);
1125 FDCS->reset = 1;
1126 return;
1128 #endif
1129 f = claim_dma_lock();
1130 fd_disable_dma();
1131 #ifdef fd_dma_setup
1132 if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1133 (raw_cmd->flags & FD_RAW_READ) ?
1134 DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
1135 release_dma_lock(f);
1136 cont->done(0);
1137 FDCS->reset = 1;
1138 return;
1140 release_dma_lock(f);
1141 #else
1142 fd_clear_dma_ff();
1143 fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1144 fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
1145 DMA_MODE_READ : DMA_MODE_WRITE);
1146 fd_set_dma_addr(raw_cmd->kernel_data);
1147 fd_set_dma_count(raw_cmd->length);
1148 virtual_dma_port = FDCS->address;
1149 fd_enable_dma();
1150 release_dma_lock(f);
1151 #endif
1152 floppy_disable_hlt();
1155 static void show_floppy(void);
1157 /* waits until the fdc becomes ready */
1158 static int wait_til_ready(void)
1160 int counter, status;
1161 if (FDCS->reset)
1162 return -1;
1163 for (counter = 0; counter < 10000; counter++) {
1164 status = fd_inb(FD_STATUS);
1165 if (status & STATUS_READY)
1166 return status;
1168 if (!initialising) {
1169 DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
1170 show_floppy();
1172 FDCS->reset = 1;
1173 return -1;
1176 /* sends a command byte to the fdc */
1177 static int output_byte(char byte)
1179 int status;
1181 if ((status = wait_til_ready()) < 0)
1182 return -1;
1183 if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY) {
1184 fd_outb(byte, FD_DATA);
1185 #ifdef FLOPPY_SANITY_CHECK
1186 output_log[output_log_pos].data = byte;
1187 output_log[output_log_pos].status = status;
1188 output_log[output_log_pos].jiffies = jiffies;
1189 output_log_pos = (output_log_pos + 1) % OLOGSIZE;
1190 #endif
1191 return 0;
1193 FDCS->reset = 1;
1194 if (!initialising) {
1195 DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
1196 byte, fdc, status);
1197 show_floppy();
1199 return -1;
1202 #define LAST_OUT(x) if (output_byte(x)<0){ reset_fdc();return;}
1204 /* gets the response from the fdc */
1205 static int result(void)
1207 int i, status = 0;
1209 for (i = 0; i < MAX_REPLIES; i++) {
1210 if ((status = wait_til_ready()) < 0)
1211 break;
1212 status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
1213 if ((status & ~STATUS_BUSY) == STATUS_READY) {
1214 #ifdef FLOPPY_SANITY_CHECK
1215 resultjiffies = jiffies;
1216 resultsize = i;
1217 #endif
1218 return i;
1220 if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
1221 reply_buffer[i] = fd_inb(FD_DATA);
1222 else
1223 break;
1225 if (!initialising) {
1226 DPRINT
1227 ("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
1228 fdc, status, i);
1229 show_floppy();
1231 FDCS->reset = 1;
1232 return -1;
1235 #define MORE_OUTPUT -2
1236 /* does the fdc need more output? */
1237 static int need_more_output(void)
1239 int status;
1240 if ((status = wait_til_ready()) < 0)
1241 return -1;
1242 if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY)
1243 return MORE_OUTPUT;
1244 return result();
1247 /* Set perpendicular mode as required, based on data rate, if supported.
1248 * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
1250 static inline void perpendicular_mode(void)
1252 unsigned char perp_mode;
1254 if (raw_cmd->rate & 0x40) {
1255 switch (raw_cmd->rate & 3) {
1256 case 0:
1257 perp_mode = 2;
1258 break;
1259 case 3:
1260 perp_mode = 3;
1261 break;
1262 default:
1263 DPRINT("Invalid data rate for perpendicular mode!\n");
1264 cont->done(0);
1265 FDCS->reset = 1; /* convenient way to return to
1266 * redo without to much hassle (deep
1267 * stack et al. */
1268 return;
1270 } else
1271 perp_mode = 0;
1273 if (FDCS->perp_mode == perp_mode)
1274 return;
1275 if (FDCS->version >= FDC_82077_ORIG) {
1276 output_byte(FD_PERPENDICULAR);
1277 output_byte(perp_mode);
1278 FDCS->perp_mode = perp_mode;
1279 } else if (perp_mode) {
1280 DPRINT("perpendicular mode not supported by this FDC.\n");
1282 } /* perpendicular_mode */
1284 static int fifo_depth = 0xa;
1285 static int no_fifo;
1287 static int fdc_configure(void)
1289 /* Turn on FIFO */
1290 output_byte(FD_CONFIGURE);
1291 if (need_more_output() != MORE_OUTPUT)
1292 return 0;
1293 output_byte(0);
1294 output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1295 output_byte(0); /* pre-compensation from track
1296 0 upwards */
1297 return 1;
1300 #define NOMINAL_DTR 500
1302 /* Issue a "SPECIFY" command to set the step rate time, head unload time,
1303 * head load time, and DMA disable flag to values needed by floppy.
1305 * The value "dtr" is the data transfer rate in Kbps. It is needed
1306 * to account for the data rate-based scaling done by the 82072 and 82077
1307 * FDC types. This parameter is ignored for other types of FDCs (i.e.
1308 * 8272a).
1310 * Note that changing the data transfer rate has a (probably deleterious)
1311 * effect on the parameters subject to scaling for 82072/82077 FDCs, so
1312 * fdc_specify is called again after each data transfer rate
1313 * change.
1315 * srt: 1000 to 16000 in microseconds
1316 * hut: 16 to 240 milliseconds
1317 * hlt: 2 to 254 milliseconds
1319 * These values are rounded up to the next highest available delay time.
1321 static void fdc_specify(void)
1323 unsigned char spec1, spec2;
1324 unsigned long srt, hlt, hut;
1325 unsigned long dtr = NOMINAL_DTR;
1326 unsigned long scale_dtr = NOMINAL_DTR;
1327 int hlt_max_code = 0x7f;
1328 int hut_max_code = 0xf;
1330 if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
1331 fdc_configure();
1332 FDCS->need_configure = 0;
1333 /*DPRINT("FIFO enabled\n"); */
1336 switch (raw_cmd->rate & 0x03) {
1337 case 3:
1338 dtr = 1000;
1339 break;
1340 case 1:
1341 dtr = 300;
1342 if (FDCS->version >= FDC_82078) {
1343 /* chose the default rate table, not the one
1344 * where 1 = 2 Mbps */
1345 output_byte(FD_DRIVESPEC);
1346 if (need_more_output() == MORE_OUTPUT) {
1347 output_byte(UNIT(current_drive));
1348 output_byte(0xc0);
1351 break;
1352 case 2:
1353 dtr = 250;
1354 break;
1357 if (FDCS->version >= FDC_82072) {
1358 scale_dtr = dtr;
1359 hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
1360 hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
1363 /* Convert step rate from microseconds to milliseconds and 4 bits */
1364 srt = 16 - (DP->srt * scale_dtr / 1000 + NOMINAL_DTR - 1) / NOMINAL_DTR;
1365 if (slow_floppy) {
1366 srt = srt / 4;
1368 SUPBOUND(srt, 0xf);
1369 INFBOUND(srt, 0);
1371 hlt = (DP->hlt * scale_dtr / 2 + NOMINAL_DTR - 1) / NOMINAL_DTR;
1372 if (hlt < 0x01)
1373 hlt = 0x01;
1374 else if (hlt > 0x7f)
1375 hlt = hlt_max_code;
1377 hut = (DP->hut * scale_dtr / 16 + NOMINAL_DTR - 1) / NOMINAL_DTR;
1378 if (hut < 0x1)
1379 hut = 0x1;
1380 else if (hut > 0xf)
1381 hut = hut_max_code;
1383 spec1 = (srt << 4) | hut;
1384 spec2 = (hlt << 1) | (use_virtual_dma & 1);
1386 /* If these parameters did not change, just return with success */
1387 if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
1388 /* Go ahead and set spec1 and spec2 */
1389 output_byte(FD_SPECIFY);
1390 output_byte(FDCS->spec1 = spec1);
1391 output_byte(FDCS->spec2 = spec2);
1393 } /* fdc_specify */
1395 /* Set the FDC's data transfer rate on behalf of the specified drive.
1396 * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
1397 * of the specify command (i.e. using the fdc_specify function).
1399 static int fdc_dtr(void)
1401 /* If data rate not already set to desired value, set it. */
1402 if ((raw_cmd->rate & 3) == FDCS->dtr)
1403 return 0;
1405 /* Set dtr */
1406 fd_outb(raw_cmd->rate & 3, FD_DCR);
1408 /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1409 * need a stabilization period of several milliseconds to be
1410 * enforced after data rate changes before R/W operations.
1411 * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
1413 FDCS->dtr = raw_cmd->rate & 3;
1414 return (fd_wait_for_completion(jiffies + 2UL * HZ / 100,
1415 (timeout_fn) floppy_ready));
1416 } /* fdc_dtr */
1418 static void tell_sector(void)
1420 printk(": track %d, head %d, sector %d, size %d",
1421 R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
1422 } /* tell_sector */
1425 * OK, this error interpreting routine is called after a
1426 * DMA read/write has succeeded
1427 * or failed, so we check the results, and copy any buffers.
1428 * hhb: Added better error reporting.
1429 * ak: Made this into a separate routine.
1431 static int interpret_errors(void)
1433 char bad;
1435 if (inr != 7) {
1436 DPRINT("-- FDC reply error");
1437 FDCS->reset = 1;
1438 return 1;
1441 /* check IC to find cause of interrupt */
1442 switch (ST0 & ST0_INTR) {
1443 case 0x40: /* error occurred during command execution */
1444 if (ST1 & ST1_EOC)
1445 return 0; /* occurs with pseudo-DMA */
1446 bad = 1;
1447 if (ST1 & ST1_WP) {
1448 DPRINT("Drive is write protected\n");
1449 CLEARF(FD_DISK_WRITABLE);
1450 cont->done(0);
1451 bad = 2;
1452 } else if (ST1 & ST1_ND) {
1453 SETF(FD_NEED_TWADDLE);
1454 } else if (ST1 & ST1_OR) {
1455 if (DP->flags & FTD_MSG)
1456 DPRINT("Over/Underrun - retrying\n");
1457 bad = 0;
1458 } else if (*errors >= DP->max_errors.reporting) {
1459 DPRINT("");
1460 if (ST0 & ST0_ECE) {
1461 printk("Recalibrate failed!");
1462 } else if (ST2 & ST2_CRC) {
1463 printk("data CRC error");
1464 tell_sector();
1465 } else if (ST1 & ST1_CRC) {
1466 printk("CRC error");
1467 tell_sector();
1468 } else if ((ST1 & (ST1_MAM | ST1_ND))
1469 || (ST2 & ST2_MAM)) {
1470 if (!probing) {
1471 printk("sector not found");
1472 tell_sector();
1473 } else
1474 printk("probe failed...");
1475 } else if (ST2 & ST2_WC) { /* seek error */
1476 printk("wrong cylinder");
1477 } else if (ST2 & ST2_BC) { /* cylinder marked as bad */
1478 printk("bad cylinder");
1479 } else {
1480 printk
1481 ("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
1482 ST0, ST1, ST2);
1483 tell_sector();
1485 printk("\n");
1488 if (ST2 & ST2_WC || ST2 & ST2_BC)
1489 /* wrong cylinder => recal */
1490 DRS->track = NEED_2_RECAL;
1491 return bad;
1492 case 0x80: /* invalid command given */
1493 DPRINT("Invalid FDC command given!\n");
1494 cont->done(0);
1495 return 2;
1496 case 0xc0:
1497 DPRINT("Abnormal termination caused by polling\n");
1498 cont->error();
1499 return 2;
1500 default: /* (0) Normal command termination */
1501 return 0;
1506 * This routine is called when everything should be correctly set up
1507 * for the transfer (i.e. floppy motor is on, the correct floppy is
1508 * selected, and the head is sitting on the right track).
1510 static void setup_rw_floppy(void)
1512 int i, r, flags, dflags;
1513 unsigned long ready_date;
1514 timeout_fn function;
1516 flags = raw_cmd->flags;
1517 if (flags & (FD_RAW_READ | FD_RAW_WRITE))
1518 flags |= FD_RAW_INTR;
1520 if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
1521 ready_date = DRS->spinup_date + DP->spinup;
1522 /* If spinup will take a long time, rerun scandrives
1523 * again just before spinup completion. Beware that
1524 * after scandrives, we must again wait for selection.
1526 if ((signed)(ready_date - jiffies) > DP->select_delay) {
1527 ready_date -= DP->select_delay;
1528 function = (timeout_fn) floppy_start;
1529 } else
1530 function = (timeout_fn) setup_rw_floppy;
1532 /* wait until the floppy is spinning fast enough */
1533 if (fd_wait_for_completion(ready_date, function))
1534 return;
1536 dflags = DRS->flags;
1538 if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
1539 setup_DMA();
1541 if (flags & FD_RAW_INTR)
1542 do_floppy = main_command_interrupt;
1544 r = 0;
1545 for (i = 0; i < raw_cmd->cmd_count; i++)
1546 r |= output_byte(raw_cmd->cmd[i]);
1548 debugt("rw_command: ");
1550 if (r) {
1551 cont->error();
1552 reset_fdc();
1553 return;
1556 if (!(flags & FD_RAW_INTR)) {
1557 inr = result();
1558 cont->interrupt();
1559 } else if (flags & FD_RAW_NEED_DISK)
1560 fd_watchdog();
1563 static int blind_seek;
1566 * This is the routine called after every seek (or recalibrate) interrupt
1567 * from the floppy controller.
1569 static void seek_interrupt(void)
1571 debugt("seek interrupt:");
1572 if (inr != 2 || (ST0 & 0xF8) != 0x20) {
1573 DPRINT("seek failed\n");
1574 DRS->track = NEED_2_RECAL;
1575 cont->error();
1576 cont->redo();
1577 return;
1579 if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
1580 #ifdef DCL_DEBUG
1581 if (DP->flags & FD_DEBUG) {
1582 DPRINT
1583 ("clearing NEWCHANGE flag because of effective seek\n");
1584 DPRINT("jiffies=%lu\n", jiffies);
1586 #endif
1587 CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
1588 DRS->select_date = jiffies;
1590 DRS->track = ST1;
1591 floppy_ready();
1594 static void check_wp(void)
1596 if (TESTF(FD_VERIFY)) {
1597 /* check write protection */
1598 output_byte(FD_GETSTATUS);
1599 output_byte(UNIT(current_drive));
1600 if (result() != 1) {
1601 FDCS->reset = 1;
1602 return;
1604 CLEARF(FD_VERIFY);
1605 CLEARF(FD_NEED_TWADDLE);
1606 #ifdef DCL_DEBUG
1607 if (DP->flags & FD_DEBUG) {
1608 DPRINT("checking whether disk is write protected\n");
1609 DPRINT("wp=%x\n", ST3 & 0x40);
1611 #endif
1612 if (!(ST3 & 0x40))
1613 SETF(FD_DISK_WRITABLE);
1614 else
1615 CLEARF(FD_DISK_WRITABLE);
1619 static void seek_floppy(void)
1621 int track;
1623 blind_seek = 0;
1625 #ifdef DCL_DEBUG
1626 if (DP->flags & FD_DEBUG) {
1627 DPRINT("calling disk change from seek\n");
1629 #endif
1631 if (!TESTF(FD_DISK_NEWCHANGE) &&
1632 disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1633 /* the media changed flag should be cleared after the seek.
1634 * If it isn't, this means that there is really no disk in
1635 * the drive.
1637 SETF(FD_DISK_CHANGED);
1638 cont->done(0);
1639 cont->redo();
1640 return;
1642 if (DRS->track <= NEED_1_RECAL) {
1643 recalibrate_floppy();
1644 return;
1645 } else if (TESTF(FD_DISK_NEWCHANGE) &&
1646 (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1647 (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
1648 /* we seek to clear the media-changed condition. Does anybody
1649 * know a more elegant way, which works on all drives? */
1650 if (raw_cmd->track)
1651 track = raw_cmd->track - 1;
1652 else {
1653 if (DP->flags & FD_SILENT_DCL_CLEAR) {
1654 set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
1655 blind_seek = 1;
1656 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1658 track = 1;
1660 } else {
1661 check_wp();
1662 if (raw_cmd->track != DRS->track &&
1663 (raw_cmd->flags & FD_RAW_NEED_SEEK))
1664 track = raw_cmd->track;
1665 else {
1666 setup_rw_floppy();
1667 return;
1671 do_floppy = seek_interrupt;
1672 output_byte(FD_SEEK);
1673 output_byte(UNIT(current_drive));
1674 LAST_OUT(track);
1675 debugt("seek command:");
1678 static void recal_interrupt(void)
1680 debugt("recal interrupt:");
1681 if (inr != 2)
1682 FDCS->reset = 1;
1683 else if (ST0 & ST0_ECE) {
1684 switch (DRS->track) {
1685 case NEED_1_RECAL:
1686 debugt("recal interrupt need 1 recal:");
1687 /* after a second recalibrate, we still haven't
1688 * reached track 0. Probably no drive. Raise an
1689 * error, as failing immediately might upset
1690 * computers possessed by the Devil :-) */
1691 cont->error();
1692 cont->redo();
1693 return;
1694 case NEED_2_RECAL:
1695 debugt("recal interrupt need 2 recal:");
1696 /* If we already did a recalibrate,
1697 * and we are not at track 0, this
1698 * means we have moved. (The only way
1699 * not to move at recalibration is to
1700 * be already at track 0.) Clear the
1701 * new change flag */
1702 #ifdef DCL_DEBUG
1703 if (DP->flags & FD_DEBUG) {
1704 DPRINT
1705 ("clearing NEWCHANGE flag because of second recalibrate\n");
1707 #endif
1709 CLEARF(FD_DISK_NEWCHANGE);
1710 DRS->select_date = jiffies;
1711 /* fall through */
1712 default:
1713 debugt("recal interrupt default:");
1714 /* Recalibrate moves the head by at
1715 * most 80 steps. If after one
1716 * recalibrate we don't have reached
1717 * track 0, this might mean that we
1718 * started beyond track 80. Try
1719 * again. */
1720 DRS->track = NEED_1_RECAL;
1721 break;
1723 } else
1724 DRS->track = ST1;
1725 floppy_ready();
1728 static void print_result(char *message, int inr)
1730 int i;
1732 DPRINT("%s ", message);
1733 if (inr >= 0)
1734 for (i = 0; i < inr; i++)
1735 printk("repl[%d]=%x ", i, reply_buffer[i]);
1736 printk("\n");
1739 /* interrupt handler. Note that this can be called externally on the Sparc */
1740 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1742 void (*handler) (void) = do_floppy;
1743 int do_print;
1744 unsigned long f;
1746 lasthandler = handler;
1747 interruptjiffies = jiffies;
1749 f = claim_dma_lock();
1750 fd_disable_dma();
1751 release_dma_lock(f);
1753 floppy_enable_hlt();
1754 do_floppy = NULL;
1755 if (fdc >= N_FDC || FDCS->address == -1) {
1756 /* we don't even know which FDC is the culprit */
1757 printk("DOR0=%x\n", fdc_state[0].dor);
1758 printk("floppy interrupt on bizarre fdc %d\n", fdc);
1759 printk("handler=%p\n", handler);
1760 is_alive("bizarre fdc");
1761 return IRQ_NONE;
1764 FDCS->reset = 0;
1765 /* We have to clear the reset flag here, because apparently on boxes
1766 * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
1767 * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
1768 * emission of the SENSEI's.
1769 * It is OK to emit floppy commands because we are in an interrupt
1770 * handler here, and thus we have to fear no interference of other
1771 * activity.
1774 do_print = !handler && print_unex && !initialising;
1776 inr = result();
1777 if (do_print)
1778 print_result("unexpected interrupt", inr);
1779 if (inr == 0) {
1780 int max_sensei = 4;
1781 do {
1782 output_byte(FD_SENSEI);
1783 inr = result();
1784 if (do_print)
1785 print_result("sensei", inr);
1786 max_sensei--;
1787 } while ((ST0 & 0x83) != UNIT(current_drive) && inr == 2
1788 && max_sensei);
1790 if (!handler) {
1791 FDCS->reset = 1;
1792 return IRQ_NONE;
1794 schedule_bh(handler);
1795 is_alive("normal interrupt end");
1797 /* FIXME! Was it really for us? */
1798 return IRQ_HANDLED;
1801 static void recalibrate_floppy(void)
1803 debugt("recalibrate floppy:");
1804 do_floppy = recal_interrupt;
1805 output_byte(FD_RECALIBRATE);
1806 LAST_OUT(UNIT(current_drive));
1810 * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1812 static void reset_interrupt(void)
1814 debugt("reset interrupt:");
1815 result(); /* get the status ready for set_fdc */
1816 if (FDCS->reset) {
1817 printk("reset set in interrupt, calling %p\n", cont->error);
1818 cont->error(); /* a reset just after a reset. BAD! */
1820 cont->redo();
1824 * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1825 * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1827 static void reset_fdc(void)
1829 unsigned long flags;
1831 do_floppy = reset_interrupt;
1832 FDCS->reset = 0;
1833 reset_fdc_info(0);
1835 /* Pseudo-DMA may intercept 'reset finished' interrupt. */
1836 /* Irrelevant for systems with true DMA (i386). */
1838 flags = claim_dma_lock();
1839 fd_disable_dma();
1840 release_dma_lock(flags);
1842 if (FDCS->version >= FDC_82072A)
1843 fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
1844 else {
1845 fd_outb(FDCS->dor & ~0x04, FD_DOR);
1846 udelay(FD_RESET_DELAY);
1847 fd_outb(FDCS->dor, FD_DOR);
1851 static void show_floppy(void)
1853 int i;
1855 printk("\n");
1856 printk("floppy driver state\n");
1857 printk("-------------------\n");
1858 printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",
1859 jiffies, interruptjiffies, jiffies - interruptjiffies,
1860 lasthandler);
1862 #ifdef FLOPPY_SANITY_CHECK
1863 printk("timeout_message=%s\n", timeout_message);
1864 printk("last output bytes:\n");
1865 for (i = 0; i < OLOGSIZE; i++)
1866 printk("%2x %2x %lu\n",
1867 output_log[(i + output_log_pos) % OLOGSIZE].data,
1868 output_log[(i + output_log_pos) % OLOGSIZE].status,
1869 output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1870 printk("last result at %lu\n", resultjiffies);
1871 printk("last redo_fd_request at %lu\n", lastredo);
1872 for (i = 0; i < resultsize; i++) {
1873 printk("%2x ", reply_buffer[i]);
1875 printk("\n");
1876 #endif
1878 printk("status=%x\n", fd_inb(FD_STATUS));
1879 printk("fdc_busy=%lu\n", fdc_busy);
1880 if (do_floppy)
1881 printk("do_floppy=%p\n", do_floppy);
1882 if (floppy_work.pending)
1883 printk("floppy_work.func=%p\n", floppy_work.func);
1884 if (timer_pending(&fd_timer))
1885 printk("fd_timer.function=%p\n", fd_timer.function);
1886 if (timer_pending(&fd_timeout)) {
1887 printk("timer_function=%p\n", fd_timeout.function);
1888 printk("expires=%lu\n", fd_timeout.expires - jiffies);
1889 printk("now=%lu\n", jiffies);
1891 printk("cont=%p\n", cont);
1892 printk("current_req=%p\n", current_req);
1893 printk("command_status=%d\n", command_status);
1894 printk("\n");
1897 static void floppy_shutdown(unsigned long data)
1899 unsigned long flags;
1901 if (!initialising)
1902 show_floppy();
1903 cancel_activity();
1905 floppy_enable_hlt();
1907 flags = claim_dma_lock();
1908 fd_disable_dma();
1909 release_dma_lock(flags);
1911 /* avoid dma going to a random drive after shutdown */
1913 if (!initialising)
1914 DPRINT("floppy timeout called\n");
1915 FDCS->reset = 1;
1916 if (cont) {
1917 cont->done(0);
1918 cont->redo(); /* this will recall reset when needed */
1919 } else {
1920 printk("no cont in shutdown!\n");
1921 process_fd_request();
1923 is_alive("floppy shutdown");
1926 /*typedef void (*timeout_fn)(unsigned long);*/
1928 /* start motor, check media-changed condition and write protection */
1929 static int start_motor(void (*function) (void))
1931 int mask, data;
1933 mask = 0xfc;
1934 data = UNIT(current_drive);
1935 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1936 if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
1937 set_debugt();
1938 /* no read since this drive is running */
1939 DRS->first_read_date = 0;
1940 /* note motor start time if motor is not yet running */
1941 DRS->spinup_date = jiffies;
1942 data |= (0x10 << UNIT(current_drive));
1944 } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
1945 mask &= ~(0x10 << UNIT(current_drive));
1947 /* starts motor and selects floppy */
1948 del_timer(motor_off_timer + current_drive);
1949 set_dor(fdc, mask, data);
1951 /* wait_for_completion also schedules reset if needed. */
1952 return (fd_wait_for_completion(DRS->select_date + DP->select_delay,
1953 (timeout_fn) function));
1956 static void floppy_ready(void)
1958 CHECK_RESET;
1959 if (start_motor(floppy_ready))
1960 return;
1961 if (fdc_dtr())
1962 return;
1964 #ifdef DCL_DEBUG
1965 if (DP->flags & FD_DEBUG) {
1966 DPRINT("calling disk change from floppy_ready\n");
1968 #endif
1969 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1970 disk_change(current_drive) && !DP->select_delay)
1971 twaddle(); /* this clears the dcl on certain drive/controller
1972 * combinations */
1974 #ifdef fd_chose_dma_mode
1975 if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1976 unsigned long flags = claim_dma_lock();
1977 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1978 release_dma_lock(flags);
1980 #endif
1982 if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1983 perpendicular_mode();
1984 fdc_specify(); /* must be done here because of hut, hlt ... */
1985 seek_floppy();
1986 } else {
1987 if ((raw_cmd->flags & FD_RAW_READ) ||
1988 (raw_cmd->flags & FD_RAW_WRITE))
1989 fdc_specify();
1990 setup_rw_floppy();
1994 static void floppy_start(void)
1996 reschedule_timeout(current_reqD, "floppy start", 0);
1998 scandrives();
1999 #ifdef DCL_DEBUG
2000 if (DP->flags & FD_DEBUG) {
2001 DPRINT("setting NEWCHANGE in floppy_start\n");
2003 #endif
2004 SETF(FD_DISK_NEWCHANGE);
2005 floppy_ready();
2009 * ========================================================================
2010 * here ends the bottom half. Exported routines are:
2011 * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
2012 * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
2013 * Initialization also uses output_byte, result, set_dor, floppy_interrupt
2014 * and set_dor.
2015 * ========================================================================
2018 * General purpose continuations.
2019 * ==============================
2022 static void do_wakeup(void)
2024 reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
2025 cont = NULL;
2026 command_status += 2;
2027 wake_up(&command_done);
2030 static struct cont_t wakeup_cont = {
2031 .interrupt = empty,
2032 .redo = do_wakeup,
2033 .error = empty,
2034 .done = (done_f) empty
2037 static struct cont_t intr_cont = {
2038 .interrupt = empty,
2039 .redo = process_fd_request,
2040 .error = empty,
2041 .done = (done_f) empty
2044 static int wait_til_done(void (*handler) (void), int interruptible)
2046 int ret;
2048 schedule_bh(handler);
2050 if (command_status < 2 && NO_SIGNAL) {
2051 DECLARE_WAITQUEUE(wait, current);
2053 add_wait_queue(&command_done, &wait);
2054 for (;;) {
2055 set_current_state(interruptible ?
2056 TASK_INTERRUPTIBLE :
2057 TASK_UNINTERRUPTIBLE);
2059 if (command_status >= 2 || !NO_SIGNAL)
2060 break;
2062 is_alive("wait_til_done");
2064 schedule();
2067 set_current_state(TASK_RUNNING);
2068 remove_wait_queue(&command_done, &wait);
2071 if (command_status < 2) {
2072 cancel_activity();
2073 cont = &intr_cont;
2074 reset_fdc();
2075 return -EINTR;
2078 if (FDCS->reset)
2079 command_status = FD_COMMAND_ERROR;
2080 if (command_status == FD_COMMAND_OKAY)
2081 ret = 0;
2082 else
2083 ret = -EIO;
2084 command_status = FD_COMMAND_NONE;
2085 return ret;
2088 static void generic_done(int result)
2090 command_status = result;
2091 cont = &wakeup_cont;
2094 static void generic_success(void)
2096 cont->done(1);
2099 static void generic_failure(void)
2101 cont->done(0);
2104 static void success_and_wakeup(void)
2106 generic_success();
2107 cont->redo();
2111 * formatting and rw support.
2112 * ==========================
2115 static int next_valid_format(void)
2117 int probed_format;
2119 probed_format = DRS->probed_format;
2120 while (1) {
2121 if (probed_format >= 8 || !DP->autodetect[probed_format]) {
2122 DRS->probed_format = 0;
2123 return 1;
2125 if (floppy_type[DP->autodetect[probed_format]].sect) {
2126 DRS->probed_format = probed_format;
2127 return 0;
2129 probed_format++;
2133 static void bad_flp_intr(void)
2135 int err_count;
2137 if (probing) {
2138 DRS->probed_format++;
2139 if (!next_valid_format())
2140 return;
2142 err_count = ++(*errors);
2143 INFBOUND(DRWE->badness, err_count);
2144 if (err_count > DP->max_errors.abort)
2145 cont->done(0);
2146 if (err_count > DP->max_errors.reset)
2147 FDCS->reset = 1;
2148 else if (err_count > DP->max_errors.recal)
2149 DRS->track = NEED_2_RECAL;
2152 static void set_floppy(int drive)
2154 int type = ITYPE(UDRS->fd_device);
2155 if (type)
2156 _floppy = floppy_type + type;
2157 else
2158 _floppy = current_type[drive];
2162 * formatting support.
2163 * ===================
2165 static void format_interrupt(void)
2167 switch (interpret_errors()) {
2168 case 1:
2169 cont->error();
2170 case 2:
2171 break;
2172 case 0:
2173 cont->done(1);
2175 cont->redo();
2178 #define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
2179 #define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80) >>1))
2180 #define CT(x) ((x) | 0xc0)
2181 static void setup_format_params(int track)
2183 struct fparm {
2184 unsigned char track, head, sect, size;
2185 } *here = (struct fparm *)floppy_track_buffer;
2186 int il, n;
2187 int count, head_shift, track_shift;
2189 raw_cmd = &default_raw_cmd;
2190 raw_cmd->track = track;
2192 raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2193 FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2194 raw_cmd->rate = _floppy->rate & 0x43;
2195 raw_cmd->cmd_count = NR_F;
2196 COMMAND = FM_MODE(_floppy, FD_FORMAT);
2197 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2198 F_SIZECODE = FD_SIZECODE(_floppy);
2199 F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2200 F_GAP = _floppy->fmt_gap;
2201 F_FILL = FD_FILL_BYTE;
2203 raw_cmd->kernel_data = floppy_track_buffer;
2204 raw_cmd->length = 4 * F_SECT_PER_TRACK;
2206 /* allow for about 30ms for data transport per track */
2207 head_shift = (F_SECT_PER_TRACK + 5) / 6;
2209 /* a ``cylinder'' is two tracks plus a little stepping time */
2210 track_shift = 2 * head_shift + 3;
2212 /* position of logical sector 1 on this track */
2213 n = (track_shift * format_req.track + head_shift * format_req.head)
2214 % F_SECT_PER_TRACK;
2216 /* determine interleave */
2217 il = 1;
2218 if (_floppy->fmt_gap < 0x22)
2219 il++;
2221 /* initialize field */
2222 for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2223 here[count].track = format_req.track;
2224 here[count].head = format_req.head;
2225 here[count].sect = 0;
2226 here[count].size = F_SIZECODE;
2228 /* place logical sectors */
2229 for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2230 here[n].sect = count;
2231 n = (n + il) % F_SECT_PER_TRACK;
2232 if (here[n].sect) { /* sector busy, find next free sector */
2233 ++n;
2234 if (n >= F_SECT_PER_TRACK) {
2235 n -= F_SECT_PER_TRACK;
2236 while (here[n].sect)
2237 ++n;
2241 if (_floppy->stretch & FD_ZEROBASED) {
2242 for (count = 0; count < F_SECT_PER_TRACK; count++)
2243 here[count].sect--;
2247 static void redo_format(void)
2249 buffer_track = -1;
2250 setup_format_params(format_req.track << STRETCH(_floppy));
2251 floppy_start();
2252 debugt("queue format request");
2255 static struct cont_t format_cont = {
2256 .interrupt = format_interrupt,
2257 .redo = redo_format,
2258 .error = bad_flp_intr,
2259 .done = generic_done
2262 static int do_format(int drive, struct format_descr *tmp_format_req)
2264 int ret;
2266 LOCK_FDC(drive, 1);
2267 set_floppy(drive);
2268 if (!_floppy ||
2269 _floppy->track > DP->tracks ||
2270 tmp_format_req->track >= _floppy->track ||
2271 tmp_format_req->head >= _floppy->head ||
2272 (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2273 !_floppy->fmt_gap) {
2274 process_fd_request();
2275 return -EINVAL;
2277 format_req = *tmp_format_req;
2278 format_errors = 0;
2279 cont = &format_cont;
2280 errors = &format_errors;
2281 IWAIT(redo_format);
2282 process_fd_request();
2283 return ret;
2287 * Buffer read/write and support
2288 * =============================
2291 static void floppy_end_request(struct request *req, int uptodate)
2293 unsigned int nr_sectors = current_count_sectors;
2295 /* current_count_sectors can be zero if transfer failed */
2296 if (!uptodate)
2297 nr_sectors = req->current_nr_sectors;
2298 if (end_that_request_first(req, uptodate, nr_sectors))
2299 return;
2300 add_disk_randomness(req->rq_disk);
2301 floppy_off((long)req->rq_disk->private_data);
2302 blkdev_dequeue_request(req);
2303 end_that_request_last(req, uptodate);
2305 /* We're done with the request */
2306 current_req = NULL;
2309 /* new request_done. Can handle physical sectors which are smaller than a
2310 * logical buffer */
2311 static void request_done(int uptodate)
2313 struct request_queue *q = floppy_queue;
2314 struct request *req = current_req;
2315 unsigned long flags;
2316 int block;
2318 probing = 0;
2319 reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
2321 if (!req) {
2322 printk("floppy.c: no request in request_done\n");
2323 return;
2326 if (uptodate) {
2327 /* maintain values for invalidation on geometry
2328 * change */
2329 block = current_count_sectors + req->sector;
2330 INFBOUND(DRS->maxblock, block);
2331 if (block > _floppy->sect)
2332 DRS->maxtrack = 1;
2334 /* unlock chained buffers */
2335 spin_lock_irqsave(q->queue_lock, flags);
2336 floppy_end_request(req, 1);
2337 spin_unlock_irqrestore(q->queue_lock, flags);
2338 } else {
2339 if (rq_data_dir(req) == WRITE) {
2340 /* record write error information */
2341 DRWE->write_errors++;
2342 if (DRWE->write_errors == 1) {
2343 DRWE->first_error_sector = req->sector;
2344 DRWE->first_error_generation = DRS->generation;
2346 DRWE->last_error_sector = req->sector;
2347 DRWE->last_error_generation = DRS->generation;
2349 spin_lock_irqsave(q->queue_lock, flags);
2350 floppy_end_request(req, 0);
2351 spin_unlock_irqrestore(q->queue_lock, flags);
2355 /* Interrupt handler evaluating the result of the r/w operation */
2356 static void rw_interrupt(void)
2358 int nr_sectors, ssize, eoc, heads;
2360 if (R_HEAD >= 2) {
2361 /* some Toshiba floppy controllers occasionnally seem to
2362 * return bogus interrupts after read/write operations, which
2363 * can be recognized by a bad head number (>= 2) */
2364 return;
2367 if (!DRS->first_read_date)
2368 DRS->first_read_date = jiffies;
2370 nr_sectors = 0;
2371 CODE2SIZE;
2373 if (ST1 & ST1_EOC)
2374 eoc = 1;
2375 else
2376 eoc = 0;
2378 if (COMMAND & 0x80)
2379 heads = 2;
2380 else
2381 heads = 1;
2383 nr_sectors = (((R_TRACK - TRACK) * heads +
2384 R_HEAD - HEAD) * SECT_PER_TRACK +
2385 R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2387 #ifdef FLOPPY_SANITY_CHECK
2388 if (nr_sectors / ssize >
2389 (in_sector_offset + current_count_sectors + ssize - 1) / ssize) {
2390 DPRINT("long rw: %x instead of %lx\n",
2391 nr_sectors, current_count_sectors);
2392 printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
2393 printk("rh=%d h=%d\n", R_HEAD, HEAD);
2394 printk("rt=%d t=%d\n", R_TRACK, TRACK);
2395 printk("heads=%d eoc=%d\n", heads, eoc);
2396 printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
2397 fsector_t, ssize);
2398 printk("in_sector_offset=%d\n", in_sector_offset);
2400 #endif
2402 nr_sectors -= in_sector_offset;
2403 INFBOUND(nr_sectors, 0);
2404 SUPBOUND(current_count_sectors, nr_sectors);
2406 switch (interpret_errors()) {
2407 case 2:
2408 cont->redo();
2409 return;
2410 case 1:
2411 if (!current_count_sectors) {
2412 cont->error();
2413 cont->redo();
2414 return;
2416 break;
2417 case 0:
2418 if (!current_count_sectors) {
2419 cont->redo();
2420 return;
2422 current_type[current_drive] = _floppy;
2423 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2424 break;
2427 if (probing) {
2428 if (DP->flags & FTD_MSG)
2429 DPRINT("Auto-detected floppy type %s in fd%d\n",
2430 _floppy->name, current_drive);
2431 current_type[current_drive] = _floppy;
2432 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2433 probing = 0;
2436 if (CT(COMMAND) != FD_READ ||
2437 raw_cmd->kernel_data == current_req->buffer) {
2438 /* transfer directly from buffer */
2439 cont->done(1);
2440 } else if (CT(COMMAND) == FD_READ) {
2441 buffer_track = raw_cmd->track;
2442 buffer_drive = current_drive;
2443 INFBOUND(buffer_max, nr_sectors + fsector_t);
2445 cont->redo();
2448 /* Compute maximal contiguous buffer size. */
2449 static int buffer_chain_size(void)
2451 struct bio *bio;
2452 struct bio_vec *bv;
2453 int size, i;
2454 char *base;
2456 base = bio_data(current_req->bio);
2457 size = 0;
2459 rq_for_each_bio(bio, current_req) {
2460 bio_for_each_segment(bv, bio, i) {
2461 if (page_address(bv->bv_page) + bv->bv_offset !=
2462 base + size)
2463 break;
2465 size += bv->bv_len;
2469 return size >> 9;
2472 /* Compute the maximal transfer size */
2473 static int transfer_size(int ssize, int max_sector, int max_size)
2475 SUPBOUND(max_sector, fsector_t + max_size);
2477 /* alignment */
2478 max_sector -= (max_sector % _floppy->sect) % ssize;
2480 /* transfer size, beginning not aligned */
2481 current_count_sectors = max_sector - fsector_t;
2483 return max_sector;
2487 * Move data from/to the track buffer to/from the buffer cache.
2489 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2491 int remaining; /* number of transferred 512-byte sectors */
2492 struct bio_vec *bv;
2493 struct bio *bio;
2494 char *buffer, *dma_buffer;
2495 int size, i;
2497 max_sector = transfer_size(ssize,
2498 min(max_sector, max_sector_2),
2499 current_req->nr_sectors);
2501 if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2502 buffer_max > fsector_t + current_req->nr_sectors)
2503 current_count_sectors = min_t(int, buffer_max - fsector_t,
2504 current_req->nr_sectors);
2506 remaining = current_count_sectors << 9;
2507 #ifdef FLOPPY_SANITY_CHECK
2508 if ((remaining >> 9) > current_req->nr_sectors &&
2509 CT(COMMAND) == FD_WRITE) {
2510 DPRINT("in copy buffer\n");
2511 printk("current_count_sectors=%ld\n", current_count_sectors);
2512 printk("remaining=%d\n", remaining >> 9);
2513 printk("current_req->nr_sectors=%ld\n",
2514 current_req->nr_sectors);
2515 printk("current_req->current_nr_sectors=%u\n",
2516 current_req->current_nr_sectors);
2517 printk("max_sector=%d\n", max_sector);
2518 printk("ssize=%d\n", ssize);
2520 #endif
2522 buffer_max = max(max_sector, buffer_max);
2524 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2526 size = current_req->current_nr_sectors << 9;
2528 rq_for_each_bio(bio, current_req) {
2529 bio_for_each_segment(bv, bio, i) {
2530 if (!remaining)
2531 break;
2533 size = bv->bv_len;
2534 SUPBOUND(size, remaining);
2536 buffer = page_address(bv->bv_page) + bv->bv_offset;
2537 #ifdef FLOPPY_SANITY_CHECK
2538 if (dma_buffer + size >
2539 floppy_track_buffer + (max_buffer_sectors << 10) ||
2540 dma_buffer < floppy_track_buffer) {
2541 DPRINT("buffer overrun in copy buffer %d\n",
2542 (int)((floppy_track_buffer -
2543 dma_buffer) >> 9));
2544 printk("fsector_t=%d buffer_min=%d\n",
2545 fsector_t, buffer_min);
2546 printk("current_count_sectors=%ld\n",
2547 current_count_sectors);
2548 if (CT(COMMAND) == FD_READ)
2549 printk("read\n");
2550 if (CT(COMMAND) == FD_WRITE)
2551 printk("write\n");
2552 break;
2554 if (((unsigned long)buffer) % 512)
2555 DPRINT("%p buffer not aligned\n", buffer);
2556 #endif
2557 if (CT(COMMAND) == FD_READ)
2558 memcpy(buffer, dma_buffer, size);
2559 else
2560 memcpy(dma_buffer, buffer, size);
2562 remaining -= size;
2563 dma_buffer += size;
2566 #ifdef FLOPPY_SANITY_CHECK
2567 if (remaining) {
2568 if (remaining > 0)
2569 max_sector -= remaining >> 9;
2570 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2572 #endif
2575 #if 0
2576 static inline int check_dma_crossing(char *start,
2577 unsigned long length, char *message)
2579 if (CROSS_64KB(start, length)) {
2580 printk("DMA xfer crosses 64KB boundary in %s %p-%p\n",
2581 message, start, start + length);
2582 return 1;
2583 } else
2584 return 0;
2586 #endif
2588 /* work around a bug in pseudo DMA
2589 * (on some FDCs) pseudo DMA does not stop when the CPU stops
2590 * sending data. Hence we need a different way to signal the
2591 * transfer length: We use SECT_PER_TRACK. Unfortunately, this
2592 * does not work with MT, hence we can only transfer one head at
2593 * a time
2595 static void virtualdmabug_workaround(void)
2597 int hard_sectors, end_sector;
2599 if (CT(COMMAND) == FD_WRITE) {
2600 COMMAND &= ~0x80; /* switch off multiple track mode */
2602 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2603 end_sector = SECTOR + hard_sectors - 1;
2604 #ifdef FLOPPY_SANITY_CHECK
2605 if (end_sector > SECT_PER_TRACK) {
2606 printk("too many sectors %d > %d\n",
2607 end_sector, SECT_PER_TRACK);
2608 return;
2610 #endif
2611 SECT_PER_TRACK = end_sector; /* make sure SECT_PER_TRACK points
2612 * to end of transfer */
2617 * Formulate a read/write request.
2618 * this routine decides where to load the data (directly to buffer, or to
2619 * tmp floppy area), how much data to load (the size of the buffer, the whole
2620 * track, or a single sector)
2621 * All floppy_track_buffer handling goes in here. If we ever add track buffer
2622 * allocation on the fly, it should be done here. No other part should need
2623 * modification.
2626 static int make_raw_rw_request(void)
2628 int aligned_sector_t;
2629 int max_sector, max_size, tracksize, ssize;
2631 if (max_buffer_sectors == 0) {
2632 printk("VFS: Block I/O scheduled on unopened device\n");
2633 return 0;
2636 set_fdc((long)current_req->rq_disk->private_data);
2638 raw_cmd = &default_raw_cmd;
2639 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2640 FD_RAW_NEED_SEEK;
2641 raw_cmd->cmd_count = NR_RW;
2642 if (rq_data_dir(current_req) == READ) {
2643 raw_cmd->flags |= FD_RAW_READ;
2644 COMMAND = FM_MODE(_floppy, FD_READ);
2645 } else if (rq_data_dir(current_req) == WRITE) {
2646 raw_cmd->flags |= FD_RAW_WRITE;
2647 COMMAND = FM_MODE(_floppy, FD_WRITE);
2648 } else {
2649 DPRINT("make_raw_rw_request: unknown command\n");
2650 return 0;
2653 max_sector = _floppy->sect * _floppy->head;
2655 TRACK = (int)current_req->sector / max_sector;
2656 fsector_t = (int)current_req->sector % max_sector;
2657 if (_floppy->track && TRACK >= _floppy->track) {
2658 if (current_req->current_nr_sectors & 1) {
2659 current_count_sectors = 1;
2660 return 1;
2661 } else
2662 return 0;
2664 HEAD = fsector_t / _floppy->sect;
2666 if (((_floppy->stretch & (FD_SWAPSIDES | FD_ZEROBASED)) ||
2667 TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
2668 max_sector = _floppy->sect;
2670 /* 2M disks have phantom sectors on the first track */
2671 if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2672 max_sector = 2 * _floppy->sect / 3;
2673 if (fsector_t >= max_sector) {
2674 current_count_sectors =
2675 min_t(int, _floppy->sect - fsector_t,
2676 current_req->nr_sectors);
2677 return 1;
2679 SIZECODE = 2;
2680 } else
2681 SIZECODE = FD_SIZECODE(_floppy);
2682 raw_cmd->rate = _floppy->rate & 0x43;
2683 if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2684 raw_cmd->rate = 1;
2686 if (SIZECODE)
2687 SIZECODE2 = 0xff;
2688 else
2689 SIZECODE2 = 0x80;
2690 raw_cmd->track = TRACK << STRETCH(_floppy);
2691 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2692 GAP = _floppy->gap;
2693 CODE2SIZE;
2694 SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2695 SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
2696 ((_floppy->stretch & FD_ZEROBASED) ? 0 : 1);
2698 /* tracksize describes the size which can be filled up with sectors
2699 * of size ssize.
2701 tracksize = _floppy->sect - _floppy->sect % ssize;
2702 if (tracksize < _floppy->sect) {
2703 SECT_PER_TRACK++;
2704 if (tracksize <= fsector_t % _floppy->sect)
2705 SECTOR--;
2707 /* if we are beyond tracksize, fill up using smaller sectors */
2708 while (tracksize <= fsector_t % _floppy->sect) {
2709 while (tracksize + ssize > _floppy->sect) {
2710 SIZECODE--;
2711 ssize >>= 1;
2713 SECTOR++;
2714 SECT_PER_TRACK++;
2715 tracksize += ssize;
2717 max_sector = HEAD * _floppy->sect + tracksize;
2718 } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2719 max_sector = _floppy->sect;
2720 } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2721 /* for virtual DMA bug workaround */
2722 max_sector = _floppy->sect;
2725 in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2726 aligned_sector_t = fsector_t - in_sector_offset;
2727 max_size = current_req->nr_sectors;
2728 if ((raw_cmd->track == buffer_track) &&
2729 (current_drive == buffer_drive) &&
2730 (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2731 /* data already in track buffer */
2732 if (CT(COMMAND) == FD_READ) {
2733 copy_buffer(1, max_sector, buffer_max);
2734 return 1;
2736 } else if (in_sector_offset || current_req->nr_sectors < ssize) {
2737 if (CT(COMMAND) == FD_WRITE) {
2738 if (fsector_t + current_req->nr_sectors > ssize &&
2739 fsector_t + current_req->nr_sectors < ssize + ssize)
2740 max_size = ssize + ssize;
2741 else
2742 max_size = ssize;
2744 raw_cmd->flags &= ~FD_RAW_WRITE;
2745 raw_cmd->flags |= FD_RAW_READ;
2746 COMMAND = FM_MODE(_floppy, FD_READ);
2747 } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2748 unsigned long dma_limit;
2749 int direct, indirect;
2751 indirect =
2752 transfer_size(ssize, max_sector,
2753 max_buffer_sectors * 2) - fsector_t;
2756 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2757 * on a 64 bit machine!
2759 max_size = buffer_chain_size();
2760 dma_limit =
2761 (MAX_DMA_ADDRESS -
2762 ((unsigned long)current_req->buffer)) >> 9;
2763 if ((unsigned long)max_size > dma_limit) {
2764 max_size = dma_limit;
2766 /* 64 kb boundaries */
2767 if (CROSS_64KB(current_req->buffer, max_size << 9))
2768 max_size = (K_64 -
2769 ((unsigned long)current_req->buffer) %
2770 K_64) >> 9;
2771 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2773 * We try to read tracks, but if we get too many errors, we
2774 * go back to reading just one sector at a time.
2776 * This means we should be able to read a sector even if there
2777 * are other bad sectors on this track.
2779 if (!direct ||
2780 (indirect * 2 > direct * 3 &&
2781 *errors < DP->max_errors.read_track &&
2782 /*!TESTF(FD_NEED_TWADDLE) && */
2783 ((!probing
2784 || (DP->read_track & (1 << DRS->probed_format)))))) {
2785 max_size = current_req->nr_sectors;
2786 } else {
2787 raw_cmd->kernel_data = current_req->buffer;
2788 raw_cmd->length = current_count_sectors << 9;
2789 if (raw_cmd->length == 0) {
2790 DPRINT
2791 ("zero dma transfer attempted from make_raw_request\n");
2792 DPRINT("indirect=%d direct=%d fsector_t=%d",
2793 indirect, direct, fsector_t);
2794 return 0;
2796 /* check_dma_crossing(raw_cmd->kernel_data,
2797 raw_cmd->length,
2798 "end of make_raw_request [1]");*/
2800 virtualdmabug_workaround();
2801 return 2;
2805 if (CT(COMMAND) == FD_READ)
2806 max_size = max_sector; /* unbounded */
2808 /* claim buffer track if needed */
2809 if (buffer_track != raw_cmd->track || /* bad track */
2810 buffer_drive != current_drive || /* bad drive */
2811 fsector_t > buffer_max ||
2812 fsector_t < buffer_min ||
2813 ((CT(COMMAND) == FD_READ ||
2814 (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
2815 max_sector > 2 * max_buffer_sectors + buffer_min &&
2816 max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
2817 /* not enough space */
2819 buffer_track = -1;
2820 buffer_drive = current_drive;
2821 buffer_max = buffer_min = aligned_sector_t;
2823 raw_cmd->kernel_data = floppy_track_buffer +
2824 ((aligned_sector_t - buffer_min) << 9);
2826 if (CT(COMMAND) == FD_WRITE) {
2827 /* copy write buffer to track buffer.
2828 * if we get here, we know that the write
2829 * is either aligned or the data already in the buffer
2830 * (buffer will be overwritten) */
2831 #ifdef FLOPPY_SANITY_CHECK
2832 if (in_sector_offset && buffer_track == -1)
2833 DPRINT("internal error offset !=0 on write\n");
2834 #endif
2835 buffer_track = raw_cmd->track;
2836 buffer_drive = current_drive;
2837 copy_buffer(ssize, max_sector,
2838 2 * max_buffer_sectors + buffer_min);
2839 } else
2840 transfer_size(ssize, max_sector,
2841 2 * max_buffer_sectors + buffer_min -
2842 aligned_sector_t);
2844 /* round up current_count_sectors to get dma xfer size */
2845 raw_cmd->length = in_sector_offset + current_count_sectors;
2846 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2847 raw_cmd->length <<= 9;
2848 #ifdef FLOPPY_SANITY_CHECK
2849 /*check_dma_crossing(raw_cmd->kernel_data, raw_cmd->length,
2850 "end of make_raw_request"); */
2851 if ((raw_cmd->length < current_count_sectors << 9) ||
2852 (raw_cmd->kernel_data != current_req->buffer &&
2853 CT(COMMAND) == FD_WRITE &&
2854 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2855 aligned_sector_t < buffer_min)) ||
2856 raw_cmd->length % (128 << SIZECODE) ||
2857 raw_cmd->length <= 0 || current_count_sectors <= 0) {
2858 DPRINT("fractionary current count b=%lx s=%lx\n",
2859 raw_cmd->length, current_count_sectors);
2860 if (raw_cmd->kernel_data != current_req->buffer)
2861 printk("addr=%d, length=%ld\n",
2862 (int)((raw_cmd->kernel_data -
2863 floppy_track_buffer) >> 9),
2864 current_count_sectors);
2865 printk("st=%d ast=%d mse=%d msi=%d\n",
2866 fsector_t, aligned_sector_t, max_sector, max_size);
2867 printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2868 printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2869 COMMAND, SECTOR, HEAD, TRACK);
2870 printk("buffer drive=%d\n", buffer_drive);
2871 printk("buffer track=%d\n", buffer_track);
2872 printk("buffer_min=%d\n", buffer_min);
2873 printk("buffer_max=%d\n", buffer_max);
2874 return 0;
2877 if (raw_cmd->kernel_data != current_req->buffer) {
2878 if (raw_cmd->kernel_data < floppy_track_buffer ||
2879 current_count_sectors < 0 ||
2880 raw_cmd->length < 0 ||
2881 raw_cmd->kernel_data + raw_cmd->length >
2882 floppy_track_buffer + (max_buffer_sectors << 10)) {
2883 DPRINT("buffer overrun in schedule dma\n");
2884 printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
2885 fsector_t, buffer_min, raw_cmd->length >> 9);
2886 printk("current_count_sectors=%ld\n",
2887 current_count_sectors);
2888 if (CT(COMMAND) == FD_READ)
2889 printk("read\n");
2890 if (CT(COMMAND) == FD_WRITE)
2891 printk("write\n");
2892 return 0;
2894 } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
2895 current_count_sectors > current_req->nr_sectors) {
2896 DPRINT("buffer overrun in direct transfer\n");
2897 return 0;
2898 } else if (raw_cmd->length < current_count_sectors << 9) {
2899 DPRINT("more sectors than bytes\n");
2900 printk("bytes=%ld\n", raw_cmd->length >> 9);
2901 printk("sectors=%ld\n", current_count_sectors);
2903 if (raw_cmd->length == 0) {
2904 DPRINT("zero dma transfer attempted from make_raw_request\n");
2905 return 0;
2907 #endif
2909 virtualdmabug_workaround();
2910 return 2;
2913 static void redo_fd_request(void)
2915 #define REPEAT {request_done(0); continue; }
2916 int drive;
2917 int tmp;
2919 lastredo = jiffies;
2920 if (current_drive < N_DRIVE)
2921 floppy_off(current_drive);
2923 for (;;) {
2924 if (!current_req) {
2925 struct request *req;
2927 spin_lock_irq(floppy_queue->queue_lock);
2928 req = elv_next_request(floppy_queue);
2929 spin_unlock_irq(floppy_queue->queue_lock);
2930 if (!req) {
2931 do_floppy = NULL;
2932 unlock_fdc();
2933 return;
2935 current_req = req;
2937 drive = (long)current_req->rq_disk->private_data;
2938 set_fdc(drive);
2939 reschedule_timeout(current_reqD, "redo fd request", 0);
2941 set_floppy(drive);
2942 raw_cmd = &default_raw_cmd;
2943 raw_cmd->flags = 0;
2944 if (start_motor(redo_fd_request))
2945 return;
2946 disk_change(current_drive);
2947 if (test_bit(current_drive, &fake_change) ||
2948 TESTF(FD_DISK_CHANGED)) {
2949 DPRINT("disk absent or changed during operation\n");
2950 REPEAT;
2952 if (!_floppy) { /* Autodetection */
2953 if (!probing) {
2954 DRS->probed_format = 0;
2955 if (next_valid_format()) {
2956 DPRINT("no autodetectable formats\n");
2957 _floppy = NULL;
2958 REPEAT;
2961 probing = 1;
2962 _floppy =
2963 floppy_type + DP->autodetect[DRS->probed_format];
2964 } else
2965 probing = 0;
2966 errors = &(current_req->errors);
2967 tmp = make_raw_rw_request();
2968 if (tmp < 2) {
2969 request_done(tmp);
2970 continue;
2973 if (TESTF(FD_NEED_TWADDLE))
2974 twaddle();
2975 schedule_bh(floppy_start);
2976 debugt("queue fd request");
2977 return;
2979 #undef REPEAT
2982 static struct cont_t rw_cont = {
2983 .interrupt = rw_interrupt,
2984 .redo = redo_fd_request,
2985 .error = bad_flp_intr,
2986 .done = request_done
2989 static void process_fd_request(void)
2991 cont = &rw_cont;
2992 schedule_bh(redo_fd_request);
2995 static void do_fd_request(request_queue_t * q)
2997 if (max_buffer_sectors == 0) {
2998 printk("VFS: do_fd_request called on non-open device\n");
2999 return;
3002 if (usage_count == 0) {
3003 printk("warning: usage count=0, current_req=%p exiting\n",
3004 current_req);
3005 printk("sect=%ld flags=%lx\n", (long)current_req->sector,
3006 current_req->flags);
3007 return;
3009 if (test_bit(0, &fdc_busy)) {
3010 /* fdc busy, this new request will be treated when the
3011 current one is done */
3012 is_alive("do fd request, old request running");
3013 return;
3015 lock_fdc(MAXTIMEOUT, 0);
3016 process_fd_request();
3017 is_alive("do fd request");
3020 static struct cont_t poll_cont = {
3021 .interrupt = success_and_wakeup,
3022 .redo = floppy_ready,
3023 .error = generic_failure,
3024 .done = generic_done
3027 static int poll_drive(int interruptible, int flag)
3029 int ret;
3030 /* no auto-sense, just clear dcl */
3031 raw_cmd = &default_raw_cmd;
3032 raw_cmd->flags = flag;
3033 raw_cmd->track = 0;
3034 raw_cmd->cmd_count = 0;
3035 cont = &poll_cont;
3036 #ifdef DCL_DEBUG
3037 if (DP->flags & FD_DEBUG) {
3038 DPRINT("setting NEWCHANGE in poll_drive\n");
3040 #endif
3041 SETF(FD_DISK_NEWCHANGE);
3042 WAIT(floppy_ready);
3043 return ret;
3047 * User triggered reset
3048 * ====================
3051 static void reset_intr(void)
3053 printk("weird, reset interrupt called\n");
3056 static struct cont_t reset_cont = {
3057 .interrupt = reset_intr,
3058 .redo = success_and_wakeup,
3059 .error = generic_failure,
3060 .done = generic_done
3063 static int user_reset_fdc(int drive, int arg, int interruptible)
3065 int ret;
3067 ret = 0;
3068 LOCK_FDC(drive, interruptible);
3069 if (arg == FD_RESET_ALWAYS)
3070 FDCS->reset = 1;
3071 if (FDCS->reset) {
3072 cont = &reset_cont;
3073 WAIT(reset_fdc);
3075 process_fd_request();
3076 return ret;
3080 * Misc Ioctl's and support
3081 * ========================
3083 static inline int fd_copyout(void __user *param, const void *address,
3084 unsigned long size)
3086 return copy_to_user(param, address, size) ? -EFAULT : 0;
3089 static inline int fd_copyin(void __user *param, void *address, unsigned long size)
3091 return copy_from_user(address, param, size) ? -EFAULT : 0;
3094 #define _COPYOUT(x) (copy_to_user((void __user *)param, &(x), sizeof(x)) ? -EFAULT : 0)
3095 #define _COPYIN(x) (copy_from_user(&(x), (void __user *)param, sizeof(x)) ? -EFAULT : 0)
3097 #define COPYOUT(x) ECALL(_COPYOUT(x))
3098 #define COPYIN(x) ECALL(_COPYIN(x))
3100 static inline const char *drive_name(int type, int drive)
3102 struct floppy_struct *floppy;
3104 if (type)
3105 floppy = floppy_type + type;
3106 else {
3107 if (UDP->native_format)
3108 floppy = floppy_type + UDP->native_format;
3109 else
3110 return "(null)";
3112 if (floppy->name)
3113 return floppy->name;
3114 else
3115 return "(null)";
3118 /* raw commands */
3119 static void raw_cmd_done(int flag)
3121 int i;
3123 if (!flag) {
3124 raw_cmd->flags |= FD_RAW_FAILURE;
3125 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3126 } else {
3127 raw_cmd->reply_count = inr;
3128 if (raw_cmd->reply_count > MAX_REPLIES)
3129 raw_cmd->reply_count = 0;
3130 for (i = 0; i < raw_cmd->reply_count; i++)
3131 raw_cmd->reply[i] = reply_buffer[i];
3133 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3134 unsigned long flags;
3135 flags = claim_dma_lock();
3136 raw_cmd->length = fd_get_dma_residue();
3137 release_dma_lock(flags);
3140 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3141 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3142 raw_cmd->flags |= FD_RAW_FAILURE;
3144 if (disk_change(current_drive))
3145 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3146 else
3147 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3148 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3149 motor_off_callback(current_drive);
3151 if (raw_cmd->next &&
3152 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3153 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3154 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3155 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3156 raw_cmd = raw_cmd->next;
3157 return;
3160 generic_done(flag);
3163 static struct cont_t raw_cmd_cont = {
3164 .interrupt = success_and_wakeup,
3165 .redo = floppy_start,
3166 .error = generic_failure,
3167 .done = raw_cmd_done
3170 static inline int raw_cmd_copyout(int cmd, char __user *param,
3171 struct floppy_raw_cmd *ptr)
3173 int ret;
3175 while (ptr) {
3176 COPYOUT(*ptr);
3177 param += sizeof(struct floppy_raw_cmd);
3178 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3179 if (ptr->length >= 0
3180 && ptr->length <= ptr->buffer_length)
3181 ECALL(fd_copyout
3182 (ptr->data, ptr->kernel_data,
3183 ptr->buffer_length - ptr->length));
3185 ptr = ptr->next;
3187 return 0;
3190 static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3192 struct floppy_raw_cmd *next, *this;
3194 this = *ptr;
3195 *ptr = NULL;
3196 while (this) {
3197 if (this->buffer_length) {
3198 fd_dma_mem_free((unsigned long)this->kernel_data,
3199 this->buffer_length);
3200 this->buffer_length = 0;
3202 next = this->next;
3203 kfree(this);
3204 this = next;
3208 static inline int raw_cmd_copyin(int cmd, char __user *param,
3209 struct floppy_raw_cmd **rcmd)
3211 struct floppy_raw_cmd *ptr;
3212 int ret;
3213 int i;
3215 *rcmd = NULL;
3216 while (1) {
3217 ptr = (struct floppy_raw_cmd *)
3218 kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3219 if (!ptr)
3220 return -ENOMEM;
3221 *rcmd = ptr;
3222 COPYIN(*ptr);
3223 ptr->next = NULL;
3224 ptr->buffer_length = 0;
3225 param += sizeof(struct floppy_raw_cmd);
3226 if (ptr->cmd_count > 33)
3227 /* the command may now also take up the space
3228 * initially intended for the reply & the
3229 * reply count. Needed for long 82078 commands
3230 * such as RESTORE, which takes ... 17 command
3231 * bytes. Murphy's law #137: When you reserve
3232 * 16 bytes for a structure, you'll one day
3233 * discover that you really need 17...
3235 return -EINVAL;
3237 for (i = 0; i < 16; i++)
3238 ptr->reply[i] = 0;
3239 ptr->resultcode = 0;
3240 ptr->kernel_data = NULL;
3242 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3243 if (ptr->length <= 0)
3244 return -EINVAL;
3245 ptr->kernel_data =
3246 (char *)fd_dma_mem_alloc(ptr->length);
3247 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3248 if (!ptr->kernel_data)
3249 return -ENOMEM;
3250 ptr->buffer_length = ptr->length;
3252 if (ptr->flags & FD_RAW_WRITE)
3253 ECALL(fd_copyin(ptr->data, ptr->kernel_data,
3254 ptr->length));
3255 rcmd = &(ptr->next);
3256 if (!(ptr->flags & FD_RAW_MORE))
3257 return 0;
3258 ptr->rate &= 0x43;
3262 static int raw_cmd_ioctl(int cmd, void __user *param)
3264 int drive, ret, ret2;
3265 struct floppy_raw_cmd *my_raw_cmd;
3267 if (FDCS->rawcmd <= 1)
3268 FDCS->rawcmd = 1;
3269 for (drive = 0; drive < N_DRIVE; drive++) {
3270 if (FDC(drive) != fdc)
3271 continue;
3272 if (drive == current_drive) {
3273 if (UDRS->fd_ref > 1) {
3274 FDCS->rawcmd = 2;
3275 break;
3277 } else if (UDRS->fd_ref) {
3278 FDCS->rawcmd = 2;
3279 break;
3283 if (FDCS->reset)
3284 return -EIO;
3286 ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3287 if (ret) {
3288 raw_cmd_free(&my_raw_cmd);
3289 return ret;
3292 raw_cmd = my_raw_cmd;
3293 cont = &raw_cmd_cont;
3294 ret = wait_til_done(floppy_start, 1);
3295 #ifdef DCL_DEBUG
3296 if (DP->flags & FD_DEBUG) {
3297 DPRINT("calling disk change from raw_cmd ioctl\n");
3299 #endif
3301 if (ret != -EINTR && FDCS->reset)
3302 ret = -EIO;
3304 DRS->track = NO_TRACK;
3306 ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3307 if (!ret)
3308 ret = ret2;
3309 raw_cmd_free(&my_raw_cmd);
3310 return ret;
3313 static int invalidate_drive(struct block_device *bdev)
3315 /* invalidate the buffer track to force a reread */
3316 set_bit((long)bdev->bd_disk->private_data, &fake_change);
3317 process_fd_request();
3318 check_disk_change(bdev);
3319 return 0;
3322 static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
3323 int drive, int type, struct block_device *bdev)
3325 int cnt;
3327 /* sanity checking for parameters. */
3328 if (g->sect <= 0 ||
3329 g->head <= 0 ||
3330 g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3331 /* check if reserved bits are set */
3332 (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_ZEROBASED)) != 0)
3333 return -EINVAL;
3334 if (type) {
3335 if (!capable(CAP_SYS_ADMIN))
3336 return -EPERM;
3337 mutex_lock(&open_lock);
3338 LOCK_FDC(drive, 1);
3339 floppy_type[type] = *g;
3340 floppy_type[type].name = "user format";
3341 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3342 floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3343 floppy_type[type].size + 1;
3344 process_fd_request();
3345 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3346 struct block_device *bdev = opened_bdev[cnt];
3347 if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3348 continue;
3349 __invalidate_device(bdev);
3351 mutex_unlock(&open_lock);
3352 } else {
3353 int oldStretch;
3354 LOCK_FDC(drive, 1);
3355 if (cmd != FDDEFPRM)
3356 /* notice a disk change immediately, else
3357 * we lose our settings immediately*/
3358 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3359 oldStretch = g->stretch;
3360 user_params[drive] = *g;
3361 if (buffer_drive == drive)
3362 SUPBOUND(buffer_max, user_params[drive].sect);
3363 current_type[drive] = &user_params[drive];
3364 floppy_sizes[drive] = user_params[drive].size;
3365 if (cmd == FDDEFPRM)
3366 DRS->keep_data = -1;
3367 else
3368 DRS->keep_data = 1;
3369 /* invalidation. Invalidate only when needed, i.e.
3370 * when there are already sectors in the buffer cache
3371 * whose number will change. This is useful, because
3372 * mtools often changes the geometry of the disk after
3373 * looking at the boot block */
3374 if (DRS->maxblock > user_params[drive].sect ||
3375 DRS->maxtrack ||
3376 ((user_params[drive].sect ^ oldStretch) &
3377 (FD_SWAPSIDES | FD_ZEROBASED)))
3378 invalidate_drive(bdev);
3379 else
3380 process_fd_request();
3382 return 0;
3385 /* handle obsolete ioctl's */
3386 static int ioctl_table[] = {
3387 FDCLRPRM,
3388 FDSETPRM,
3389 FDDEFPRM,
3390 FDGETPRM,
3391 FDMSGON,
3392 FDMSGOFF,
3393 FDFMTBEG,
3394 FDFMTTRK,
3395 FDFMTEND,
3396 FDSETEMSGTRESH,
3397 FDFLUSH,
3398 FDSETMAXERRS,
3399 FDGETMAXERRS,
3400 FDGETDRVTYP,
3401 FDSETDRVPRM,
3402 FDGETDRVPRM,
3403 FDGETDRVSTAT,
3404 FDPOLLDRVSTAT,
3405 FDRESET,
3406 FDGETFDCSTAT,
3407 FDWERRORCLR,
3408 FDWERRORGET,
3409 FDRAWCMD,
3410 FDEJECT,
3411 FDTWADDLE
3414 static inline int normalize_ioctl(int *cmd, int *size)
3416 int i;
3418 for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3419 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3420 *size = _IOC_SIZE(*cmd);
3421 *cmd = ioctl_table[i];
3422 if (*size > _IOC_SIZE(*cmd)) {
3423 printk("ioctl not yet supported\n");
3424 return -EFAULT;
3426 return 0;
3429 return -EINVAL;
3432 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3434 if (type)
3435 *g = &floppy_type[type];
3436 else {
3437 LOCK_FDC(drive, 0);
3438 CALL(poll_drive(0, 0));
3439 process_fd_request();
3440 *g = current_type[drive];
3442 if (!*g)
3443 return -ENODEV;
3444 return 0;
3447 static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3449 int drive = (long)bdev->bd_disk->private_data;
3450 int type = ITYPE(drive_state[drive].fd_device);
3451 struct floppy_struct *g;
3452 int ret;
3454 ret = get_floppy_geometry(drive, type, &g);
3455 if (ret)
3456 return ret;
3458 geo->heads = g->head;
3459 geo->sectors = g->sect;
3460 geo->cylinders = g->track;
3461 return 0;
3464 static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
3465 unsigned long param)
3467 #define FD_IOCTL_ALLOWED ((filp) && (filp)->private_data)
3468 #define OUT(c,x) case c: outparam = (const char *) (x); break
3469 #define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
3471 int drive = (long)inode->i_bdev->bd_disk->private_data;
3472 int i, type = ITYPE(UDRS->fd_device);
3473 int ret;
3474 int size;
3475 union inparam {
3476 struct floppy_struct g; /* geometry */
3477 struct format_descr f;
3478 struct floppy_max_errors max_errors;
3479 struct floppy_drive_params dp;
3480 } inparam; /* parameters coming from user space */
3481 const char *outparam; /* parameters passed back to user space */
3483 /* convert compatibility eject ioctls into floppy eject ioctl.
3484 * We do this in order to provide a means to eject floppy disks before
3485 * installing the new fdutils package */
3486 if (cmd == CDROMEJECT || /* CD-ROM eject */
3487 cmd == 0x6470 /* SunOS floppy eject */ ) {
3488 DPRINT("obsolete eject ioctl\n");
3489 DPRINT("please use floppycontrol --eject\n");
3490 cmd = FDEJECT;
3493 /* convert the old style command into a new style command */
3494 if ((cmd & 0xff00) == 0x0200) {
3495 ECALL(normalize_ioctl(&cmd, &size));
3496 } else
3497 return -EINVAL;
3499 /* permission checks */
3500 if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
3501 ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3502 return -EPERM;
3504 /* copyin */
3505 CLEARSTRUCT(&inparam);
3506 if (_IOC_DIR(cmd) & _IOC_WRITE)
3507 ECALL(fd_copyin((void __user *)param, &inparam, size))
3509 switch (cmd) {
3510 case FDEJECT:
3511 if (UDRS->fd_ref != 1)
3512 /* somebody else has this drive open */
3513 return -EBUSY;
3514 LOCK_FDC(drive, 1);
3516 /* do the actual eject. Fails on
3517 * non-Sparc architectures */
3518 ret = fd_eject(UNIT(drive));
3520 USETF(FD_DISK_CHANGED);
3521 USETF(FD_VERIFY);
3522 process_fd_request();
3523 return ret;
3524 case FDCLRPRM:
3525 LOCK_FDC(drive, 1);
3526 current_type[drive] = NULL;
3527 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3528 UDRS->keep_data = 0;
3529 return invalidate_drive(inode->i_bdev);
3530 case FDSETPRM:
3531 case FDDEFPRM:
3532 return set_geometry(cmd, &inparam.g,
3533 drive, type, inode->i_bdev);
3534 case FDGETPRM:
3535 ECALL(get_floppy_geometry(drive, type,
3536 (struct floppy_struct **)
3537 &outparam));
3538 break;
3540 case FDMSGON:
3541 UDP->flags |= FTD_MSG;
3542 return 0;
3543 case FDMSGOFF:
3544 UDP->flags &= ~FTD_MSG;
3545 return 0;
3547 case FDFMTBEG:
3548 LOCK_FDC(drive, 1);
3549 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3550 ret = UDRS->flags;
3551 process_fd_request();
3552 if (ret & FD_VERIFY)
3553 return -ENODEV;
3554 if (!(ret & FD_DISK_WRITABLE))
3555 return -EROFS;
3556 return 0;
3557 case FDFMTTRK:
3558 if (UDRS->fd_ref != 1)
3559 return -EBUSY;
3560 return do_format(drive, &inparam.f);
3561 case FDFMTEND:
3562 case FDFLUSH:
3563 LOCK_FDC(drive, 1);
3564 return invalidate_drive(inode->i_bdev);
3566 case FDSETEMSGTRESH:
3567 UDP->max_errors.reporting =
3568 (unsigned short)(param & 0x0f);
3569 return 0;
3570 OUT(FDGETMAXERRS, &UDP->max_errors);
3571 IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
3573 case FDGETDRVTYP:
3574 outparam = drive_name(type, drive);
3575 SUPBOUND(size, strlen(outparam) + 1);
3576 break;
3578 IN(FDSETDRVPRM, UDP, dp);
3579 OUT(FDGETDRVPRM, UDP);
3581 case FDPOLLDRVSTAT:
3582 LOCK_FDC(drive, 1);
3583 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3584 process_fd_request();
3585 /* fall through */
3586 OUT(FDGETDRVSTAT, UDRS);
3588 case FDRESET:
3589 return user_reset_fdc(drive, (int)param, 1);
3591 OUT(FDGETFDCSTAT, UFDCS);
3593 case FDWERRORCLR:
3594 CLEARSTRUCT(UDRWE);
3595 return 0;
3596 OUT(FDWERRORGET, UDRWE);
3598 case FDRAWCMD:
3599 if (type)
3600 return -EINVAL;
3601 LOCK_FDC(drive, 1);
3602 set_floppy(drive);
3603 CALL(i = raw_cmd_ioctl(cmd, (void __user *)param));
3604 process_fd_request();
3605 return i;
3607 case FDTWADDLE:
3608 LOCK_FDC(drive, 1);
3609 twaddle();
3610 process_fd_request();
3611 return 0;
3613 default:
3614 return -EINVAL;
3617 if (_IOC_DIR(cmd) & _IOC_READ)
3618 return fd_copyout((void __user *)param, outparam, size);
3619 else
3620 return 0;
3621 #undef OUT
3622 #undef IN
3625 static void __init config_types(void)
3627 int first = 1;
3628 int drive;
3630 /* read drive info out of physical CMOS */
3631 drive = 0;
3632 if (!UDP->cmos)
3633 UDP->cmos = FLOPPY0_TYPE;
3634 drive = 1;
3635 if (!UDP->cmos && FLOPPY1_TYPE)
3636 UDP->cmos = FLOPPY1_TYPE;
3638 /* XXX */
3639 /* additional physical CMOS drive detection should go here */
3641 for (drive = 0; drive < N_DRIVE; drive++) {
3642 unsigned int type = UDP->cmos;
3643 struct floppy_drive_params *params;
3644 const char *name = NULL;
3645 static char temparea[32];
3647 if (type < ARRAY_SIZE(default_drive_params)) {
3648 params = &default_drive_params[type].params;
3649 if (type) {
3650 name = default_drive_params[type].name;
3651 allowed_drive_mask |= 1 << drive;
3652 } else
3653 allowed_drive_mask &= ~(1 << drive);
3654 } else {
3655 params = &default_drive_params[0].params;
3656 sprintf(temparea, "unknown type %d (usb?)", type);
3657 name = temparea;
3659 if (name) {
3660 const char *prepend = ",";
3661 if (first) {
3662 prepend = KERN_INFO "Floppy drive(s):";
3663 first = 0;
3665 printk("%s fd%d is %s", prepend, drive, name);
3666 register_devfs_entries(drive);
3668 *UDP = *params;
3670 if (!first)
3671 printk("\n");
3674 static int floppy_release(struct inode *inode, struct file *filp)
3676 int drive = (long)inode->i_bdev->bd_disk->private_data;
3678 mutex_lock(&open_lock);
3679 if (UDRS->fd_ref < 0)
3680 UDRS->fd_ref = 0;
3681 else if (!UDRS->fd_ref--) {
3682 DPRINT("floppy_release with fd_ref == 0");
3683 UDRS->fd_ref = 0;
3685 if (!UDRS->fd_ref)
3686 opened_bdev[drive] = NULL;
3687 floppy_release_irq_and_dma();
3688 mutex_unlock(&open_lock);
3689 return 0;
3693 * floppy_open check for aliasing (/dev/fd0 can be the same as
3694 * /dev/PS0 etc), and disallows simultaneous access to the same
3695 * drive with different device numbers.
3697 static int floppy_open(struct inode *inode, struct file *filp)
3699 int drive = (long)inode->i_bdev->bd_disk->private_data;
3700 int old_dev;
3701 int try;
3702 int res = -EBUSY;
3703 char *tmp;
3705 filp->private_data = (void *)0;
3706 mutex_lock(&open_lock);
3707 old_dev = UDRS->fd_device;
3708 if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
3709 goto out2;
3711 if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
3712 USETF(FD_DISK_CHANGED);
3713 USETF(FD_VERIFY);
3716 if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
3717 goto out2;
3719 if (floppy_grab_irq_and_dma())
3720 goto out2;
3722 if (filp->f_flags & O_EXCL)
3723 UDRS->fd_ref = -1;
3724 else
3725 UDRS->fd_ref++;
3727 opened_bdev[drive] = inode->i_bdev;
3729 res = -ENXIO;
3731 if (!floppy_track_buffer) {
3732 /* if opening an ED drive, reserve a big buffer,
3733 * else reserve a small one */
3734 if ((UDP->cmos == 6) || (UDP->cmos == 5))
3735 try = 64; /* Only 48 actually useful */
3736 else
3737 try = 32; /* Only 24 actually useful */
3739 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3740 if (!tmp && !floppy_track_buffer) {
3741 try >>= 1; /* buffer only one side */
3742 INFBOUND(try, 16);
3743 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3745 if (!tmp && !floppy_track_buffer) {
3746 fallback_on_nodma_alloc(&tmp, 2048 * try);
3748 if (!tmp && !floppy_track_buffer) {
3749 DPRINT("Unable to allocate DMA memory\n");
3750 goto out;
3752 if (floppy_track_buffer) {
3753 if (tmp)
3754 fd_dma_mem_free((unsigned long)tmp, try * 1024);
3755 } else {
3756 buffer_min = buffer_max = -1;
3757 floppy_track_buffer = tmp;
3758 max_buffer_sectors = try;
3762 UDRS->fd_device = iminor(inode);
3763 set_capacity(disks[drive], floppy_sizes[iminor(inode)]);
3764 if (old_dev != -1 && old_dev != iminor(inode)) {
3765 if (buffer_drive == drive)
3766 buffer_track = -1;
3769 /* Allow ioctls if we have write-permissions even if read-only open.
3770 * Needed so that programs such as fdrawcmd still can work on write
3771 * protected disks */
3772 if ((filp->f_mode & FMODE_WRITE) || !file_permission(filp, MAY_WRITE))
3773 filp->private_data = (void *)8;
3775 if (UFDCS->rawcmd == 1)
3776 UFDCS->rawcmd = 2;
3778 if (!(filp->f_flags & O_NDELAY)) {
3779 if (filp->f_mode & 3) {
3780 UDRS->last_checked = 0;
3781 check_disk_change(inode->i_bdev);
3782 if (UTESTF(FD_DISK_CHANGED))
3783 goto out;
3785 res = -EROFS;
3786 if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
3787 goto out;
3789 mutex_unlock(&open_lock);
3790 return 0;
3791 out:
3792 if (UDRS->fd_ref < 0)
3793 UDRS->fd_ref = 0;
3794 else
3795 UDRS->fd_ref--;
3796 if (!UDRS->fd_ref)
3797 opened_bdev[drive] = NULL;
3798 floppy_release_irq_and_dma();
3799 out2:
3800 mutex_unlock(&open_lock);
3801 return res;
3805 * Check if the disk has been changed or if a change has been faked.
3807 static int check_floppy_change(struct gendisk *disk)
3809 int drive = (long)disk->private_data;
3811 if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
3812 return 1;
3814 if (UDP->checkfreq < (int)(jiffies - UDRS->last_checked)) {
3815 if (floppy_grab_irq_and_dma()) {
3816 return 1;
3819 lock_fdc(drive, 0);
3820 poll_drive(0, 0);
3821 process_fd_request();
3822 floppy_release_irq_and_dma();
3825 if (UTESTF(FD_DISK_CHANGED) ||
3826 UTESTF(FD_VERIFY) ||
3827 test_bit(drive, &fake_change) ||
3828 (!ITYPE(UDRS->fd_device) && !current_type[drive]))
3829 return 1;
3830 return 0;
3834 * This implements "read block 0" for floppy_revalidate().
3835 * Needed for format autodetection, checking whether there is
3836 * a disk in the drive, and whether that disk is writable.
3839 static int floppy_rb0_complete(struct bio *bio, unsigned int bytes_done,
3840 int err)
3842 if (bio->bi_size)
3843 return 1;
3845 complete((struct completion *)bio->bi_private);
3846 return 0;
3849 static int __floppy_read_block_0(struct block_device *bdev)
3851 struct bio bio;
3852 struct bio_vec bio_vec;
3853 struct completion complete;
3854 struct page *page;
3855 size_t size;
3857 page = alloc_page(GFP_NOIO);
3858 if (!page) {
3859 process_fd_request();
3860 return -ENOMEM;
3863 size = bdev->bd_block_size;
3864 if (!size)
3865 size = 1024;
3867 bio_init(&bio);
3868 bio.bi_io_vec = &bio_vec;
3869 bio_vec.bv_page = page;
3870 bio_vec.bv_len = size;
3871 bio_vec.bv_offset = 0;
3872 bio.bi_vcnt = 1;
3873 bio.bi_idx = 0;
3874 bio.bi_size = size;
3875 bio.bi_bdev = bdev;
3876 bio.bi_sector = 0;
3877 init_completion(&complete);
3878 bio.bi_private = &complete;
3879 bio.bi_end_io = floppy_rb0_complete;
3881 submit_bio(READ, &bio);
3882 generic_unplug_device(bdev_get_queue(bdev));
3883 process_fd_request();
3884 wait_for_completion(&complete);
3886 __free_page(page);
3888 return 0;
3891 /* revalidate the floppy disk, i.e. trigger format autodetection by reading
3892 * the bootblock (block 0). "Autodetection" is also needed to check whether
3893 * there is a disk in the drive at all... Thus we also do it for fixed
3894 * geometry formats */
3895 static int floppy_revalidate(struct gendisk *disk)
3897 int drive = (long)disk->private_data;
3898 #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
3899 int cf;
3900 int res = 0;
3902 if (UTESTF(FD_DISK_CHANGED) ||
3903 UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
3904 if (usage_count == 0) {
3905 printk("VFS: revalidate called on non-open device.\n");
3906 return -EFAULT;
3908 lock_fdc(drive, 0);
3909 cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
3910 if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
3911 process_fd_request(); /*already done by another thread */
3912 return 0;
3914 UDRS->maxblock = 0;
3915 UDRS->maxtrack = 0;
3916 if (buffer_drive == drive)
3917 buffer_track = -1;
3918 clear_bit(drive, &fake_change);
3919 UCLEARF(FD_DISK_CHANGED);
3920 if (cf)
3921 UDRS->generation++;
3922 if (NO_GEOM) {
3923 /* auto-sensing */
3924 res = __floppy_read_block_0(opened_bdev[drive]);
3925 } else {
3926 if (cf)
3927 poll_drive(0, FD_RAW_NEED_DISK);
3928 process_fd_request();
3931 set_capacity(disk, floppy_sizes[UDRS->fd_device]);
3932 return res;
3935 static struct block_device_operations floppy_fops = {
3936 .owner = THIS_MODULE,
3937 .open = floppy_open,
3938 .release = floppy_release,
3939 .ioctl = fd_ioctl,
3940 .getgeo = fd_getgeo,
3941 .media_changed = check_floppy_change,
3942 .revalidate_disk = floppy_revalidate,
3944 static char *table[] = {
3945 "", "d360", "h1200", "u360", "u720", "h360", "h720",
3946 "u1440", "u2880", "CompaQ", "h1440", "u1680", "h410",
3947 "u820", "h1476", "u1722", "h420", "u830", "h1494", "u1743",
3948 "h880", "u1040", "u1120", "h1600", "u1760", "u1920",
3949 "u3200", "u3520", "u3840", "u1840", "u800", "u1600",
3950 NULL
3952 static int t360[] = { 1, 0 },
3953 t1200[] = { 2, 5, 6, 10, 12, 14, 16, 18, 20, 23, 0 },
3954 t3in[] = { 8, 9, 26, 27, 28, 7, 11, 15, 19, 24, 25, 29, 31, 3, 4, 13,
3955 17, 21, 22, 30, 0 };
3956 static int *table_sup[] =
3957 { NULL, t360, t1200, t3in + 5 + 8, t3in + 5, t3in, t3in };
3959 static void __init register_devfs_entries(int drive)
3961 int base_minor = (drive < 4) ? drive : (124 + drive);
3963 if (UDP->cmos < ARRAY_SIZE(default_drive_params)) {
3964 int i = 0;
3965 do {
3966 int minor = base_minor + (table_sup[UDP->cmos][i] << 2);
3968 devfs_mk_bdev(MKDEV(FLOPPY_MAJOR, minor),
3969 S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP |
3970 S_IWGRP, "floppy/%d%s", drive,
3971 table[table_sup[UDP->cmos][i]]);
3972 } while (table_sup[UDP->cmos][i++]);
3977 * Floppy Driver initialization
3978 * =============================
3981 /* Determine the floppy disk controller type */
3982 /* This routine was written by David C. Niemi */
3983 static char __init get_fdc_version(void)
3985 int r;
3987 output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */
3988 if (FDCS->reset)
3989 return FDC_NONE;
3990 if ((r = result()) <= 0x00)
3991 return FDC_NONE; /* No FDC present ??? */
3992 if ((r == 1) && (reply_buffer[0] == 0x80)) {
3993 printk(KERN_INFO "FDC %d is an 8272A\n", fdc);
3994 return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
3996 if (r != 10) {
3997 printk
3998 ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
3999 fdc, r);
4000 return FDC_UNKNOWN;
4003 if (!fdc_configure()) {
4004 printk(KERN_INFO "FDC %d is an 82072\n", fdc);
4005 return FDC_82072; /* 82072 doesn't know CONFIGURE */
4008 output_byte(FD_PERPENDICULAR);
4009 if (need_more_output() == MORE_OUTPUT) {
4010 output_byte(0);
4011 } else {
4012 printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
4013 return FDC_82072A; /* 82072A as found on Sparcs. */
4016 output_byte(FD_UNLOCK);
4017 r = result();
4018 if ((r == 1) && (reply_buffer[0] == 0x80)) {
4019 printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
4020 return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
4021 * LOCK/UNLOCK */
4023 if ((r != 1) || (reply_buffer[0] != 0x00)) {
4024 printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
4025 fdc, r);
4026 return FDC_UNKNOWN;
4028 output_byte(FD_PARTID);
4029 r = result();
4030 if (r != 1) {
4031 printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
4032 fdc, r);
4033 return FDC_UNKNOWN;
4035 if (reply_buffer[0] == 0x80) {
4036 printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);
4037 return FDC_82077; /* Revised 82077AA passes all the tests */
4039 switch (reply_buffer[0] >> 5) {
4040 case 0x0:
4041 /* Either a 82078-1 or a 82078SL running at 5Volt */
4042 printk(KERN_INFO "FDC %d is an 82078.\n", fdc);
4043 return FDC_82078;
4044 case 0x1:
4045 printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);
4046 return FDC_82078;
4047 case 0x2:
4048 printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
4049 return FDC_S82078B;
4050 case 0x3:
4051 printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",
4052 fdc);
4053 return FDC_87306;
4054 default:
4055 printk(KERN_INFO
4056 "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
4057 fdc, reply_buffer[0] >> 5);
4058 return FDC_82078_UNKN;
4060 } /* get_fdc_version */
4062 /* lilo configuration */
4064 static void __init floppy_set_flags(int *ints, int param, int param2)
4066 int i;
4068 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4069 if (param)
4070 default_drive_params[i].params.flags |= param2;
4071 else
4072 default_drive_params[i].params.flags &= ~param2;
4074 DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4077 static void __init daring(int *ints, int param, int param2)
4079 int i;
4081 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4082 if (param) {
4083 default_drive_params[i].params.select_delay = 0;
4084 default_drive_params[i].params.flags |=
4085 FD_SILENT_DCL_CLEAR;
4086 } else {
4087 default_drive_params[i].params.select_delay =
4088 2 * HZ / 100;
4089 default_drive_params[i].params.flags &=
4090 ~FD_SILENT_DCL_CLEAR;
4093 DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4096 static void __init set_cmos(int *ints, int dummy, int dummy2)
4098 int current_drive = 0;
4100 if (ints[0] != 2) {
4101 DPRINT("wrong number of parameters for CMOS\n");
4102 return;
4104 current_drive = ints[1];
4105 if (current_drive < 0 || current_drive >= 8) {
4106 DPRINT("bad drive for set_cmos\n");
4107 return;
4109 #if N_FDC > 1
4110 if (current_drive >= 4 && !FDC2)
4111 FDC2 = 0x370;
4112 #endif
4113 DP->cmos = ints[2];
4114 DPRINT("setting CMOS code to %d\n", ints[2]);
4117 static struct param_table {
4118 const char *name;
4119 void (*fn) (int *ints, int param, int param2);
4120 int *var;
4121 int def_param;
4122 int param2;
4123 } config_params[] __initdata = {
4124 {"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4125 {"all_drives", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4126 {"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
4127 {"irq", NULL, &FLOPPY_IRQ, 6, 0},
4128 {"dma", NULL, &FLOPPY_DMA, 2, 0},
4129 {"daring", daring, NULL, 1, 0},
4130 #if N_FDC > 1
4131 {"two_fdc", NULL, &FDC2, 0x370, 0},
4132 {"one_fdc", NULL, &FDC2, 0, 0},
4133 #endif
4134 {"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
4135 {"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
4136 {"messages", floppy_set_flags, NULL, 1, FTD_MSG},
4137 {"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
4138 {"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
4139 {"nodma", NULL, &can_use_virtual_dma, 1, 0},
4140 {"omnibook", NULL, &can_use_virtual_dma, 1, 0},
4141 {"yesdma", NULL, &can_use_virtual_dma, 0, 0},
4142 {"fifo_depth", NULL, &fifo_depth, 0xa, 0},
4143 {"nofifo", NULL, &no_fifo, 0x20, 0},
4144 {"usefifo", NULL, &no_fifo, 0, 0},
4145 {"cmos", set_cmos, NULL, 0, 0},
4146 {"slow", NULL, &slow_floppy, 1, 0},
4147 {"unexpected_interrupts", NULL, &print_unex, 1, 0},
4148 {"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
4149 {"L40SX", NULL, &print_unex, 0, 0}
4151 EXTRA_FLOPPY_PARAMS
4154 static int __init floppy_setup(char *str)
4156 int i;
4157 int param;
4158 int ints[11];
4160 str = get_options(str, ARRAY_SIZE(ints), ints);
4161 if (str) {
4162 for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4163 if (strcmp(str, config_params[i].name) == 0) {
4164 if (ints[0])
4165 param = ints[1];
4166 else
4167 param = config_params[i].def_param;
4168 if (config_params[i].fn)
4169 config_params[i].
4170 fn(ints, param,
4171 config_params[i].param2);
4172 if (config_params[i].var) {
4173 DPRINT("%s=%d\n", str, param);
4174 *config_params[i].var = param;
4176 return 1;
4180 if (str) {
4181 DPRINT("unknown floppy option [%s]\n", str);
4183 DPRINT("allowed options are:");
4184 for (i = 0; i < ARRAY_SIZE(config_params); i++)
4185 printk(" %s", config_params[i].name);
4186 printk("\n");
4187 } else
4188 DPRINT("botched floppy option\n");
4189 DPRINT("Read Documentation/floppy.txt\n");
4190 return 0;
4193 static int have_no_fdc = -ENODEV;
4195 static ssize_t floppy_cmos_show(struct device *dev,
4196 struct device_attribute *attr, char *buf)
4198 struct platform_device *p;
4199 int drive;
4201 p = container_of(dev, struct platform_device,dev);
4202 drive = p->id;
4203 return sprintf(buf, "%X\n", UDP->cmos);
4205 DEVICE_ATTR(cmos,S_IRUGO,floppy_cmos_show,NULL);
4207 static void floppy_device_release(struct device *dev)
4209 complete(&device_release);
4212 static struct platform_device floppy_device[N_DRIVE];
4214 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4216 int drive = (*part & 3) | ((*part & 0x80) >> 5);
4217 if (drive >= N_DRIVE ||
4218 !(allowed_drive_mask & (1 << drive)) ||
4219 fdc_state[FDC(drive)].version == FDC_NONE)
4220 return NULL;
4221 if (((*part >> 2) & 0x1f) >= ARRAY_SIZE(floppy_type))
4222 return NULL;
4223 *part = 0;
4224 return get_disk(disks[drive]);
4227 static int __init floppy_init(void)
4229 int i, unit, drive;
4230 int err, dr;
4232 raw_cmd = NULL;
4234 for (dr = 0; dr < N_DRIVE; dr++) {
4235 disks[dr] = alloc_disk(1);
4236 if (!disks[dr]) {
4237 err = -ENOMEM;
4238 goto out_put_disk;
4241 disks[dr]->major = FLOPPY_MAJOR;
4242 disks[dr]->first_minor = TOMINOR(dr);
4243 disks[dr]->fops = &floppy_fops;
4244 sprintf(disks[dr]->disk_name, "fd%d", dr);
4246 init_timer(&motor_off_timer[dr]);
4247 motor_off_timer[dr].data = dr;
4248 motor_off_timer[dr].function = motor_off_callback;
4251 devfs_mk_dir("floppy");
4253 err = register_blkdev(FLOPPY_MAJOR, "fd");
4254 if (err)
4255 goto out_devfs_remove;
4257 floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
4258 if (!floppy_queue) {
4259 err = -ENOMEM;
4260 goto out_unreg_blkdev;
4262 blk_queue_max_sectors(floppy_queue, 64);
4264 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4265 floppy_find, NULL, NULL);
4267 for (i = 0; i < 256; i++)
4268 if (ITYPE(i))
4269 floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4270 else
4271 floppy_sizes[i] = MAX_DISK_SIZE << 1;
4273 reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
4274 config_types();
4276 for (i = 0; i < N_FDC; i++) {
4277 fdc = i;
4278 CLEARSTRUCT(FDCS);
4279 FDCS->dtr = -1;
4280 FDCS->dor = 0x4;
4281 #if defined(__sparc__) || defined(__mc68000__)
4282 /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
4283 #ifdef __mc68000__
4284 if (MACH_IS_SUN3X)
4285 #endif
4286 FDCS->version = FDC_82072A;
4287 #endif
4290 use_virtual_dma = can_use_virtual_dma & 1;
4291 #if defined(CONFIG_PPC64)
4292 if (check_legacy_ioport(FDC1)) {
4293 del_timer(&fd_timeout);
4294 err = -ENODEV;
4295 goto out_unreg_region;
4297 #endif
4298 fdc_state[0].address = FDC1;
4299 if (fdc_state[0].address == -1) {
4300 del_timer(&fd_timeout);
4301 err = -ENODEV;
4302 goto out_unreg_region;
4304 #if N_FDC > 1
4305 fdc_state[1].address = FDC2;
4306 #endif
4308 fdc = 0; /* reset fdc in case of unexpected interrupt */
4309 err = floppy_grab_irq_and_dma();
4310 if (err) {
4311 del_timer(&fd_timeout);
4312 err = -EBUSY;
4313 goto out_unreg_region;
4316 /* initialise drive state */
4317 for (drive = 0; drive < N_DRIVE; drive++) {
4318 CLEARSTRUCT(UDRS);
4319 CLEARSTRUCT(UDRWE);
4320 USETF(FD_DISK_NEWCHANGE);
4321 USETF(FD_DISK_CHANGED);
4322 USETF(FD_VERIFY);
4323 UDRS->fd_device = -1;
4324 floppy_track_buffer = NULL;
4325 max_buffer_sectors = 0;
4328 * Small 10 msec delay to let through any interrupt that
4329 * initialization might have triggered, to not
4330 * confuse detection:
4332 msleep(10);
4334 for (i = 0; i < N_FDC; i++) {
4335 fdc = i;
4336 FDCS->driver_version = FD_DRIVER_VERSION;
4337 for (unit = 0; unit < 4; unit++)
4338 FDCS->track[unit] = 0;
4339 if (FDCS->address == -1)
4340 continue;
4341 FDCS->rawcmd = 2;
4342 if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
4343 /* free ioports reserved by floppy_grab_irq_and_dma() */
4344 release_region(FDCS->address + 2, 4);
4345 release_region(FDCS->address + 7, 1);
4346 FDCS->address = -1;
4347 FDCS->version = FDC_NONE;
4348 continue;
4350 /* Try to determine the floppy controller type */
4351 FDCS->version = get_fdc_version();
4352 if (FDCS->version == FDC_NONE) {
4353 /* free ioports reserved by floppy_grab_irq_and_dma() */
4354 release_region(FDCS->address + 2, 4);
4355 release_region(FDCS->address + 7, 1);
4356 FDCS->address = -1;
4357 continue;
4359 if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
4360 can_use_virtual_dma = 0;
4362 have_no_fdc = 0;
4363 /* Not all FDCs seem to be able to handle the version command
4364 * properly, so force a reset for the standard FDC clones,
4365 * to avoid interrupt garbage.
4367 user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
4369 fdc = 0;
4370 del_timer(&fd_timeout);
4371 current_drive = 0;
4372 floppy_release_irq_and_dma();
4373 initialising = 0;
4374 if (have_no_fdc) {
4375 DPRINT("no floppy controllers found\n");
4376 err = have_no_fdc;
4377 goto out_flush_work;
4380 for (drive = 0; drive < N_DRIVE; drive++) {
4381 if (!(allowed_drive_mask & (1 << drive)))
4382 continue;
4383 if (fdc_state[FDC(drive)].version == FDC_NONE)
4384 continue;
4386 floppy_device[drive].name = floppy_device_name;
4387 floppy_device[drive].id = drive;
4388 floppy_device[drive].dev.release = floppy_device_release;
4390 err = platform_device_register(&floppy_device[drive]);
4391 if (err)
4392 goto out_flush_work;
4394 device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
4395 /* to be cleaned up... */
4396 disks[drive]->private_data = (void *)(long)drive;
4397 disks[drive]->queue = floppy_queue;
4398 disks[drive]->flags |= GENHD_FL_REMOVABLE;
4399 disks[drive]->driverfs_dev = &floppy_device[drive].dev;
4400 add_disk(disks[drive]);
4403 return 0;
4405 out_flush_work:
4406 flush_scheduled_work();
4407 if (usage_count)
4408 floppy_release_irq_and_dma();
4409 out_unreg_region:
4410 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4411 blk_cleanup_queue(floppy_queue);
4412 out_unreg_blkdev:
4413 unregister_blkdev(FLOPPY_MAJOR, "fd");
4414 out_devfs_remove:
4415 devfs_remove("floppy");
4416 out_put_disk:
4417 while (dr--) {
4418 del_timer(&motor_off_timer[dr]);
4419 put_disk(disks[dr]);
4421 return err;
4424 static DEFINE_SPINLOCK(floppy_usage_lock);
4426 static int floppy_grab_irq_and_dma(void)
4428 unsigned long flags;
4430 spin_lock_irqsave(&floppy_usage_lock, flags);
4431 if (usage_count++) {
4432 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4433 return 0;
4435 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4436 if (fd_request_irq()) {
4437 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4438 FLOPPY_IRQ);
4439 spin_lock_irqsave(&floppy_usage_lock, flags);
4440 usage_count--;
4441 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4442 return -1;
4444 if (fd_request_dma()) {
4445 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4446 FLOPPY_DMA);
4447 fd_free_irq();
4448 spin_lock_irqsave(&floppy_usage_lock, flags);
4449 usage_count--;
4450 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4451 return -1;
4454 for (fdc = 0; fdc < N_FDC; fdc++) {
4455 if (FDCS->address != -1) {
4456 if (!request_region(FDCS->address + 2, 4, "floppy")) {
4457 DPRINT("Floppy io-port 0x%04lx in use\n",
4458 FDCS->address + 2);
4459 goto cleanup1;
4461 if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
4462 DPRINT("Floppy io-port 0x%04lx in use\n",
4463 FDCS->address + 7);
4464 goto cleanup2;
4466 /* address + 6 is reserved, and may be taken by IDE.
4467 * Unfortunately, Adaptec doesn't know this :-(, */
4470 for (fdc = 0; fdc < N_FDC; fdc++) {
4471 if (FDCS->address != -1) {
4472 reset_fdc_info(1);
4473 fd_outb(FDCS->dor, FD_DOR);
4476 fdc = 0;
4477 set_dor(0, ~0, 8); /* avoid immediate interrupt */
4479 for (fdc = 0; fdc < N_FDC; fdc++)
4480 if (FDCS->address != -1)
4481 fd_outb(FDCS->dor, FD_DOR);
4483 * The driver will try and free resources and relies on us
4484 * to know if they were allocated or not.
4486 fdc = 0;
4487 irqdma_allocated = 1;
4488 return 0;
4489 cleanup2:
4490 release_region(FDCS->address + 2, 4);
4491 cleanup1:
4492 fd_free_irq();
4493 fd_free_dma();
4494 while (--fdc >= 0) {
4495 release_region(FDCS->address + 2, 4);
4496 release_region(FDCS->address + 7, 1);
4498 spin_lock_irqsave(&floppy_usage_lock, flags);
4499 usage_count--;
4500 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4501 return -1;
4504 static void floppy_release_irq_and_dma(void)
4506 int old_fdc;
4507 #ifdef FLOPPY_SANITY_CHECK
4508 #ifndef __sparc__
4509 int drive;
4510 #endif
4511 #endif
4512 long tmpsize;
4513 unsigned long tmpaddr;
4514 unsigned long flags;
4516 spin_lock_irqsave(&floppy_usage_lock, flags);
4517 if (--usage_count) {
4518 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4519 return;
4521 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4522 if (irqdma_allocated) {
4523 fd_disable_dma();
4524 fd_free_dma();
4525 fd_free_irq();
4526 irqdma_allocated = 0;
4528 set_dor(0, ~0, 8);
4529 #if N_FDC > 1
4530 set_dor(1, ~8, 0);
4531 #endif
4532 floppy_enable_hlt();
4534 if (floppy_track_buffer && max_buffer_sectors) {
4535 tmpsize = max_buffer_sectors * 1024;
4536 tmpaddr = (unsigned long)floppy_track_buffer;
4537 floppy_track_buffer = NULL;
4538 max_buffer_sectors = 0;
4539 buffer_min = buffer_max = -1;
4540 fd_dma_mem_free(tmpaddr, tmpsize);
4542 #ifdef FLOPPY_SANITY_CHECK
4543 #ifndef __sparc__
4544 for (drive = 0; drive < N_FDC * 4; drive++)
4545 if (timer_pending(motor_off_timer + drive))
4546 printk("motor off timer %d still active\n", drive);
4547 #endif
4549 if (timer_pending(&fd_timeout))
4550 printk("floppy timer still active:%s\n", timeout_message);
4551 if (timer_pending(&fd_timer))
4552 printk("auxiliary floppy timer still active\n");
4553 if (floppy_work.pending)
4554 printk("work still pending\n");
4555 #endif
4556 old_fdc = fdc;
4557 for (fdc = 0; fdc < N_FDC; fdc++)
4558 if (FDCS->address != -1) {
4559 release_region(FDCS->address + 2, 4);
4560 release_region(FDCS->address + 7, 1);
4562 fdc = old_fdc;
4565 #ifdef MODULE
4567 static char *floppy;
4569 static void unregister_devfs_entries(int drive)
4571 int i;
4573 if (UDP->cmos < ARRAY_SIZE(default_drive_params)) {
4574 i = 0;
4575 do {
4576 devfs_remove("floppy/%d%s", drive,
4577 table[table_sup[UDP->cmos][i]]);
4578 } while (table_sup[UDP->cmos][i++]);
4582 static void __init parse_floppy_cfg_string(char *cfg)
4584 char *ptr;
4586 while (*cfg) {
4587 for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != '\t'; cfg++) ;
4588 if (*cfg) {
4589 *cfg = '\0';
4590 cfg++;
4592 if (*ptr)
4593 floppy_setup(ptr);
4597 int init_module(void)
4599 if (floppy)
4600 parse_floppy_cfg_string(floppy);
4601 return floppy_init();
4604 void cleanup_module(void)
4606 int drive;
4608 init_completion(&device_release);
4609 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4610 unregister_blkdev(FLOPPY_MAJOR, "fd");
4612 for (drive = 0; drive < N_DRIVE; drive++) {
4613 del_timer_sync(&motor_off_timer[drive]);
4615 if ((allowed_drive_mask & (1 << drive)) &&
4616 fdc_state[FDC(drive)].version != FDC_NONE) {
4617 del_gendisk(disks[drive]);
4618 unregister_devfs_entries(drive);
4619 device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
4620 platform_device_unregister(&floppy_device[drive]);
4622 put_disk(disks[drive]);
4624 devfs_remove("floppy");
4626 del_timer_sync(&fd_timeout);
4627 del_timer_sync(&fd_timer);
4628 blk_cleanup_queue(floppy_queue);
4630 if (usage_count)
4631 floppy_release_irq_and_dma();
4633 /* eject disk, if any */
4634 fd_eject(0);
4636 wait_for_completion(&device_release);
4639 module_param(floppy, charp, 0);
4640 module_param(FLOPPY_IRQ, int, 0);
4641 module_param(FLOPPY_DMA, int, 0);
4642 MODULE_AUTHOR("Alain L. Knaff");
4643 MODULE_SUPPORTED_DEVICE("fd");
4644 MODULE_LICENSE("GPL");
4646 #else
4648 __setup("floppy=", floppy_setup);
4649 module_init(floppy_init)
4650 #endif
4652 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);