ia64/linux-2.6.18-xen.hg

view drivers/block/floppy.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents fbfa306ab465
children
line source
1 /*
2 * linux/drivers/block/floppy.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1993, 1994 Alain Knaff
6 * Copyright (C) 1998 Alan Cox
7 */
8 /*
9 * 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.
13 */
15 /*
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.
21 */
23 /*
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.
29 */
31 /*
32 * 28.02.92 - made track-buffering routines, based on the routines written
33 * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
34 */
36 /*
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.
40 */
42 /*
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.
46 *
47 * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
48 *
49 * TODO: Errors are still not counted properly.
50 */
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.
60 */
62 /*
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.
66 */
68 /* 1994/6/24 --bbroad-- added the floppy table entries and made
69 * minor modifications to allow 2.88 floppies to be run.
70 */
72 /* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
73 * disk types.
74 */
76 /*
77 * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
78 * format bug fixes, but unfortunately some new bugs too...
79 */
81 /* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
82 * errors to allow safe writing by specialized programs.
83 */
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").
89 */
91 /*
92 * 1995/8/26 -- Andreas Busse -- added Mips support.
93 */
95 /*
96 * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
97 * features to asm/floppy.h.
98 */
100 /*
101 * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
102 */
104 /*
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.
108 */
110 /*
111 * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
112 * failures.
113 */
115 /*
116 * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
117 */
119 /*
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).
123 */
125 /*
126 * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
127 * - get rid of check_region
128 * - s/suser/capable/
129 */
131 /*
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.)
134 */
136 /*
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.
140 */
142 /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
143 * Better audit of register_blkdev.
144 */
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/jiffies.h>
174 #include <linux/fcntl.h>
175 #include <linux/delay.h>
176 #include <linux/mc146818rtc.h> /* CMOS defines */
177 #include <linux/ioport.h>
178 #include <linux/interrupt.h>
179 #include <linux/init.h>
180 #include <linux/platform_device.h>
181 #include <linux/buffer_head.h> /* for invalidate_buffers() */
182 #include <linux/mutex.h>
184 /*
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.
188 */
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
206 */
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
218 */
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);
227 #define K_64 0x10000 /* 64KB */
229 /* the following is the mask of allowed drives. By default units 2 and
230 * 3 of both floppy controllers are disabled, because switching on the
231 * motor of these drives causes system hangs on some PCI computers. drive
232 * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
233 * a drive is allowed.
234 *
235 * NOTE: This must come before we include the arch floppy header because
236 * some ports reference this variable from there. -DaveM
237 */
239 static int allowed_drive_mask = 0x33;
241 #include <asm/floppy.h>
243 static int irqdma_allocated;
245 #define DEVICE_NAME "floppy"
247 #include <linux/blkdev.h>
248 #include <linux/blkpg.h>
249 #include <linux/cdrom.h> /* for the compatibility eject ioctl */
250 #include <linux/completion.h>
252 static struct request *current_req;
253 static struct request_queue *floppy_queue;
254 static void do_fd_request(request_queue_t * q);
256 #ifndef fd_get_dma_residue
257 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
258 #endif
260 /* Dma Memory related stuff */
262 #ifndef fd_dma_mem_free
263 #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
264 #endif
266 #ifndef fd_dma_mem_alloc
267 #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
268 #endif
270 static inline void fallback_on_nodma_alloc(char **addr, size_t l)
271 {
272 #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
273 if (*addr)
274 return; /* we have the memory */
275 if (can_use_virtual_dma != 2)
276 return; /* no fallback allowed */
277 printk
278 ("DMA memory shortage. Temporarily falling back on virtual DMA\n");
279 *addr = (char *)nodma_mem_alloc(l);
280 #else
281 return;
282 #endif
283 }
285 /* End dma memory related stuff */
287 static unsigned long fake_change;
288 static int initialising = 1;
290 #define ITYPE(x) (((x)>>2) & 0x1f)
291 #define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
292 #define UNIT(x) ((x) & 0x03) /* drive on fdc */
293 #define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
294 #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
295 /* reverse mapping from unit and fdc to drive */
296 #define DP (&drive_params[current_drive])
297 #define DRS (&drive_state[current_drive])
298 #define DRWE (&write_errors[current_drive])
299 #define FDCS (&fdc_state[fdc])
300 #define CLEARF(x) (clear_bit(x##_BIT, &DRS->flags))
301 #define SETF(x) (set_bit(x##_BIT, &DRS->flags))
302 #define TESTF(x) (test_bit(x##_BIT, &DRS->flags))
304 #define UDP (&drive_params[drive])
305 #define UDRS (&drive_state[drive])
306 #define UDRWE (&write_errors[drive])
307 #define UFDCS (&fdc_state[FDC(drive)])
308 #define UCLEARF(x) (clear_bit(x##_BIT, &UDRS->flags))
309 #define USETF(x) (set_bit(x##_BIT, &UDRS->flags))
310 #define UTESTF(x) (test_bit(x##_BIT, &UDRS->flags))
312 #define DPRINT(format, args...) printk(DEVICE_NAME "%d: " format, current_drive , ## args)
314 #define PH_HEAD(floppy,head) (((((floppy)->stretch & 2) >>1) ^ head) << 2)
315 #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
317 #define CLEARSTRUCT(x) memset((x), 0, sizeof(*(x)))
319 /* read/write */
320 #define COMMAND raw_cmd->cmd[0]
321 #define DR_SELECT raw_cmd->cmd[1]
322 #define TRACK raw_cmd->cmd[2]
323 #define HEAD raw_cmd->cmd[3]
324 #define SECTOR raw_cmd->cmd[4]
325 #define SIZECODE raw_cmd->cmd[5]
326 #define SECT_PER_TRACK raw_cmd->cmd[6]
327 #define GAP raw_cmd->cmd[7]
328 #define SIZECODE2 raw_cmd->cmd[8]
329 #define NR_RW 9
331 /* format */
332 #define F_SIZECODE raw_cmd->cmd[2]
333 #define F_SECT_PER_TRACK raw_cmd->cmd[3]
334 #define F_GAP raw_cmd->cmd[4]
335 #define F_FILL raw_cmd->cmd[5]
336 #define NR_F 6
338 /*
339 * Maximum disk size (in kilobytes). This default is used whenever the
340 * current disk size is unknown.
341 * [Now it is rather a minimum]
342 */
343 #define MAX_DISK_SIZE 4 /* 3984 */
345 /*
346 * globals used by 'result()'
347 */
348 #define MAX_REPLIES 16
349 static unsigned char reply_buffer[MAX_REPLIES];
350 static int inr; /* size of reply buffer, when called from interrupt */
351 #define ST0 (reply_buffer[0])
352 #define ST1 (reply_buffer[1])
353 #define ST2 (reply_buffer[2])
354 #define ST3 (reply_buffer[0]) /* result of GETSTATUS */
355 #define R_TRACK (reply_buffer[3])
356 #define R_HEAD (reply_buffer[4])
357 #define R_SECTOR (reply_buffer[5])
358 #define R_SIZECODE (reply_buffer[6])
360 #define SEL_DLY (2*HZ/100)
362 /*
363 * this struct defines the different floppy drive types.
364 */
365 static struct {
366 struct floppy_drive_params params;
367 const char *name; /* name printed while booting */
368 } default_drive_params[] = {
369 /* NOTE: the time values in jiffies should be in msec!
370 CMOS drive type
371 | Maximum data rate supported by drive type
372 | | Head load time, msec
373 | | | Head unload time, msec (not used)
374 | | | | Step rate interval, usec
375 | | | | | Time needed for spinup time (jiffies)
376 | | | | | | Timeout for spinning down (jiffies)
377 | | | | | | | Spindown offset (where disk stops)
378 | | | | | | | | Select delay
379 | | | | | | | | | RPS
380 | | | | | | | | | | Max number of tracks
381 | | | | | | | | | | | Interrupt timeout
382 | | | | | | | | | | | | Max nonintlv. sectors
383 | | | | | | | | | | | | | -Max Errors- flags */
384 {{0, 500, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 80, 3*HZ, 20, {3,1,2,0,2}, 0,
385 0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
387 {{1, 300, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 40, 3*HZ, 17, {3,1,2,0,2}, 0,
388 0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
390 {{2, 500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6, 83, 3*HZ, 17, {3,1,2,0,2}, 0,
391 0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
393 {{3, 250, 16, 16, 3000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
394 0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
396 {{4, 500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
397 0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
399 {{5, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
400 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
402 {{6, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
403 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
404 /* | --autodetected formats--- | | |
405 * read_track | | Name printed when booting
406 * | Native format
407 * Frequency of disk change checks */
408 };
410 static struct floppy_drive_params drive_params[N_DRIVE];
411 static struct floppy_drive_struct drive_state[N_DRIVE];
412 static struct floppy_write_errors write_errors[N_DRIVE];
413 static struct timer_list motor_off_timer[N_DRIVE];
414 static struct gendisk *disks[N_DRIVE];
415 static struct block_device *opened_bdev[N_DRIVE];
416 static DEFINE_MUTEX(open_lock);
417 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
419 /*
420 * This struct defines the different floppy types.
421 *
422 * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
423 * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
424 * tells if the disk is in Commodore 1581 format, which means side 0 sectors
425 * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
426 * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
427 * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
428 * side 0 is on physical side 0 (but with the misnamed sector IDs).
429 * 'stretch' should probably be renamed to something more general, like
430 * 'options'. Other parameters should be self-explanatory (see also
431 * setfdprm(8)).
432 */
433 /*
434 Size
435 | Sectors per track
436 | | Head
437 | | | Tracks
438 | | | | Stretch
439 | | | | | Gap 1 size
440 | | | | | | Data rate, | 0x40 for perp
441 | | | | | | | Spec1 (stepping rate, head unload
442 | | | | | | | | /fmt gap (gap2) */
443 static struct floppy_struct floppy_type[32] = {
444 { 0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL }, /* 0 no testing */
445 { 720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360" }, /* 1 360KB PC */
446 { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /* 2 1.2MB AT */
447 { 720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360" }, /* 3 360KB SS 3.5" */
448 { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720" }, /* 4 720KB 3.5" */
449 { 720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360" }, /* 5 360KB AT */
450 { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720" }, /* 6 720KB AT */
451 { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /* 7 1.44MB 3.5" */
452 { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /* 8 2.88MB 3.5" */
453 { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /* 9 3.12MB 3.5" */
455 { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25" */
456 { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5" */
457 { 820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410" }, /* 12 410KB 5.25" */
458 { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820" }, /* 13 820KB 3.5" */
459 { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25" */
460 { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5" */
461 { 840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420" }, /* 16 420KB 5.25" */
462 { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830" }, /* 17 830KB 3.5" */
463 { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25" */
464 { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5" */
466 { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880" }, /* 20 880KB 5.25" */
467 { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5" */
468 { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5" */
469 { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25" */
470 { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5" */
471 { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5" */
472 { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5" */
473 { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5" */
474 { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5" */
476 { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5" */
477 { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800" }, /* 30 800KB 3.5" */
478 { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5" */
479 };
481 #define SECTSIZE (_FD_SECTSIZE(*floppy))
483 /* Auto-detection: Disk type used until the next media change occurs. */
484 static struct floppy_struct *current_type[N_DRIVE];
486 /*
487 * User-provided type information. current_type points to
488 * the respective entry of this array.
489 */
490 static struct floppy_struct user_params[N_DRIVE];
492 static sector_t floppy_sizes[256];
494 static char floppy_device_name[] = "floppy";
496 /*
497 * The driver is trying to determine the correct media format
498 * while probing is set. rw_interrupt() clears it after a
499 * successful access.
500 */
501 static int probing;
503 /* Synchronization of FDC access. */
504 #define FD_COMMAND_NONE -1
505 #define FD_COMMAND_ERROR 2
506 #define FD_COMMAND_OKAY 3
508 static volatile int command_status = FD_COMMAND_NONE;
509 static unsigned long fdc_busy;
510 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
511 static DECLARE_WAIT_QUEUE_HEAD(command_done);
513 #define NO_SIGNAL (!interruptible || !signal_pending(current))
514 #define CALL(x) if ((x) == -EINTR) return -EINTR
515 #define ECALL(x) if ((ret = (x))) return ret;
516 #define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
517 #define WAIT(x) _WAIT((x),interruptible)
518 #define IWAIT(x) _WAIT((x),1)
520 /* Errors during formatting are counted here. */
521 static int format_errors;
523 /* Format request descriptor. */
524 static struct format_descr format_req;
526 /*
527 * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
528 * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
529 * H is head unload time (1=16ms, 2=32ms, etc)
530 */
532 /*
533 * Track buffer
534 * Because these are written to by the DMA controller, they must
535 * not contain a 64k byte boundary crossing, or data will be
536 * corrupted/lost.
537 */
538 static char *floppy_track_buffer;
539 static int max_buffer_sectors;
541 static int *errors;
542 typedef void (*done_f) (int);
543 static struct cont_t {
544 void (*interrupt) (void); /* this is called after the interrupt of the
545 * main command */
546 void (*redo) (void); /* this is called to retry the operation */
547 void (*error) (void); /* this is called to tally an error */
548 done_f done; /* this is called to say if the operation has
549 * succeeded/failed */
550 } *cont;
552 static void floppy_ready(void);
553 static void floppy_start(void);
554 static void process_fd_request(void);
555 static void recalibrate_floppy(void);
556 static void floppy_shutdown(unsigned long);
558 static int floppy_grab_irq_and_dma(void);
559 static void floppy_release_irq_and_dma(void);
561 /*
562 * The "reset" variable should be tested whenever an interrupt is scheduled,
563 * after the commands have been sent. This is to ensure that the driver doesn't
564 * get wedged when the interrupt doesn't come because of a failed command.
565 * reset doesn't need to be tested before sending commands, because
566 * output_byte is automatically disabled when reset is set.
567 */
568 #define CHECK_RESET { if (FDCS->reset){ reset_fdc(); return; } }
569 static void reset_fdc(void);
571 /*
572 * These are global variables, as that's the easiest way to give
573 * information to interrupts. They are the data used for the current
574 * request.
575 */
576 #define NO_TRACK -1
577 #define NEED_1_RECAL -2
578 #define NEED_2_RECAL -3
580 static int usage_count;
582 /* buffer related variables */
583 static int buffer_track = -1;
584 static int buffer_drive = -1;
585 static int buffer_min = -1;
586 static int buffer_max = -1;
588 /* fdc related variables, should end up in a struct */
589 static struct floppy_fdc_state fdc_state[N_FDC];
590 static int fdc; /* current fdc */
592 static struct floppy_struct *_floppy = floppy_type;
593 static unsigned char current_drive;
594 static long current_count_sectors;
595 static unsigned char fsector_t; /* sector in track */
596 static unsigned char in_sector_offset; /* offset within physical sector,
597 * expressed in units of 512 bytes */
599 #ifndef fd_eject
600 static inline int fd_eject(int drive)
601 {
602 return -EINVAL;
603 }
604 #endif
606 /*
607 * Debugging
608 * =========
609 */
610 #ifdef DEBUGT
611 static long unsigned debugtimer;
613 static inline void set_debugt(void)
614 {
615 debugtimer = jiffies;
616 }
618 static inline void debugt(const char *message)
619 {
620 if (DP->flags & DEBUGT)
621 printk("%s dtime=%lu\n", message, jiffies - debugtimer);
622 }
623 #else
624 static inline void set_debugt(void) { }
625 static inline void debugt(const char *message) { }
626 #endif /* DEBUGT */
628 typedef void (*timeout_fn) (unsigned long);
629 static DEFINE_TIMER(fd_timeout, floppy_shutdown, 0, 0);
631 static const char *timeout_message;
633 #ifdef FLOPPY_SANITY_CHECK
634 static void is_alive(const char *message)
635 {
636 /* this routine checks whether the floppy driver is "alive" */
637 if (test_bit(0, &fdc_busy) && command_status < 2
638 && !timer_pending(&fd_timeout)) {
639 DPRINT("timeout handler died: %s\n", message);
640 }
641 }
642 #endif
644 static void (*do_floppy) (void) = NULL;
646 #ifdef FLOPPY_SANITY_CHECK
648 #define OLOGSIZE 20
650 static void (*lasthandler) (void);
651 static unsigned long interruptjiffies;
652 static unsigned long resultjiffies;
653 static int resultsize;
654 static unsigned long lastredo;
656 static struct output_log {
657 unsigned char data;
658 unsigned char status;
659 unsigned long jiffies;
660 } output_log[OLOGSIZE];
662 static int output_log_pos;
663 #endif
665 #define current_reqD -1
666 #define MAXTIMEOUT -2
668 static void __reschedule_timeout(int drive, const char *message, int marg)
669 {
670 if (drive == current_reqD)
671 drive = current_drive;
672 del_timer(&fd_timeout);
673 if (drive < 0 || drive > N_DRIVE) {
674 fd_timeout.expires = jiffies + 20UL * HZ;
675 drive = 0;
676 } else
677 fd_timeout.expires = jiffies + UDP->timeout;
678 add_timer(&fd_timeout);
679 if (UDP->flags & FD_DEBUG) {
680 DPRINT("reschedule timeout ");
681 printk(message, marg);
682 printk("\n");
683 }
684 timeout_message = message;
685 }
687 static void reschedule_timeout(int drive, const char *message, int marg)
688 {
689 unsigned long flags;
691 spin_lock_irqsave(&floppy_lock, flags);
692 __reschedule_timeout(drive, message, marg);
693 spin_unlock_irqrestore(&floppy_lock, flags);
694 }
696 #define INFBOUND(a,b) (a)=max_t(int, a, b)
698 #define SUPBOUND(a,b) (a)=min_t(int, a, b)
700 /*
701 * Bottom half floppy driver.
702 * ==========================
703 *
704 * This part of the file contains the code talking directly to the hardware,
705 * and also the main service loop (seek-configure-spinup-command)
706 */
708 /*
709 * disk change.
710 * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
711 * and the last_checked date.
712 *
713 * last_checked is the date of the last check which showed 'no disk change'
714 * FD_DISK_CHANGE is set under two conditions:
715 * 1. The floppy has been changed after some i/o to that floppy already
716 * took place.
717 * 2. No floppy disk is in the drive. This is done in order to ensure that
718 * requests are quickly flushed in case there is no disk in the drive. It
719 * follows that FD_DISK_CHANGE can only be cleared if there is a disk in
720 * the drive.
721 *
722 * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
723 * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
724 * each seek. If a disk is present, the disk change line should also be
725 * cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
726 * change line is set, this means either that no disk is in the drive, or
727 * that it has been removed since the last seek.
728 *
729 * This means that we really have a third possibility too:
730 * The floppy has been changed after the last seek.
731 */
733 static int disk_change(int drive)
734 {
735 int fdc = FDC(drive);
736 #ifdef FLOPPY_SANITY_CHECK
737 if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
738 DPRINT("WARNING disk change called early\n");
739 if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
740 (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
741 DPRINT("probing disk change on unselected drive\n");
742 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
743 (unsigned int)FDCS->dor);
744 }
745 #endif
747 #ifdef DCL_DEBUG
748 if (UDP->flags & FD_DEBUG) {
749 DPRINT("checking disk change line for drive %d\n", drive);
750 DPRINT("jiffies=%lu\n", jiffies);
751 DPRINT("disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
752 DPRINT("flags=%lx\n", UDRS->flags);
753 }
754 #endif
755 if (UDP->flags & FD_BROKEN_DCL)
756 return UTESTF(FD_DISK_CHANGED);
757 if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
758 USETF(FD_VERIFY); /* verify write protection */
759 if (UDRS->maxblock) {
760 /* mark it changed */
761 USETF(FD_DISK_CHANGED);
762 }
764 /* invalidate its geometry */
765 if (UDRS->keep_data >= 0) {
766 if ((UDP->flags & FTD_MSG) &&
767 current_type[drive] != NULL)
768 DPRINT("Disk type is undefined after "
769 "disk change\n");
770 current_type[drive] = NULL;
771 floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
772 }
774 /*USETF(FD_DISK_NEWCHANGE); */
775 return 1;
776 } else {
777 UDRS->last_checked = jiffies;
778 UCLEARF(FD_DISK_NEWCHANGE);
779 }
780 return 0;
781 }
783 static inline int is_selected(int dor, int unit)
784 {
785 return ((dor & (0x10 << unit)) && (dor & 3) == unit);
786 }
788 static int set_dor(int fdc, char mask, char data)
789 {
790 register unsigned char drive, unit, newdor, olddor;
792 if (FDCS->address == -1)
793 return -1;
795 olddor = FDCS->dor;
796 newdor = (olddor & mask) | data;
797 if (newdor != olddor) {
798 unit = olddor & 0x3;
799 if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
800 drive = REVDRIVE(fdc, unit);
801 #ifdef DCL_DEBUG
802 if (UDP->flags & FD_DEBUG) {
803 DPRINT("calling disk change from set_dor\n");
804 }
805 #endif
806 disk_change(drive);
807 }
808 FDCS->dor = newdor;
809 fd_outb(newdor, FD_DOR);
811 unit = newdor & 0x3;
812 if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
813 drive = REVDRIVE(fdc, unit);
814 UDRS->select_date = jiffies;
815 }
816 }
817 return olddor;
818 }
820 static void twaddle(void)
821 {
822 if (DP->select_delay)
823 return;
824 fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
825 fd_outb(FDCS->dor, FD_DOR);
826 DRS->select_date = jiffies;
827 }
829 /* reset all driver information about the current fdc. This is needed after
830 * a reset, and after a raw command. */
831 static void reset_fdc_info(int mode)
832 {
833 int drive;
835 FDCS->spec1 = FDCS->spec2 = -1;
836 FDCS->need_configure = 1;
837 FDCS->perp_mode = 1;
838 FDCS->rawcmd = 0;
839 for (drive = 0; drive < N_DRIVE; drive++)
840 if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
841 UDRS->track = NEED_2_RECAL;
842 }
844 /* selects the fdc and drive, and enables the fdc's input/dma. */
845 static void set_fdc(int drive)
846 {
847 if (drive >= 0 && drive < N_DRIVE) {
848 fdc = FDC(drive);
849 current_drive = drive;
850 }
851 if (fdc != 1 && fdc != 0) {
852 printk("bad fdc value\n");
853 return;
854 }
855 set_dor(fdc, ~0, 8);
856 #if N_FDC > 1
857 set_dor(1 - fdc, ~8, 0);
858 #endif
859 if (FDCS->rawcmd == 2)
860 reset_fdc_info(1);
861 if (fd_inb(FD_STATUS) != STATUS_READY)
862 FDCS->reset = 1;
863 }
865 /* locks the driver */
866 static int _lock_fdc(int drive, int interruptible, int line)
867 {
868 if (!usage_count) {
869 printk(KERN_ERR
870 "Trying to lock fdc while usage count=0 at line %d\n",
871 line);
872 return -1;
873 }
875 if (test_and_set_bit(0, &fdc_busy)) {
876 DECLARE_WAITQUEUE(wait, current);
877 add_wait_queue(&fdc_wait, &wait);
879 for (;;) {
880 set_current_state(TASK_INTERRUPTIBLE);
882 if (!test_and_set_bit(0, &fdc_busy))
883 break;
885 schedule();
887 if (!NO_SIGNAL) {
888 remove_wait_queue(&fdc_wait, &wait);
889 return -EINTR;
890 }
891 }
893 set_current_state(TASK_RUNNING);
894 remove_wait_queue(&fdc_wait, &wait);
896 flush_scheduled_work();
897 }
898 command_status = FD_COMMAND_NONE;
900 __reschedule_timeout(drive, "lock fdc", 0);
901 set_fdc(drive);
902 return 0;
903 }
905 #define lock_fdc(drive,interruptible) _lock_fdc(drive,interruptible, __LINE__)
907 #define LOCK_FDC(drive,interruptible) \
908 if (lock_fdc(drive,interruptible)) return -EINTR;
910 /* unlocks the driver */
911 static inline void unlock_fdc(void)
912 {
913 unsigned long flags;
915 raw_cmd = NULL;
916 if (!test_bit(0, &fdc_busy))
917 DPRINT("FDC access conflict!\n");
919 if (do_floppy)
920 DPRINT("device interrupt still active at FDC release: %p!\n",
921 do_floppy);
922 command_status = FD_COMMAND_NONE;
923 spin_lock_irqsave(&floppy_lock, flags);
924 del_timer(&fd_timeout);
925 cont = NULL;
926 clear_bit(0, &fdc_busy);
927 if (elv_next_request(floppy_queue))
928 do_fd_request(floppy_queue);
929 spin_unlock_irqrestore(&floppy_lock, flags);
930 wake_up(&fdc_wait);
931 }
933 /* switches the motor off after a given timeout */
934 static void motor_off_callback(unsigned long nr)
935 {
936 unsigned char mask = ~(0x10 << UNIT(nr));
938 set_dor(FDC(nr), mask, 0);
939 }
941 /* schedules motor off */
942 static void floppy_off(unsigned int drive)
943 {
944 unsigned long volatile delta;
945 register int fdc = FDC(drive);
947 if (!(FDCS->dor & (0x10 << UNIT(drive))))
948 return;
950 del_timer(motor_off_timer + drive);
952 /* make spindle stop in a position which minimizes spinup time
953 * next time */
954 if (UDP->rps) {
955 delta = jiffies - UDRS->first_read_date + HZ -
956 UDP->spindown_offset;
957 delta = ((delta * UDP->rps) % HZ) / UDP->rps;
958 motor_off_timer[drive].expires =
959 jiffies + UDP->spindown - delta;
960 }
961 add_timer(motor_off_timer + drive);
962 }
964 /*
965 * cycle through all N_DRIVE floppy drives, for disk change testing.
966 * stopping at current drive. This is done before any long operation, to
967 * be sure to have up to date disk change information.
968 */
969 static void scandrives(void)
970 {
971 int i, drive, saved_drive;
973 if (DP->select_delay)
974 return;
976 saved_drive = current_drive;
977 for (i = 0; i < N_DRIVE; i++) {
978 drive = (saved_drive + i + 1) % N_DRIVE;
979 if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
980 continue; /* skip closed drives */
981 set_fdc(drive);
982 if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
983 (0x10 << UNIT(drive))))
984 /* switch the motor off again, if it was off to
985 * begin with */
986 set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
987 }
988 set_fdc(saved_drive);
989 }
991 static void empty(void)
992 {
993 }
995 static DECLARE_WORK(floppy_work, NULL, NULL);
997 static void schedule_bh(void (*handler) (void))
998 {
999 PREPARE_WORK(&floppy_work, (void (*)(void *))handler, NULL);
1000 schedule_work(&floppy_work);
1003 static DEFINE_TIMER(fd_timer, NULL, 0, 0);
1005 static void cancel_activity(void)
1007 unsigned long flags;
1009 spin_lock_irqsave(&floppy_lock, flags);
1010 do_floppy = NULL;
1011 PREPARE_WORK(&floppy_work, (void *)empty, NULL);
1012 del_timer(&fd_timer);
1013 spin_unlock_irqrestore(&floppy_lock, flags);
1016 /* this function makes sure that the disk stays in the drive during the
1017 * transfer */
1018 static void fd_watchdog(void)
1020 #ifdef DCL_DEBUG
1021 if (DP->flags & FD_DEBUG) {
1022 DPRINT("calling disk change from watchdog\n");
1024 #endif
1026 if (disk_change(current_drive)) {
1027 DPRINT("disk removed during i/o\n");
1028 cancel_activity();
1029 cont->done(0);
1030 reset_fdc();
1031 } else {
1032 del_timer(&fd_timer);
1033 fd_timer.function = (timeout_fn) fd_watchdog;
1034 fd_timer.expires = jiffies + HZ / 10;
1035 add_timer(&fd_timer);
1039 static void main_command_interrupt(void)
1041 del_timer(&fd_timer);
1042 cont->interrupt();
1045 /* waits for a delay (spinup or select) to pass */
1046 static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
1048 if (FDCS->reset) {
1049 reset_fdc(); /* do the reset during sleep to win time
1050 * if we don't need to sleep, it's a good
1051 * occasion anyways */
1052 return 1;
1055 if (time_before(jiffies, delay)) {
1056 del_timer(&fd_timer);
1057 fd_timer.function = function;
1058 fd_timer.expires = delay;
1059 add_timer(&fd_timer);
1060 return 1;
1062 return 0;
1065 static DEFINE_SPINLOCK(floppy_hlt_lock);
1066 static int hlt_disabled;
1067 static void floppy_disable_hlt(void)
1069 unsigned long flags;
1071 spin_lock_irqsave(&floppy_hlt_lock, flags);
1072 if (!hlt_disabled) {
1073 hlt_disabled = 1;
1074 #ifdef HAVE_DISABLE_HLT
1075 disable_hlt();
1076 #endif
1078 spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1081 static void floppy_enable_hlt(void)
1083 unsigned long flags;
1085 spin_lock_irqsave(&floppy_hlt_lock, flags);
1086 if (hlt_disabled) {
1087 hlt_disabled = 0;
1088 #ifdef HAVE_DISABLE_HLT
1089 enable_hlt();
1090 #endif
1092 spin_unlock_irqrestore(&floppy_hlt_lock, flags);
1095 static void setup_DMA(void)
1097 unsigned long f;
1099 #ifdef FLOPPY_SANITY_CHECK
1100 if (raw_cmd->length == 0) {
1101 int i;
1103 printk("zero dma transfer size:");
1104 for (i = 0; i < raw_cmd->cmd_count; i++)
1105 printk("%x,", raw_cmd->cmd[i]);
1106 printk("\n");
1107 cont->done(0);
1108 FDCS->reset = 1;
1109 return;
1111 if (((unsigned long)raw_cmd->kernel_data) % 512) {
1112 printk("non aligned address: %p\n", raw_cmd->kernel_data);
1113 cont->done(0);
1114 FDCS->reset = 1;
1115 return;
1117 #endif
1118 f = claim_dma_lock();
1119 fd_disable_dma();
1120 #ifdef fd_dma_setup
1121 if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1122 (raw_cmd->flags & FD_RAW_READ) ?
1123 DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
1124 release_dma_lock(f);
1125 cont->done(0);
1126 FDCS->reset = 1;
1127 return;
1129 release_dma_lock(f);
1130 #else
1131 fd_clear_dma_ff();
1132 fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1133 fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
1134 DMA_MODE_READ : DMA_MODE_WRITE);
1135 fd_set_dma_addr(raw_cmd->kernel_data);
1136 fd_set_dma_count(raw_cmd->length);
1137 virtual_dma_port = FDCS->address;
1138 fd_enable_dma();
1139 release_dma_lock(f);
1140 #endif
1141 floppy_disable_hlt();
1144 static void show_floppy(void);
1146 /* waits until the fdc becomes ready */
1147 static int wait_til_ready(void)
1149 int counter, status;
1150 if (FDCS->reset)
1151 return -1;
1152 for (counter = 0; counter < 10000; counter++) {
1153 status = fd_inb(FD_STATUS);
1154 if (status & STATUS_READY)
1155 return status;
1157 if (!initialising) {
1158 DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
1159 show_floppy();
1161 FDCS->reset = 1;
1162 return -1;
1165 /* sends a command byte to the fdc */
1166 static int output_byte(char byte)
1168 int status;
1170 if ((status = wait_til_ready()) < 0)
1171 return -1;
1172 if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY) {
1173 fd_outb(byte, FD_DATA);
1174 #ifdef FLOPPY_SANITY_CHECK
1175 output_log[output_log_pos].data = byte;
1176 output_log[output_log_pos].status = status;
1177 output_log[output_log_pos].jiffies = jiffies;
1178 output_log_pos = (output_log_pos + 1) % OLOGSIZE;
1179 #endif
1180 return 0;
1182 FDCS->reset = 1;
1183 if (!initialising) {
1184 DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
1185 byte, fdc, status);
1186 show_floppy();
1188 return -1;
1191 #define LAST_OUT(x) if (output_byte(x)<0){ reset_fdc();return;}
1193 /* gets the response from the fdc */
1194 static int result(void)
1196 int i, status = 0;
1198 for (i = 0; i < MAX_REPLIES; i++) {
1199 if ((status = wait_til_ready()) < 0)
1200 break;
1201 status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
1202 if ((status & ~STATUS_BUSY) == STATUS_READY) {
1203 #ifdef FLOPPY_SANITY_CHECK
1204 resultjiffies = jiffies;
1205 resultsize = i;
1206 #endif
1207 return i;
1209 if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
1210 reply_buffer[i] = fd_inb(FD_DATA);
1211 else
1212 break;
1214 if (!initialising) {
1215 DPRINT
1216 ("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
1217 fdc, status, i);
1218 show_floppy();
1220 FDCS->reset = 1;
1221 return -1;
1224 #define MORE_OUTPUT -2
1225 /* does the fdc need more output? */
1226 static int need_more_output(void)
1228 int status;
1229 if ((status = wait_til_ready()) < 0)
1230 return -1;
1231 if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY)
1232 return MORE_OUTPUT;
1233 return result();
1236 /* Set perpendicular mode as required, based on data rate, if supported.
1237 * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
1238 */
1239 static inline void perpendicular_mode(void)
1241 unsigned char perp_mode;
1243 if (raw_cmd->rate & 0x40) {
1244 switch (raw_cmd->rate & 3) {
1245 case 0:
1246 perp_mode = 2;
1247 break;
1248 case 3:
1249 perp_mode = 3;
1250 break;
1251 default:
1252 DPRINT("Invalid data rate for perpendicular mode!\n");
1253 cont->done(0);
1254 FDCS->reset = 1; /* convenient way to return to
1255 * redo without to much hassle (deep
1256 * stack et al. */
1257 return;
1259 } else
1260 perp_mode = 0;
1262 if (FDCS->perp_mode == perp_mode)
1263 return;
1264 if (FDCS->version >= FDC_82077_ORIG) {
1265 output_byte(FD_PERPENDICULAR);
1266 output_byte(perp_mode);
1267 FDCS->perp_mode = perp_mode;
1268 } else if (perp_mode) {
1269 DPRINT("perpendicular mode not supported by this FDC.\n");
1271 } /* perpendicular_mode */
1273 static int fifo_depth = 0xa;
1274 static int no_fifo;
1276 static int fdc_configure(void)
1278 /* Turn on FIFO */
1279 output_byte(FD_CONFIGURE);
1280 if (need_more_output() != MORE_OUTPUT)
1281 return 0;
1282 output_byte(0);
1283 output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1284 output_byte(0); /* pre-compensation from track
1285 0 upwards */
1286 return 1;
1289 #define NOMINAL_DTR 500
1291 /* Issue a "SPECIFY" command to set the step rate time, head unload time,
1292 * head load time, and DMA disable flag to values needed by floppy.
1294 * The value "dtr" is the data transfer rate in Kbps. It is needed
1295 * to account for the data rate-based scaling done by the 82072 and 82077
1296 * FDC types. This parameter is ignored for other types of FDCs (i.e.
1297 * 8272a).
1299 * Note that changing the data transfer rate has a (probably deleterious)
1300 * effect on the parameters subject to scaling for 82072/82077 FDCs, so
1301 * fdc_specify is called again after each data transfer rate
1302 * change.
1304 * srt: 1000 to 16000 in microseconds
1305 * hut: 16 to 240 milliseconds
1306 * hlt: 2 to 254 milliseconds
1308 * These values are rounded up to the next highest available delay time.
1309 */
1310 static void fdc_specify(void)
1312 unsigned char spec1, spec2;
1313 unsigned long srt, hlt, hut;
1314 unsigned long dtr = NOMINAL_DTR;
1315 unsigned long scale_dtr = NOMINAL_DTR;
1316 int hlt_max_code = 0x7f;
1317 int hut_max_code = 0xf;
1319 if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
1320 fdc_configure();
1321 FDCS->need_configure = 0;
1322 /*DPRINT("FIFO enabled\n"); */
1325 switch (raw_cmd->rate & 0x03) {
1326 case 3:
1327 dtr = 1000;
1328 break;
1329 case 1:
1330 dtr = 300;
1331 if (FDCS->version >= FDC_82078) {
1332 /* chose the default rate table, not the one
1333 * where 1 = 2 Mbps */
1334 output_byte(FD_DRIVESPEC);
1335 if (need_more_output() == MORE_OUTPUT) {
1336 output_byte(UNIT(current_drive));
1337 output_byte(0xc0);
1340 break;
1341 case 2:
1342 dtr = 250;
1343 break;
1346 if (FDCS->version >= FDC_82072) {
1347 scale_dtr = dtr;
1348 hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
1349 hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
1352 /* Convert step rate from microseconds to milliseconds and 4 bits */
1353 srt = 16 - (DP->srt * scale_dtr / 1000 + NOMINAL_DTR - 1) / NOMINAL_DTR;
1354 if (slow_floppy) {
1355 srt = srt / 4;
1357 SUPBOUND(srt, 0xf);
1358 INFBOUND(srt, 0);
1360 hlt = (DP->hlt * scale_dtr / 2 + NOMINAL_DTR - 1) / NOMINAL_DTR;
1361 if (hlt < 0x01)
1362 hlt = 0x01;
1363 else if (hlt > 0x7f)
1364 hlt = hlt_max_code;
1366 hut = (DP->hut * scale_dtr / 16 + NOMINAL_DTR - 1) / NOMINAL_DTR;
1367 if (hut < 0x1)
1368 hut = 0x1;
1369 else if (hut > 0xf)
1370 hut = hut_max_code;
1372 spec1 = (srt << 4) | hut;
1373 spec2 = (hlt << 1) | (use_virtual_dma & 1);
1375 /* If these parameters did not change, just return with success */
1376 if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
1377 /* Go ahead and set spec1 and spec2 */
1378 output_byte(FD_SPECIFY);
1379 output_byte(FDCS->spec1 = spec1);
1380 output_byte(FDCS->spec2 = spec2);
1382 } /* fdc_specify */
1384 /* Set the FDC's data transfer rate on behalf of the specified drive.
1385 * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
1386 * of the specify command (i.e. using the fdc_specify function).
1387 */
1388 static int fdc_dtr(void)
1390 /* If data rate not already set to desired value, set it. */
1391 if ((raw_cmd->rate & 3) == FDCS->dtr)
1392 return 0;
1394 /* Set dtr */
1395 fd_outb(raw_cmd->rate & 3, FD_DCR);
1397 /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1398 * need a stabilization period of several milliseconds to be
1399 * enforced after data rate changes before R/W operations.
1400 * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
1401 */
1402 FDCS->dtr = raw_cmd->rate & 3;
1403 return (fd_wait_for_completion(jiffies + 2UL * HZ / 100,
1404 (timeout_fn) floppy_ready));
1405 } /* fdc_dtr */
1407 static void tell_sector(void)
1409 printk(": track %d, head %d, sector %d, size %d",
1410 R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
1411 } /* tell_sector */
1413 /*
1414 * OK, this error interpreting routine is called after a
1415 * DMA read/write has succeeded
1416 * or failed, so we check the results, and copy any buffers.
1417 * hhb: Added better error reporting.
1418 * ak: Made this into a separate routine.
1419 */
1420 static int interpret_errors(void)
1422 char bad;
1424 if (inr != 7) {
1425 DPRINT("-- FDC reply error");
1426 FDCS->reset = 1;
1427 return 1;
1430 /* check IC to find cause of interrupt */
1431 switch (ST0 & ST0_INTR) {
1432 case 0x40: /* error occurred during command execution */
1433 if (ST1 & ST1_EOC)
1434 return 0; /* occurs with pseudo-DMA */
1435 bad = 1;
1436 if (ST1 & ST1_WP) {
1437 DPRINT("Drive is write protected\n");
1438 CLEARF(FD_DISK_WRITABLE);
1439 cont->done(0);
1440 bad = 2;
1441 } else if (ST1 & ST1_ND) {
1442 SETF(FD_NEED_TWADDLE);
1443 } else if (ST1 & ST1_OR) {
1444 if (DP->flags & FTD_MSG)
1445 DPRINT("Over/Underrun - retrying\n");
1446 bad = 0;
1447 } else if (*errors >= DP->max_errors.reporting) {
1448 DPRINT("");
1449 if (ST0 & ST0_ECE) {
1450 printk("Recalibrate failed!");
1451 } else if (ST2 & ST2_CRC) {
1452 printk("data CRC error");
1453 tell_sector();
1454 } else if (ST1 & ST1_CRC) {
1455 printk("CRC error");
1456 tell_sector();
1457 } else if ((ST1 & (ST1_MAM | ST1_ND))
1458 || (ST2 & ST2_MAM)) {
1459 if (!probing) {
1460 printk("sector not found");
1461 tell_sector();
1462 } else
1463 printk("probe failed...");
1464 } else if (ST2 & ST2_WC) { /* seek error */
1465 printk("wrong cylinder");
1466 } else if (ST2 & ST2_BC) { /* cylinder marked as bad */
1467 printk("bad cylinder");
1468 } else {
1469 printk
1470 ("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
1471 ST0, ST1, ST2);
1472 tell_sector();
1474 printk("\n");
1477 if (ST2 & ST2_WC || ST2 & ST2_BC)
1478 /* wrong cylinder => recal */
1479 DRS->track = NEED_2_RECAL;
1480 return bad;
1481 case 0x80: /* invalid command given */
1482 DPRINT("Invalid FDC command given!\n");
1483 cont->done(0);
1484 return 2;
1485 case 0xc0:
1486 DPRINT("Abnormal termination caused by polling\n");
1487 cont->error();
1488 return 2;
1489 default: /* (0) Normal command termination */
1490 return 0;
1494 /*
1495 * This routine is called when everything should be correctly set up
1496 * for the transfer (i.e. floppy motor is on, the correct floppy is
1497 * selected, and the head is sitting on the right track).
1498 */
1499 static void setup_rw_floppy(void)
1501 int i, r, flags, dflags;
1502 unsigned long ready_date;
1503 timeout_fn function;
1505 flags = raw_cmd->flags;
1506 if (flags & (FD_RAW_READ | FD_RAW_WRITE))
1507 flags |= FD_RAW_INTR;
1509 if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
1510 ready_date = DRS->spinup_date + DP->spinup;
1511 /* If spinup will take a long time, rerun scandrives
1512 * again just before spinup completion. Beware that
1513 * after scandrives, we must again wait for selection.
1514 */
1515 if (time_after(ready_date, jiffies + DP->select_delay)) {
1516 ready_date -= DP->select_delay;
1517 function = (timeout_fn) floppy_start;
1518 } else
1519 function = (timeout_fn) setup_rw_floppy;
1521 /* wait until the floppy is spinning fast enough */
1522 if (fd_wait_for_completion(ready_date, function))
1523 return;
1525 dflags = DRS->flags;
1527 if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
1528 setup_DMA();
1530 if (flags & FD_RAW_INTR)
1531 do_floppy = main_command_interrupt;
1533 r = 0;
1534 for (i = 0; i < raw_cmd->cmd_count; i++)
1535 r |= output_byte(raw_cmd->cmd[i]);
1537 debugt("rw_command: ");
1539 if (r) {
1540 cont->error();
1541 reset_fdc();
1542 return;
1545 if (!(flags & FD_RAW_INTR)) {
1546 inr = result();
1547 cont->interrupt();
1548 } else if (flags & FD_RAW_NEED_DISK)
1549 fd_watchdog();
1552 static int blind_seek;
1554 /*
1555 * This is the routine called after every seek (or recalibrate) interrupt
1556 * from the floppy controller.
1557 */
1558 static void seek_interrupt(void)
1560 debugt("seek interrupt:");
1561 if (inr != 2 || (ST0 & 0xF8) != 0x20) {
1562 DPRINT("seek failed\n");
1563 DRS->track = NEED_2_RECAL;
1564 cont->error();
1565 cont->redo();
1566 return;
1568 if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
1569 #ifdef DCL_DEBUG
1570 if (DP->flags & FD_DEBUG) {
1571 DPRINT
1572 ("clearing NEWCHANGE flag because of effective seek\n");
1573 DPRINT("jiffies=%lu\n", jiffies);
1575 #endif
1576 CLEARF(FD_DISK_NEWCHANGE); /* effective seek */
1577 DRS->select_date = jiffies;
1579 DRS->track = ST1;
1580 floppy_ready();
1583 static void check_wp(void)
1585 if (TESTF(FD_VERIFY)) {
1586 /* check write protection */
1587 output_byte(FD_GETSTATUS);
1588 output_byte(UNIT(current_drive));
1589 if (result() != 1) {
1590 FDCS->reset = 1;
1591 return;
1593 CLEARF(FD_VERIFY);
1594 CLEARF(FD_NEED_TWADDLE);
1595 #ifdef DCL_DEBUG
1596 if (DP->flags & FD_DEBUG) {
1597 DPRINT("checking whether disk is write protected\n");
1598 DPRINT("wp=%x\n", ST3 & 0x40);
1600 #endif
1601 if (!(ST3 & 0x40))
1602 SETF(FD_DISK_WRITABLE);
1603 else
1604 CLEARF(FD_DISK_WRITABLE);
1608 static void seek_floppy(void)
1610 int track;
1612 blind_seek = 0;
1614 #ifdef DCL_DEBUG
1615 if (DP->flags & FD_DEBUG) {
1616 DPRINT("calling disk change from seek\n");
1618 #endif
1620 if (!TESTF(FD_DISK_NEWCHANGE) &&
1621 disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1622 /* the media changed flag should be cleared after the seek.
1623 * If it isn't, this means that there is really no disk in
1624 * the drive.
1625 */
1626 SETF(FD_DISK_CHANGED);
1627 cont->done(0);
1628 cont->redo();
1629 return;
1631 if (DRS->track <= NEED_1_RECAL) {
1632 recalibrate_floppy();
1633 return;
1634 } else if (TESTF(FD_DISK_NEWCHANGE) &&
1635 (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1636 (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
1637 /* we seek to clear the media-changed condition. Does anybody
1638 * know a more elegant way, which works on all drives? */
1639 if (raw_cmd->track)
1640 track = raw_cmd->track - 1;
1641 else {
1642 if (DP->flags & FD_SILENT_DCL_CLEAR) {
1643 set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
1644 blind_seek = 1;
1645 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1647 track = 1;
1649 } else {
1650 check_wp();
1651 if (raw_cmd->track != DRS->track &&
1652 (raw_cmd->flags & FD_RAW_NEED_SEEK))
1653 track = raw_cmd->track;
1654 else {
1655 setup_rw_floppy();
1656 return;
1660 do_floppy = seek_interrupt;
1661 output_byte(FD_SEEK);
1662 output_byte(UNIT(current_drive));
1663 LAST_OUT(track);
1664 debugt("seek command:");
1667 static void recal_interrupt(void)
1669 debugt("recal interrupt:");
1670 if (inr != 2)
1671 FDCS->reset = 1;
1672 else if (ST0 & ST0_ECE) {
1673 switch (DRS->track) {
1674 case NEED_1_RECAL:
1675 debugt("recal interrupt need 1 recal:");
1676 /* after a second recalibrate, we still haven't
1677 * reached track 0. Probably no drive. Raise an
1678 * error, as failing immediately might upset
1679 * computers possessed by the Devil :-) */
1680 cont->error();
1681 cont->redo();
1682 return;
1683 case NEED_2_RECAL:
1684 debugt("recal interrupt need 2 recal:");
1685 /* If we already did a recalibrate,
1686 * and we are not at track 0, this
1687 * means we have moved. (The only way
1688 * not to move at recalibration is to
1689 * be already at track 0.) Clear the
1690 * new change flag */
1691 #ifdef DCL_DEBUG
1692 if (DP->flags & FD_DEBUG) {
1693 DPRINT
1694 ("clearing NEWCHANGE flag because of second recalibrate\n");
1696 #endif
1698 CLEARF(FD_DISK_NEWCHANGE);
1699 DRS->select_date = jiffies;
1700 /* fall through */
1701 default:
1702 debugt("recal interrupt default:");
1703 /* Recalibrate moves the head by at
1704 * most 80 steps. If after one
1705 * recalibrate we don't have reached
1706 * track 0, this might mean that we
1707 * started beyond track 80. Try
1708 * again. */
1709 DRS->track = NEED_1_RECAL;
1710 break;
1712 } else
1713 DRS->track = ST1;
1714 floppy_ready();
1717 static void print_result(char *message, int inr)
1719 int i;
1721 DPRINT("%s ", message);
1722 if (inr >= 0)
1723 for (i = 0; i < inr; i++)
1724 printk("repl[%d]=%x ", i, reply_buffer[i]);
1725 printk("\n");
1728 /* interrupt handler. Note that this can be called externally on the Sparc */
1729 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1731 void (*handler) (void) = do_floppy;
1732 int do_print;
1733 unsigned long f;
1735 lasthandler = handler;
1736 interruptjiffies = jiffies;
1738 f = claim_dma_lock();
1739 fd_disable_dma();
1740 release_dma_lock(f);
1742 floppy_enable_hlt();
1743 do_floppy = NULL;
1744 if (fdc >= N_FDC || FDCS->address == -1) {
1745 /* we don't even know which FDC is the culprit */
1746 printk("DOR0=%x\n", fdc_state[0].dor);
1747 printk("floppy interrupt on bizarre fdc %d\n", fdc);
1748 printk("handler=%p\n", handler);
1749 is_alive("bizarre fdc");
1750 return IRQ_NONE;
1753 FDCS->reset = 0;
1754 /* We have to clear the reset flag here, because apparently on boxes
1755 * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
1756 * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
1757 * emission of the SENSEI's.
1758 * It is OK to emit floppy commands because we are in an interrupt
1759 * handler here, and thus we have to fear no interference of other
1760 * activity.
1761 */
1763 do_print = !handler && print_unex && !initialising;
1765 inr = result();
1766 if (do_print)
1767 print_result("unexpected interrupt", inr);
1768 if (inr == 0) {
1769 int max_sensei = 4;
1770 do {
1771 output_byte(FD_SENSEI);
1772 inr = result();
1773 if (do_print)
1774 print_result("sensei", inr);
1775 max_sensei--;
1776 } while ((ST0 & 0x83) != UNIT(current_drive) && inr == 2
1777 && max_sensei);
1779 if (!handler) {
1780 FDCS->reset = 1;
1781 return IRQ_NONE;
1783 schedule_bh(handler);
1784 is_alive("normal interrupt end");
1786 /* FIXME! Was it really for us? */
1787 return IRQ_HANDLED;
1790 static void recalibrate_floppy(void)
1792 debugt("recalibrate floppy:");
1793 do_floppy = recal_interrupt;
1794 output_byte(FD_RECALIBRATE);
1795 LAST_OUT(UNIT(current_drive));
1798 /*
1799 * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1800 */
1801 static void reset_interrupt(void)
1803 debugt("reset interrupt:");
1804 result(); /* get the status ready for set_fdc */
1805 if (FDCS->reset) {
1806 printk("reset set in interrupt, calling %p\n", cont->error);
1807 cont->error(); /* a reset just after a reset. BAD! */
1809 cont->redo();
1812 /*
1813 * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1814 * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1815 */
1816 static void reset_fdc(void)
1818 unsigned long flags;
1820 do_floppy = reset_interrupt;
1821 FDCS->reset = 0;
1822 reset_fdc_info(0);
1824 /* Pseudo-DMA may intercept 'reset finished' interrupt. */
1825 /* Irrelevant for systems with true DMA (i386). */
1827 flags = claim_dma_lock();
1828 fd_disable_dma();
1829 release_dma_lock(flags);
1831 if (FDCS->version >= FDC_82072A)
1832 fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
1833 else {
1834 fd_outb(FDCS->dor & ~0x04, FD_DOR);
1835 udelay(FD_RESET_DELAY);
1836 fd_outb(FDCS->dor, FD_DOR);
1840 static void show_floppy(void)
1842 int i;
1844 printk("\n");
1845 printk("floppy driver state\n");
1846 printk("-------------------\n");
1847 printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",
1848 jiffies, interruptjiffies, jiffies - interruptjiffies,
1849 lasthandler);
1851 #ifdef FLOPPY_SANITY_CHECK
1852 printk("timeout_message=%s\n", timeout_message);
1853 printk("last output bytes:\n");
1854 for (i = 0; i < OLOGSIZE; i++)
1855 printk("%2x %2x %lu\n",
1856 output_log[(i + output_log_pos) % OLOGSIZE].data,
1857 output_log[(i + output_log_pos) % OLOGSIZE].status,
1858 output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1859 printk("last result at %lu\n", resultjiffies);
1860 printk("last redo_fd_request at %lu\n", lastredo);
1861 for (i = 0; i < resultsize; i++) {
1862 printk("%2x ", reply_buffer[i]);
1864 printk("\n");
1865 #endif
1867 printk("status=%x\n", fd_inb(FD_STATUS));
1868 printk("fdc_busy=%lu\n", fdc_busy);
1869 if (do_floppy)
1870 printk("do_floppy=%p\n", do_floppy);
1871 if (floppy_work.pending)
1872 printk("floppy_work.func=%p\n", floppy_work.func);
1873 if (timer_pending(&fd_timer))
1874 printk("fd_timer.function=%p\n", fd_timer.function);
1875 if (timer_pending(&fd_timeout)) {
1876 printk("timer_function=%p\n", fd_timeout.function);
1877 printk("expires=%lu\n", fd_timeout.expires - jiffies);
1878 printk("now=%lu\n", jiffies);
1880 printk("cont=%p\n", cont);
1881 printk("current_req=%p\n", current_req);
1882 printk("command_status=%d\n", command_status);
1883 printk("\n");
1886 static void floppy_shutdown(unsigned long data)
1888 unsigned long flags;
1890 if (!initialising)
1891 show_floppy();
1892 cancel_activity();
1894 floppy_enable_hlt();
1896 flags = claim_dma_lock();
1897 fd_disable_dma();
1898 release_dma_lock(flags);
1900 /* avoid dma going to a random drive after shutdown */
1902 if (!initialising)
1903 DPRINT("floppy timeout called\n");
1904 FDCS->reset = 1;
1905 if (cont) {
1906 cont->done(0);
1907 cont->redo(); /* this will recall reset when needed */
1908 } else {
1909 printk("no cont in shutdown!\n");
1910 process_fd_request();
1912 is_alive("floppy shutdown");
1915 /*typedef void (*timeout_fn)(unsigned long);*/
1917 /* start motor, check media-changed condition and write protection */
1918 static int start_motor(void (*function) (void))
1920 int mask, data;
1922 mask = 0xfc;
1923 data = UNIT(current_drive);
1924 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1925 if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
1926 set_debugt();
1927 /* no read since this drive is running */
1928 DRS->first_read_date = 0;
1929 /* note motor start time if motor is not yet running */
1930 DRS->spinup_date = jiffies;
1931 data |= (0x10 << UNIT(current_drive));
1933 } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
1934 mask &= ~(0x10 << UNIT(current_drive));
1936 /* starts motor and selects floppy */
1937 del_timer(motor_off_timer + current_drive);
1938 set_dor(fdc, mask, data);
1940 /* wait_for_completion also schedules reset if needed. */
1941 return (fd_wait_for_completion(DRS->select_date + DP->select_delay,
1942 (timeout_fn) function));
1945 static void floppy_ready(void)
1947 CHECK_RESET;
1948 if (start_motor(floppy_ready))
1949 return;
1950 if (fdc_dtr())
1951 return;
1953 #ifdef DCL_DEBUG
1954 if (DP->flags & FD_DEBUG) {
1955 DPRINT("calling disk change from floppy_ready\n");
1957 #endif
1958 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1959 disk_change(current_drive) && !DP->select_delay)
1960 twaddle(); /* this clears the dcl on certain drive/controller
1961 * combinations */
1963 #ifdef fd_chose_dma_mode
1964 if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1965 unsigned long flags = claim_dma_lock();
1966 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1967 release_dma_lock(flags);
1969 #endif
1971 if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1972 perpendicular_mode();
1973 fdc_specify(); /* must be done here because of hut, hlt ... */
1974 seek_floppy();
1975 } else {
1976 if ((raw_cmd->flags & FD_RAW_READ) ||
1977 (raw_cmd->flags & FD_RAW_WRITE))
1978 fdc_specify();
1979 setup_rw_floppy();
1983 static void floppy_start(void)
1985 reschedule_timeout(current_reqD, "floppy start", 0);
1987 scandrives();
1988 #ifdef DCL_DEBUG
1989 if (DP->flags & FD_DEBUG) {
1990 DPRINT("setting NEWCHANGE in floppy_start\n");
1992 #endif
1993 SETF(FD_DISK_NEWCHANGE);
1994 floppy_ready();
1997 /*
1998 * ========================================================================
1999 * here ends the bottom half. Exported routines are:
2000 * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
2001 * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
2002 * Initialization also uses output_byte, result, set_dor, floppy_interrupt
2003 * and set_dor.
2004 * ========================================================================
2005 */
2006 /*
2007 * General purpose continuations.
2008 * ==============================
2009 */
2011 static void do_wakeup(void)
2013 reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
2014 cont = NULL;
2015 command_status += 2;
2016 wake_up(&command_done);
2019 static struct cont_t wakeup_cont = {
2020 .interrupt = empty,
2021 .redo = do_wakeup,
2022 .error = empty,
2023 .done = (done_f) empty
2024 };
2026 static struct cont_t intr_cont = {
2027 .interrupt = empty,
2028 .redo = process_fd_request,
2029 .error = empty,
2030 .done = (done_f) empty
2031 };
2033 static int wait_til_done(void (*handler) (void), int interruptible)
2035 int ret;
2037 schedule_bh(handler);
2039 if (command_status < 2 && NO_SIGNAL) {
2040 DECLARE_WAITQUEUE(wait, current);
2042 add_wait_queue(&command_done, &wait);
2043 for (;;) {
2044 set_current_state(interruptible ?
2045 TASK_INTERRUPTIBLE :
2046 TASK_UNINTERRUPTIBLE);
2048 if (command_status >= 2 || !NO_SIGNAL)
2049 break;
2051 is_alive("wait_til_done");
2053 schedule();
2056 set_current_state(TASK_RUNNING);
2057 remove_wait_queue(&command_done, &wait);
2060 if (command_status < 2) {
2061 cancel_activity();
2062 cont = &intr_cont;
2063 reset_fdc();
2064 return -EINTR;
2067 if (FDCS->reset)
2068 command_status = FD_COMMAND_ERROR;
2069 if (command_status == FD_COMMAND_OKAY)
2070 ret = 0;
2071 else
2072 ret = -EIO;
2073 command_status = FD_COMMAND_NONE;
2074 return ret;
2077 static void generic_done(int result)
2079 command_status = result;
2080 cont = &wakeup_cont;
2083 static void generic_success(void)
2085 cont->done(1);
2088 static void generic_failure(void)
2090 cont->done(0);
2093 static void success_and_wakeup(void)
2095 generic_success();
2096 cont->redo();
2099 /*
2100 * formatting and rw support.
2101 * ==========================
2102 */
2104 static int next_valid_format(void)
2106 int probed_format;
2108 probed_format = DRS->probed_format;
2109 while (1) {
2110 if (probed_format >= 8 || !DP->autodetect[probed_format]) {
2111 DRS->probed_format = 0;
2112 return 1;
2114 if (floppy_type[DP->autodetect[probed_format]].sect) {
2115 DRS->probed_format = probed_format;
2116 return 0;
2118 probed_format++;
2122 static void bad_flp_intr(void)
2124 int err_count;
2126 if (probing) {
2127 DRS->probed_format++;
2128 if (!next_valid_format())
2129 return;
2131 err_count = ++(*errors);
2132 INFBOUND(DRWE->badness, err_count);
2133 if (err_count > DP->max_errors.abort)
2134 cont->done(0);
2135 if (err_count > DP->max_errors.reset)
2136 FDCS->reset = 1;
2137 else if (err_count > DP->max_errors.recal)
2138 DRS->track = NEED_2_RECAL;
2141 static void set_floppy(int drive)
2143 int type = ITYPE(UDRS->fd_device);
2144 if (type)
2145 _floppy = floppy_type + type;
2146 else
2147 _floppy = current_type[drive];
2150 /*
2151 * formatting support.
2152 * ===================
2153 */
2154 static void format_interrupt(void)
2156 switch (interpret_errors()) {
2157 case 1:
2158 cont->error();
2159 case 2:
2160 break;
2161 case 0:
2162 cont->done(1);
2164 cont->redo();
2167 #define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
2168 #define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80) >>1))
2169 #define CT(x) ((x) | 0xc0)
2170 static void setup_format_params(int track)
2172 struct fparm {
2173 unsigned char track, head, sect, size;
2174 } *here = (struct fparm *)floppy_track_buffer;
2175 int il, n;
2176 int count, head_shift, track_shift;
2178 raw_cmd = &default_raw_cmd;
2179 raw_cmd->track = track;
2181 raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2182 FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2183 raw_cmd->rate = _floppy->rate & 0x43;
2184 raw_cmd->cmd_count = NR_F;
2185 COMMAND = FM_MODE(_floppy, FD_FORMAT);
2186 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2187 F_SIZECODE = FD_SIZECODE(_floppy);
2188 F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2189 F_GAP = _floppy->fmt_gap;
2190 F_FILL = FD_FILL_BYTE;
2192 raw_cmd->kernel_data = floppy_track_buffer;
2193 raw_cmd->length = 4 * F_SECT_PER_TRACK;
2195 /* allow for about 30ms for data transport per track */
2196 head_shift = (F_SECT_PER_TRACK + 5) / 6;
2198 /* a ``cylinder'' is two tracks plus a little stepping time */
2199 track_shift = 2 * head_shift + 3;
2201 /* position of logical sector 1 on this track */
2202 n = (track_shift * format_req.track + head_shift * format_req.head)
2203 % F_SECT_PER_TRACK;
2205 /* determine interleave */
2206 il = 1;
2207 if (_floppy->fmt_gap < 0x22)
2208 il++;
2210 /* initialize field */
2211 for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2212 here[count].track = format_req.track;
2213 here[count].head = format_req.head;
2214 here[count].sect = 0;
2215 here[count].size = F_SIZECODE;
2217 /* place logical sectors */
2218 for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2219 here[n].sect = count;
2220 n = (n + il) % F_SECT_PER_TRACK;
2221 if (here[n].sect) { /* sector busy, find next free sector */
2222 ++n;
2223 if (n >= F_SECT_PER_TRACK) {
2224 n -= F_SECT_PER_TRACK;
2225 while (here[n].sect)
2226 ++n;
2230 if (_floppy->stretch & FD_ZEROBASED) {
2231 for (count = 0; count < F_SECT_PER_TRACK; count++)
2232 here[count].sect--;
2236 static void redo_format(void)
2238 buffer_track = -1;
2239 setup_format_params(format_req.track << STRETCH(_floppy));
2240 floppy_start();
2241 debugt("queue format request");
2244 static struct cont_t format_cont = {
2245 .interrupt = format_interrupt,
2246 .redo = redo_format,
2247 .error = bad_flp_intr,
2248 .done = generic_done
2249 };
2251 static int do_format(int drive, struct format_descr *tmp_format_req)
2253 int ret;
2255 LOCK_FDC(drive, 1);
2256 set_floppy(drive);
2257 if (!_floppy ||
2258 _floppy->track > DP->tracks ||
2259 tmp_format_req->track >= _floppy->track ||
2260 tmp_format_req->head >= _floppy->head ||
2261 (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2262 !_floppy->fmt_gap) {
2263 process_fd_request();
2264 return -EINVAL;
2266 format_req = *tmp_format_req;
2267 format_errors = 0;
2268 cont = &format_cont;
2269 errors = &format_errors;
2270 IWAIT(redo_format);
2271 process_fd_request();
2272 return ret;
2275 /*
2276 * Buffer read/write and support
2277 * =============================
2278 */
2280 static void floppy_end_request(struct request *req, int uptodate)
2282 unsigned int nr_sectors = current_count_sectors;
2284 /* current_count_sectors can be zero if transfer failed */
2285 if (!uptodate)
2286 nr_sectors = req->current_nr_sectors;
2287 if (end_that_request_first(req, uptodate, nr_sectors))
2288 return;
2289 add_disk_randomness(req->rq_disk);
2290 floppy_off((long)req->rq_disk->private_data);
2291 blkdev_dequeue_request(req);
2292 end_that_request_last(req, uptodate);
2294 /* We're done with the request */
2295 current_req = NULL;
2298 /* new request_done. Can handle physical sectors which are smaller than a
2299 * logical buffer */
2300 static void request_done(int uptodate)
2302 struct request_queue *q = floppy_queue;
2303 struct request *req = current_req;
2304 unsigned long flags;
2305 int block;
2307 probing = 0;
2308 reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
2310 if (!req) {
2311 printk("floppy.c: no request in request_done\n");
2312 return;
2315 if (uptodate) {
2316 /* maintain values for invalidation on geometry
2317 * change */
2318 block = current_count_sectors + req->sector;
2319 INFBOUND(DRS->maxblock, block);
2320 if (block > _floppy->sect)
2321 DRS->maxtrack = 1;
2323 /* unlock chained buffers */
2324 spin_lock_irqsave(q->queue_lock, flags);
2325 floppy_end_request(req, 1);
2326 spin_unlock_irqrestore(q->queue_lock, flags);
2327 } else {
2328 if (rq_data_dir(req) == WRITE) {
2329 /* record write error information */
2330 DRWE->write_errors++;
2331 if (DRWE->write_errors == 1) {
2332 DRWE->first_error_sector = req->sector;
2333 DRWE->first_error_generation = DRS->generation;
2335 DRWE->last_error_sector = req->sector;
2336 DRWE->last_error_generation = DRS->generation;
2338 spin_lock_irqsave(q->queue_lock, flags);
2339 floppy_end_request(req, 0);
2340 spin_unlock_irqrestore(q->queue_lock, flags);
2344 /* Interrupt handler evaluating the result of the r/w operation */
2345 static void rw_interrupt(void)
2347 int nr_sectors, ssize, eoc, heads;
2349 if (R_HEAD >= 2) {
2350 /* some Toshiba floppy controllers occasionnally seem to
2351 * return bogus interrupts after read/write operations, which
2352 * can be recognized by a bad head number (>= 2) */
2353 return;
2356 if (!DRS->first_read_date)
2357 DRS->first_read_date = jiffies;
2359 nr_sectors = 0;
2360 CODE2SIZE;
2362 if (ST1 & ST1_EOC)
2363 eoc = 1;
2364 else
2365 eoc = 0;
2367 if (COMMAND & 0x80)
2368 heads = 2;
2369 else
2370 heads = 1;
2372 nr_sectors = (((R_TRACK - TRACK) * heads +
2373 R_HEAD - HEAD) * SECT_PER_TRACK +
2374 R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2376 #ifdef FLOPPY_SANITY_CHECK
2377 if (nr_sectors / ssize >
2378 (in_sector_offset + current_count_sectors + ssize - 1) / ssize) {
2379 DPRINT("long rw: %x instead of %lx\n",
2380 nr_sectors, current_count_sectors);
2381 printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
2382 printk("rh=%d h=%d\n", R_HEAD, HEAD);
2383 printk("rt=%d t=%d\n", R_TRACK, TRACK);
2384 printk("heads=%d eoc=%d\n", heads, eoc);
2385 printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
2386 fsector_t, ssize);
2387 printk("in_sector_offset=%d\n", in_sector_offset);
2389 #endif
2391 nr_sectors -= in_sector_offset;
2392 INFBOUND(nr_sectors, 0);
2393 SUPBOUND(current_count_sectors, nr_sectors);
2395 switch (interpret_errors()) {
2396 case 2:
2397 cont->redo();
2398 return;
2399 case 1:
2400 if (!current_count_sectors) {
2401 cont->error();
2402 cont->redo();
2403 return;
2405 break;
2406 case 0:
2407 if (!current_count_sectors) {
2408 cont->redo();
2409 return;
2411 current_type[current_drive] = _floppy;
2412 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2413 break;
2416 if (probing) {
2417 if (DP->flags & FTD_MSG)
2418 DPRINT("Auto-detected floppy type %s in fd%d\n",
2419 _floppy->name, current_drive);
2420 current_type[current_drive] = _floppy;
2421 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2422 probing = 0;
2425 if (CT(COMMAND) != FD_READ ||
2426 raw_cmd->kernel_data == current_req->buffer) {
2427 /* transfer directly from buffer */
2428 cont->done(1);
2429 } else if (CT(COMMAND) == FD_READ) {
2430 buffer_track = raw_cmd->track;
2431 buffer_drive = current_drive;
2432 INFBOUND(buffer_max, nr_sectors + fsector_t);
2434 cont->redo();
2437 /* Compute maximal contiguous buffer size. */
2438 static int buffer_chain_size(void)
2440 struct bio *bio;
2441 struct bio_vec *bv;
2442 int size, i;
2443 char *base;
2445 base = bio_data(current_req->bio);
2446 size = 0;
2448 rq_for_each_bio(bio, current_req) {
2449 bio_for_each_segment(bv, bio, i) {
2450 if (page_address(bv->bv_page) + bv->bv_offset !=
2451 base + size)
2452 break;
2454 size += bv->bv_len;
2458 return size >> 9;
2461 /* Compute the maximal transfer size */
2462 static int transfer_size(int ssize, int max_sector, int max_size)
2464 SUPBOUND(max_sector, fsector_t + max_size);
2466 /* alignment */
2467 max_sector -= (max_sector % _floppy->sect) % ssize;
2469 /* transfer size, beginning not aligned */
2470 current_count_sectors = max_sector - fsector_t;
2472 return max_sector;
2475 /*
2476 * Move data from/to the track buffer to/from the buffer cache.
2477 */
2478 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2480 int remaining; /* number of transferred 512-byte sectors */
2481 struct bio_vec *bv;
2482 struct bio *bio;
2483 char *buffer, *dma_buffer;
2484 int size, i;
2486 max_sector = transfer_size(ssize,
2487 min(max_sector, max_sector_2),
2488 current_req->nr_sectors);
2490 if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2491 buffer_max > fsector_t + current_req->nr_sectors)
2492 current_count_sectors = min_t(int, buffer_max - fsector_t,
2493 current_req->nr_sectors);
2495 remaining = current_count_sectors << 9;
2496 #ifdef FLOPPY_SANITY_CHECK
2497 if ((remaining >> 9) > current_req->nr_sectors &&
2498 CT(COMMAND) == FD_WRITE) {
2499 DPRINT("in copy buffer\n");
2500 printk("current_count_sectors=%ld\n", current_count_sectors);
2501 printk("remaining=%d\n", remaining >> 9);
2502 printk("current_req->nr_sectors=%ld\n",
2503 current_req->nr_sectors);
2504 printk("current_req->current_nr_sectors=%u\n",
2505 current_req->current_nr_sectors);
2506 printk("max_sector=%d\n", max_sector);
2507 printk("ssize=%d\n", ssize);
2509 #endif
2511 buffer_max = max(max_sector, buffer_max);
2513 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2515 size = current_req->current_nr_sectors << 9;
2517 rq_for_each_bio(bio, current_req) {
2518 bio_for_each_segment(bv, bio, i) {
2519 if (!remaining)
2520 break;
2522 size = bv->bv_len;
2523 SUPBOUND(size, remaining);
2525 buffer = page_address(bv->bv_page) + bv->bv_offset;
2526 #ifdef FLOPPY_SANITY_CHECK
2527 if (dma_buffer + size >
2528 floppy_track_buffer + (max_buffer_sectors << 10) ||
2529 dma_buffer < floppy_track_buffer) {
2530 DPRINT("buffer overrun in copy buffer %d\n",
2531 (int)((floppy_track_buffer -
2532 dma_buffer) >> 9));
2533 printk("fsector_t=%d buffer_min=%d\n",
2534 fsector_t, buffer_min);
2535 printk("current_count_sectors=%ld\n",
2536 current_count_sectors);
2537 if (CT(COMMAND) == FD_READ)
2538 printk("read\n");
2539 if (CT(COMMAND) == FD_WRITE)
2540 printk("write\n");
2541 break;
2543 if (((unsigned long)buffer) % 512)
2544 DPRINT("%p buffer not aligned\n", buffer);
2545 #endif
2546 if (CT(COMMAND) == FD_READ)
2547 memcpy(buffer, dma_buffer, size);
2548 else
2549 memcpy(dma_buffer, buffer, size);
2551 remaining -= size;
2552 dma_buffer += size;
2555 #ifdef FLOPPY_SANITY_CHECK
2556 if (remaining) {
2557 if (remaining > 0)
2558 max_sector -= remaining >> 9;
2559 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2561 #endif
2564 #if 0
2565 static inline int check_dma_crossing(char *start,
2566 unsigned long length, char *message)
2568 if (CROSS_64KB(start, length)) {
2569 printk("DMA xfer crosses 64KB boundary in %s %p-%p\n",
2570 message, start, start + length);
2571 return 1;
2572 } else
2573 return 0;
2575 #endif
2577 /* work around a bug in pseudo DMA
2578 * (on some FDCs) pseudo DMA does not stop when the CPU stops
2579 * sending data. Hence we need a different way to signal the
2580 * transfer length: We use SECT_PER_TRACK. Unfortunately, this
2581 * does not work with MT, hence we can only transfer one head at
2582 * a time
2583 */
2584 static void virtualdmabug_workaround(void)
2586 int hard_sectors, end_sector;
2588 if (CT(COMMAND) == FD_WRITE) {
2589 COMMAND &= ~0x80; /* switch off multiple track mode */
2591 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2592 end_sector = SECTOR + hard_sectors - 1;
2593 #ifdef FLOPPY_SANITY_CHECK
2594 if (end_sector > SECT_PER_TRACK) {
2595 printk("too many sectors %d > %d\n",
2596 end_sector, SECT_PER_TRACK);
2597 return;
2599 #endif
2600 SECT_PER_TRACK = end_sector; /* make sure SECT_PER_TRACK points
2601 * to end of transfer */
2605 /*
2606 * Formulate a read/write request.
2607 * this routine decides where to load the data (directly to buffer, or to
2608 * tmp floppy area), how much data to load (the size of the buffer, the whole
2609 * track, or a single sector)
2610 * All floppy_track_buffer handling goes in here. If we ever add track buffer
2611 * allocation on the fly, it should be done here. No other part should need
2612 * modification.
2613 */
2615 static int make_raw_rw_request(void)
2617 int aligned_sector_t;
2618 int max_sector, max_size, tracksize, ssize;
2620 if (max_buffer_sectors == 0) {
2621 printk("VFS: Block I/O scheduled on unopened device\n");
2622 return 0;
2625 set_fdc((long)current_req->rq_disk->private_data);
2627 raw_cmd = &default_raw_cmd;
2628 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2629 FD_RAW_NEED_SEEK;
2630 raw_cmd->cmd_count = NR_RW;
2631 if (rq_data_dir(current_req) == READ) {
2632 raw_cmd->flags |= FD_RAW_READ;
2633 COMMAND = FM_MODE(_floppy, FD_READ);
2634 } else if (rq_data_dir(current_req) == WRITE) {
2635 raw_cmd->flags |= FD_RAW_WRITE;
2636 COMMAND = FM_MODE(_floppy, FD_WRITE);
2637 } else {
2638 DPRINT("make_raw_rw_request: unknown command\n");
2639 return 0;
2642 max_sector = _floppy->sect * _floppy->head;
2644 TRACK = (int)current_req->sector / max_sector;
2645 fsector_t = (int)current_req->sector % max_sector;
2646 if (_floppy->track && TRACK >= _floppy->track) {
2647 if (current_req->current_nr_sectors & 1) {
2648 current_count_sectors = 1;
2649 return 1;
2650 } else
2651 return 0;
2653 HEAD = fsector_t / _floppy->sect;
2655 if (((_floppy->stretch & (FD_SWAPSIDES | FD_ZEROBASED)) ||
2656 TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
2657 max_sector = _floppy->sect;
2659 /* 2M disks have phantom sectors on the first track */
2660 if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2661 max_sector = 2 * _floppy->sect / 3;
2662 if (fsector_t >= max_sector) {
2663 current_count_sectors =
2664 min_t(int, _floppy->sect - fsector_t,
2665 current_req->nr_sectors);
2666 return 1;
2668 SIZECODE = 2;
2669 } else
2670 SIZECODE = FD_SIZECODE(_floppy);
2671 raw_cmd->rate = _floppy->rate & 0x43;
2672 if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2673 raw_cmd->rate = 1;
2675 if (SIZECODE)
2676 SIZECODE2 = 0xff;
2677 else
2678 SIZECODE2 = 0x80;
2679 raw_cmd->track = TRACK << STRETCH(_floppy);
2680 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2681 GAP = _floppy->gap;
2682 CODE2SIZE;
2683 SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2684 SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
2685 ((_floppy->stretch & FD_ZEROBASED) ? 0 : 1);
2687 /* tracksize describes the size which can be filled up with sectors
2688 * of size ssize.
2689 */
2690 tracksize = _floppy->sect - _floppy->sect % ssize;
2691 if (tracksize < _floppy->sect) {
2692 SECT_PER_TRACK++;
2693 if (tracksize <= fsector_t % _floppy->sect)
2694 SECTOR--;
2696 /* if we are beyond tracksize, fill up using smaller sectors */
2697 while (tracksize <= fsector_t % _floppy->sect) {
2698 while (tracksize + ssize > _floppy->sect) {
2699 SIZECODE--;
2700 ssize >>= 1;
2702 SECTOR++;
2703 SECT_PER_TRACK++;
2704 tracksize += ssize;
2706 max_sector = HEAD * _floppy->sect + tracksize;
2707 } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2708 max_sector = _floppy->sect;
2709 } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2710 /* for virtual DMA bug workaround */
2711 max_sector = _floppy->sect;
2714 in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2715 aligned_sector_t = fsector_t - in_sector_offset;
2716 max_size = current_req->nr_sectors;
2717 if ((raw_cmd->track == buffer_track) &&
2718 (current_drive == buffer_drive) &&
2719 (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2720 /* data already in track buffer */
2721 if (CT(COMMAND) == FD_READ) {
2722 copy_buffer(1, max_sector, buffer_max);
2723 return 1;
2725 } else if (in_sector_offset || current_req->nr_sectors < ssize) {
2726 if (CT(COMMAND) == FD_WRITE) {
2727 if (fsector_t + current_req->nr_sectors > ssize &&
2728 fsector_t + current_req->nr_sectors < ssize + ssize)
2729 max_size = ssize + ssize;
2730 else
2731 max_size = ssize;
2733 raw_cmd->flags &= ~FD_RAW_WRITE;
2734 raw_cmd->flags |= FD_RAW_READ;
2735 COMMAND = FM_MODE(_floppy, FD_READ);
2736 } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2737 unsigned long dma_limit;
2738 int direct, indirect;
2740 indirect =
2741 transfer_size(ssize, max_sector,
2742 max_buffer_sectors * 2) - fsector_t;
2744 /*
2745 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2746 * on a 64 bit machine!
2747 */
2748 max_size = buffer_chain_size();
2749 dma_limit =
2750 (MAX_DMA_ADDRESS -
2751 ((unsigned long)current_req->buffer)) >> 9;
2752 if ((unsigned long)max_size > dma_limit) {
2753 max_size = dma_limit;
2755 /* 64 kb boundaries */
2756 if (CROSS_64KB(current_req->buffer, max_size << 9))
2757 max_size = (K_64 -
2758 ((unsigned long)current_req->buffer) %
2759 K_64) >> 9;
2760 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2761 /*
2762 * We try to read tracks, but if we get too many errors, we
2763 * go back to reading just one sector at a time.
2765 * This means we should be able to read a sector even if there
2766 * are other bad sectors on this track.
2767 */
2768 if (!direct ||
2769 (indirect * 2 > direct * 3 &&
2770 *errors < DP->max_errors.read_track &&
2771 /*!TESTF(FD_NEED_TWADDLE) && */
2772 ((!probing
2773 || (DP->read_track & (1 << DRS->probed_format)))))) {
2774 max_size = current_req->nr_sectors;
2775 } else {
2776 raw_cmd->kernel_data = current_req->buffer;
2777 raw_cmd->length = current_count_sectors << 9;
2778 if (raw_cmd->length == 0) {
2779 DPRINT
2780 ("zero dma transfer attempted from make_raw_request\n");
2781 DPRINT("indirect=%d direct=%d fsector_t=%d",
2782 indirect, direct, fsector_t);
2783 return 0;
2785 /* check_dma_crossing(raw_cmd->kernel_data,
2786 raw_cmd->length,
2787 "end of make_raw_request [1]");*/
2789 virtualdmabug_workaround();
2790 return 2;
2794 if (CT(COMMAND) == FD_READ)
2795 max_size = max_sector; /* unbounded */
2797 /* claim buffer track if needed */
2798 if (buffer_track != raw_cmd->track || /* bad track */
2799 buffer_drive != current_drive || /* bad drive */
2800 fsector_t > buffer_max ||
2801 fsector_t < buffer_min ||
2802 ((CT(COMMAND) == FD_READ ||
2803 (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
2804 max_sector > 2 * max_buffer_sectors + buffer_min &&
2805 max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
2806 /* not enough space */
2807 ) {
2808 buffer_track = -1;
2809 buffer_drive = current_drive;
2810 buffer_max = buffer_min = aligned_sector_t;
2812 raw_cmd->kernel_data = floppy_track_buffer +
2813 ((aligned_sector_t - buffer_min) << 9);
2815 if (CT(COMMAND) == FD_WRITE) {
2816 /* copy write buffer to track buffer.
2817 * if we get here, we know that the write
2818 * is either aligned or the data already in the buffer
2819 * (buffer will be overwritten) */
2820 #ifdef FLOPPY_SANITY_CHECK
2821 if (in_sector_offset && buffer_track == -1)
2822 DPRINT("internal error offset !=0 on write\n");
2823 #endif
2824 buffer_track = raw_cmd->track;
2825 buffer_drive = current_drive;
2826 copy_buffer(ssize, max_sector,
2827 2 * max_buffer_sectors + buffer_min);
2828 } else
2829 transfer_size(ssize, max_sector,
2830 2 * max_buffer_sectors + buffer_min -
2831 aligned_sector_t);
2833 /* round up current_count_sectors to get dma xfer size */
2834 raw_cmd->length = in_sector_offset + current_count_sectors;
2835 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2836 raw_cmd->length <<= 9;
2837 #ifdef FLOPPY_SANITY_CHECK
2838 /*check_dma_crossing(raw_cmd->kernel_data, raw_cmd->length,
2839 "end of make_raw_request"); */
2840 if ((raw_cmd->length < current_count_sectors << 9) ||
2841 (raw_cmd->kernel_data != current_req->buffer &&
2842 CT(COMMAND) == FD_WRITE &&
2843 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2844 aligned_sector_t < buffer_min)) ||
2845 raw_cmd->length % (128 << SIZECODE) ||
2846 raw_cmd->length <= 0 || current_count_sectors <= 0) {
2847 DPRINT("fractionary current count b=%lx s=%lx\n",
2848 raw_cmd->length, current_count_sectors);
2849 if (raw_cmd->kernel_data != current_req->buffer)
2850 printk("addr=%d, length=%ld\n",
2851 (int)((raw_cmd->kernel_data -
2852 floppy_track_buffer) >> 9),
2853 current_count_sectors);
2854 printk("st=%d ast=%d mse=%d msi=%d\n",
2855 fsector_t, aligned_sector_t, max_sector, max_size);
2856 printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2857 printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2858 COMMAND, SECTOR, HEAD, TRACK);
2859 printk("buffer drive=%d\n", buffer_drive);
2860 printk("buffer track=%d\n", buffer_track);
2861 printk("buffer_min=%d\n", buffer_min);
2862 printk("buffer_max=%d\n", buffer_max);
2863 return 0;
2866 if (raw_cmd->kernel_data != current_req->buffer) {
2867 if (raw_cmd->kernel_data < floppy_track_buffer ||
2868 current_count_sectors < 0 ||
2869 raw_cmd->length < 0 ||
2870 raw_cmd->kernel_data + raw_cmd->length >
2871 floppy_track_buffer + (max_buffer_sectors << 10)) {
2872 DPRINT("buffer overrun in schedule dma\n");
2873 printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
2874 fsector_t, buffer_min, raw_cmd->length >> 9);
2875 printk("current_count_sectors=%ld\n",
2876 current_count_sectors);
2877 if (CT(COMMAND) == FD_READ)
2878 printk("read\n");
2879 if (CT(COMMAND) == FD_WRITE)
2880 printk("write\n");
2881 return 0;
2883 } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
2884 current_count_sectors > current_req->nr_sectors) {
2885 DPRINT("buffer overrun in direct transfer\n");
2886 return 0;
2887 } else if (raw_cmd->length < current_count_sectors << 9) {
2888 DPRINT("more sectors than bytes\n");
2889 printk("bytes=%ld\n", raw_cmd->length >> 9);
2890 printk("sectors=%ld\n", current_count_sectors);
2892 if (raw_cmd->length == 0) {
2893 DPRINT("zero dma transfer attempted from make_raw_request\n");
2894 return 0;
2896 #endif
2898 virtualdmabug_workaround();
2899 return 2;
2902 static void redo_fd_request(void)
2904 #define REPEAT {request_done(0); continue; }
2905 int drive;
2906 int tmp;
2908 lastredo = jiffies;
2909 if (current_drive < N_DRIVE)
2910 floppy_off(current_drive);
2912 for (;;) {
2913 if (!current_req) {
2914 struct request *req;
2916 spin_lock_irq(floppy_queue->queue_lock);
2917 req = elv_next_request(floppy_queue);
2918 spin_unlock_irq(floppy_queue->queue_lock);
2919 if (!req) {
2920 do_floppy = NULL;
2921 unlock_fdc();
2922 return;
2924 current_req = req;
2926 drive = (long)current_req->rq_disk->private_data;
2927 set_fdc(drive);
2928 reschedule_timeout(current_reqD, "redo fd request", 0);
2930 set_floppy(drive);
2931 raw_cmd = &default_raw_cmd;
2932 raw_cmd->flags = 0;
2933 if (start_motor(redo_fd_request))
2934 return;
2935 disk_change(current_drive);
2936 if (test_bit(current_drive, &fake_change) ||
2937 TESTF(FD_DISK_CHANGED)) {
2938 DPRINT("disk absent or changed during operation\n");
2939 REPEAT;
2941 if (!_floppy) { /* Autodetection */
2942 if (!probing) {
2943 DRS->probed_format = 0;
2944 if (next_valid_format()) {
2945 DPRINT("no autodetectable formats\n");
2946 _floppy = NULL;
2947 REPEAT;
2950 probing = 1;
2951 _floppy =
2952 floppy_type + DP->autodetect[DRS->probed_format];
2953 } else
2954 probing = 0;
2955 errors = &(current_req->errors);
2956 tmp = make_raw_rw_request();
2957 if (tmp < 2) {
2958 request_done(tmp);
2959 continue;
2962 if (TESTF(FD_NEED_TWADDLE))
2963 twaddle();
2964 schedule_bh(floppy_start);
2965 debugt("queue fd request");
2966 return;
2968 #undef REPEAT
2971 static struct cont_t rw_cont = {
2972 .interrupt = rw_interrupt,
2973 .redo = redo_fd_request,
2974 .error = bad_flp_intr,
2975 .done = request_done
2976 };
2978 static void process_fd_request(void)
2980 cont = &rw_cont;
2981 schedule_bh(redo_fd_request);
2984 static void do_fd_request(request_queue_t * q)
2986 if (max_buffer_sectors == 0) {
2987 printk("VFS: do_fd_request called on non-open device\n");
2988 return;
2991 if (usage_count == 0) {
2992 printk("warning: usage count=0, current_req=%p exiting\n",
2993 current_req);
2994 printk("sect=%ld flags=%lx\n", (long)current_req->sector,
2995 current_req->flags);
2996 return;
2998 if (test_bit(0, &fdc_busy)) {
2999 /* fdc busy, this new request will be treated when the
3000 current one is done */
3001 is_alive("do fd request, old request running");
3002 return;
3004 lock_fdc(MAXTIMEOUT, 0);
3005 process_fd_request();
3006 is_alive("do fd request");
3009 static struct cont_t poll_cont = {
3010 .interrupt = success_and_wakeup,
3011 .redo = floppy_ready,
3012 .error = generic_failure,
3013 .done = generic_done
3014 };
3016 static int poll_drive(int interruptible, int flag)
3018 int ret;
3019 /* no auto-sense, just clear dcl */
3020 raw_cmd = &default_raw_cmd;
3021 raw_cmd->flags = flag;
3022 raw_cmd->track = 0;
3023 raw_cmd->cmd_count = 0;
3024 cont = &poll_cont;
3025 #ifdef DCL_DEBUG
3026 if (DP->flags & FD_DEBUG) {
3027 DPRINT("setting NEWCHANGE in poll_drive\n");
3029 #endif
3030 SETF(FD_DISK_NEWCHANGE);
3031 WAIT(floppy_ready);
3032 return ret;
3035 /*
3036 * User triggered reset
3037 * ====================
3038 */
3040 static void reset_intr(void)
3042 printk("weird, reset interrupt called\n");
3045 static struct cont_t reset_cont = {
3046 .interrupt = reset_intr,
3047 .redo = success_and_wakeup,
3048 .error = generic_failure,
3049 .done = generic_done
3050 };
3052 static int user_reset_fdc(int drive, int arg, int interruptible)
3054 int ret;
3056 ret = 0;
3057 LOCK_FDC(drive, interruptible);
3058 if (arg == FD_RESET_ALWAYS)
3059 FDCS->reset = 1;
3060 if (FDCS->reset) {
3061 cont = &reset_cont;
3062 WAIT(reset_fdc);
3064 process_fd_request();
3065 return ret;
3068 /*
3069 * Misc Ioctl's and support
3070 * ========================
3071 */
3072 static inline int fd_copyout(void __user *param, const void *address,
3073 unsigned long size)
3075 return copy_to_user(param, address, size) ? -EFAULT : 0;
3078 static inline int fd_copyin(void __user *param, void *address, unsigned long size)
3080 return copy_from_user(address, param, size) ? -EFAULT : 0;
3083 #define _COPYOUT(x) (copy_to_user((void __user *)param, &(x), sizeof(x)) ? -EFAULT : 0)
3084 #define _COPYIN(x) (copy_from_user(&(x), (void __user *)param, sizeof(x)) ? -EFAULT : 0)
3086 #define COPYOUT(x) ECALL(_COPYOUT(x))
3087 #define COPYIN(x) ECALL(_COPYIN(x))
3089 static inline const char *drive_name(int type, int drive)
3091 struct floppy_struct *floppy;
3093 if (type)
3094 floppy = floppy_type + type;
3095 else {
3096 if (UDP->native_format)
3097 floppy = floppy_type + UDP->native_format;
3098 else
3099 return "(null)";
3101 if (floppy->name)
3102 return floppy->name;
3103 else
3104 return "(null)";
3107 /* raw commands */
3108 static void raw_cmd_done(int flag)
3110 int i;
3112 if (!flag) {
3113 raw_cmd->flags |= FD_RAW_FAILURE;
3114 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3115 } else {
3116 raw_cmd->reply_count = inr;
3117 if (raw_cmd->reply_count > MAX_REPLIES)
3118 raw_cmd->reply_count = 0;
3119 for (i = 0; i < raw_cmd->reply_count; i++)
3120 raw_cmd->reply[i] = reply_buffer[i];
3122 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3123 unsigned long flags;
3124 flags = claim_dma_lock();
3125 raw_cmd->length = fd_get_dma_residue();
3126 release_dma_lock(flags);
3129 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3130 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3131 raw_cmd->flags |= FD_RAW_FAILURE;
3133 if (disk_change(current_drive))
3134 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3135 else
3136 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3137 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3138 motor_off_callback(current_drive);
3140 if (raw_cmd->next &&
3141 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3142 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3143 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3144 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3145 raw_cmd = raw_cmd->next;
3146 return;
3149 generic_done(flag);
3152 static struct cont_t raw_cmd_cont = {
3153 .interrupt = success_and_wakeup,
3154 .redo = floppy_start,
3155 .error = generic_failure,
3156 .done = raw_cmd_done
3157 };
3159 static inline int raw_cmd_copyout(int cmd, char __user *param,
3160 struct floppy_raw_cmd *ptr)
3162 int ret;
3164 while (ptr) {
3165 COPYOUT(*ptr);
3166 param += sizeof(struct floppy_raw_cmd);
3167 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3168 if (ptr->length >= 0
3169 && ptr->length <= ptr->buffer_length)
3170 ECALL(fd_copyout
3171 (ptr->data, ptr->kernel_data,
3172 ptr->buffer_length - ptr->length));
3174 ptr = ptr->next;
3176 return 0;
3179 static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3181 struct floppy_raw_cmd *next, *this;
3183 this = *ptr;
3184 *ptr = NULL;
3185 while (this) {
3186 if (this->buffer_length) {
3187 fd_dma_mem_free((unsigned long)this->kernel_data,
3188 this->buffer_length);
3189 this->buffer_length = 0;
3191 next = this->next;
3192 kfree(this);
3193 this = next;
3197 static inline int raw_cmd_copyin(int cmd, char __user *param,
3198 struct floppy_raw_cmd **rcmd)
3200 struct floppy_raw_cmd *ptr;
3201 int ret;
3202 int i;
3204 *rcmd = NULL;
3205 while (1) {
3206 ptr = (struct floppy_raw_cmd *)
3207 kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3208 if (!ptr)
3209 return -ENOMEM;
3210 *rcmd = ptr;
3211 COPYIN(*ptr);
3212 ptr->next = NULL;
3213 ptr->buffer_length = 0;
3214 param += sizeof(struct floppy_raw_cmd);
3215 if (ptr->cmd_count > 33)
3216 /* the command may now also take up the space
3217 * initially intended for the reply & the
3218 * reply count. Needed for long 82078 commands
3219 * such as RESTORE, which takes ... 17 command
3220 * bytes. Murphy's law #137: When you reserve
3221 * 16 bytes for a structure, you'll one day
3222 * discover that you really need 17...
3223 */
3224 return -EINVAL;
3226 for (i = 0; i < 16; i++)
3227 ptr->reply[i] = 0;
3228 ptr->resultcode = 0;
3229 ptr->kernel_data = NULL;
3231 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3232 if (ptr->length <= 0)
3233 return -EINVAL;
3234 ptr->kernel_data =
3235 (char *)fd_dma_mem_alloc(ptr->length);
3236 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3237 if (!ptr->kernel_data)
3238 return -ENOMEM;
3239 ptr->buffer_length = ptr->length;
3241 if (ptr->flags & FD_RAW_WRITE)
3242 ECALL(fd_copyin(ptr->data, ptr->kernel_data,
3243 ptr->length));
3244 rcmd = &(ptr->next);
3245 if (!(ptr->flags & FD_RAW_MORE))
3246 return 0;
3247 ptr->rate &= 0x43;
3251 static int raw_cmd_ioctl(int cmd, void __user *param)
3253 int drive, ret, ret2;
3254 struct floppy_raw_cmd *my_raw_cmd;
3256 if (FDCS->rawcmd <= 1)
3257 FDCS->rawcmd = 1;
3258 for (drive = 0; drive < N_DRIVE; drive++) {
3259 if (FDC(drive) != fdc)
3260 continue;
3261 if (drive == current_drive) {
3262 if (UDRS->fd_ref > 1) {
3263 FDCS->rawcmd = 2;
3264 break;
3266 } else if (UDRS->fd_ref) {
3267 FDCS->rawcmd = 2;
3268 break;
3272 if (FDCS->reset)
3273 return -EIO;
3275 ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3276 if (ret) {
3277 raw_cmd_free(&my_raw_cmd);
3278 return ret;
3281 raw_cmd = my_raw_cmd;
3282 cont = &raw_cmd_cont;
3283 ret = wait_til_done(floppy_start, 1);
3284 #ifdef DCL_DEBUG
3285 if (DP->flags & FD_DEBUG) {
3286 DPRINT("calling disk change from raw_cmd ioctl\n");
3288 #endif
3290 if (ret != -EINTR && FDCS->reset)
3291 ret = -EIO;
3293 DRS->track = NO_TRACK;
3295 ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3296 if (!ret)
3297 ret = ret2;
3298 raw_cmd_free(&my_raw_cmd);
3299 return ret;
3302 static int invalidate_drive(struct block_device *bdev)
3304 /* invalidate the buffer track to force a reread */
3305 set_bit((long)bdev->bd_disk->private_data, &fake_change);
3306 process_fd_request();
3307 check_disk_change(bdev);
3308 return 0;
3311 static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
3312 int drive, int type, struct block_device *bdev)
3314 int cnt;
3316 /* sanity checking for parameters. */
3317 if (g->sect <= 0 ||
3318 g->head <= 0 ||
3319 g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3320 /* check if reserved bits are set */
3321 (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_ZEROBASED)) != 0)
3322 return -EINVAL;
3323 if (type) {
3324 if (!capable(CAP_SYS_ADMIN))
3325 return -EPERM;
3326 mutex_lock(&open_lock);
3327 LOCK_FDC(drive, 1);
3328 floppy_type[type] = *g;
3329 floppy_type[type].name = "user format";
3330 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3331 floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3332 floppy_type[type].size + 1;
3333 process_fd_request();
3334 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3335 struct block_device *bdev = opened_bdev[cnt];
3336 if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3337 continue;
3338 __invalidate_device(bdev);
3340 mutex_unlock(&open_lock);
3341 } else {
3342 int oldStretch;
3343 LOCK_FDC(drive, 1);
3344 if (cmd != FDDEFPRM)
3345 /* notice a disk change immediately, else
3346 * we lose our settings immediately*/
3347 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3348 oldStretch = g->stretch;
3349 user_params[drive] = *g;
3350 if (buffer_drive == drive)
3351 SUPBOUND(buffer_max, user_params[drive].sect);
3352 current_type[drive] = &user_params[drive];
3353 floppy_sizes[drive] = user_params[drive].size;
3354 if (cmd == FDDEFPRM)
3355 DRS->keep_data = -1;
3356 else
3357 DRS->keep_data = 1;
3358 /* invalidation. Invalidate only when needed, i.e.
3359 * when there are already sectors in the buffer cache
3360 * whose number will change. This is useful, because
3361 * mtools often changes the geometry of the disk after
3362 * looking at the boot block */
3363 if (DRS->maxblock > user_params[drive].sect ||
3364 DRS->maxtrack ||
3365 ((user_params[drive].sect ^ oldStretch) &
3366 (FD_SWAPSIDES | FD_ZEROBASED)))
3367 invalidate_drive(bdev);
3368 else
3369 process_fd_request();
3371 return 0;
3374 /* handle obsolete ioctl's */
3375 static int ioctl_table[] = {
3376 FDCLRPRM,
3377 FDSETPRM,
3378 FDDEFPRM,
3379 FDGETPRM,
3380 FDMSGON,
3381 FDMSGOFF,
3382 FDFMTBEG,
3383 FDFMTTRK,
3384 FDFMTEND,
3385 FDSETEMSGTRESH,
3386 FDFLUSH,
3387 FDSETMAXERRS,
3388 FDGETMAXERRS,
3389 FDGETDRVTYP,
3390 FDSETDRVPRM,
3391 FDGETDRVPRM,
3392 FDGETDRVSTAT,
3393 FDPOLLDRVSTAT,
3394 FDRESET,
3395 FDGETFDCSTAT,
3396 FDWERRORCLR,
3397 FDWERRORGET,
3398 FDRAWCMD,
3399 FDEJECT,
3400 FDTWADDLE
3401 };
3403 static inline int normalize_ioctl(int *cmd, int *size)
3405 int i;
3407 for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3408 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3409 *size = _IOC_SIZE(*cmd);
3410 *cmd = ioctl_table[i];
3411 if (*size > _IOC_SIZE(*cmd)) {
3412 printk("ioctl not yet supported\n");
3413 return -EFAULT;
3415 return 0;
3418 return -EINVAL;
3421 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3423 if (type)
3424 *g = &floppy_type[type];
3425 else {
3426 LOCK_FDC(drive, 0);
3427 CALL(poll_drive(0, 0));
3428 process_fd_request();
3429 *g = current_type[drive];
3431 if (!*g)
3432 return -ENODEV;
3433 return 0;
3436 static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3438 int drive = (long)bdev->bd_disk->private_data;
3439 int type = ITYPE(drive_state[drive].fd_device);
3440 struct floppy_struct *g;
3441 int ret;
3443 ret = get_floppy_geometry(drive, type, &g);
3444 if (ret)
3445 return ret;
3447 geo->heads = g->head;
3448 geo->sectors = g->sect;
3449 geo->cylinders = g->track;
3450 return 0;
3453 static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
3454 unsigned long param)
3456 #define FD_IOCTL_ALLOWED ((filp) && (filp)->private_data)
3457 #define OUT(c,x) case c: outparam = (const char *) (x); break
3458 #define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
3460 int drive = (long)inode->i_bdev->bd_disk->private_data;
3461 int i, type = ITYPE(UDRS->fd_device);
3462 int ret;
3463 int size;
3464 union inparam {
3465 struct floppy_struct g; /* geometry */
3466 struct format_descr f;
3467 struct floppy_max_errors max_errors;
3468 struct floppy_drive_params dp;
3469 } inparam; /* parameters coming from user space */
3470 const char *outparam; /* parameters passed back to user space */
3472 /* convert compatibility eject ioctls into floppy eject ioctl.
3473 * We do this in order to provide a means to eject floppy disks before
3474 * installing the new fdutils package */
3475 if (cmd == CDROMEJECT || /* CD-ROM eject */
3476 cmd == 0x6470 /* SunOS floppy eject */ ) {
3477 DPRINT("obsolete eject ioctl\n");
3478 DPRINT("please use floppycontrol --eject\n");
3479 cmd = FDEJECT;
3482 /* convert the old style command into a new style command */
3483 if ((cmd & 0xff00) == 0x0200) {
3484 ECALL(normalize_ioctl(&cmd, &size));
3485 } else
3486 return -EINVAL;
3488 /* permission checks */
3489 if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
3490 ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3491 return -EPERM;
3493 /* copyin */
3494 CLEARSTRUCT(&inparam);
3495 if (_IOC_DIR(cmd) & _IOC_WRITE)
3496 ECALL(fd_copyin((void __user *)param, &inparam, size))
3498 switch (cmd) {
3499 case FDEJECT:
3500 if (UDRS->fd_ref != 1)
3501 /* somebody else has this drive open */
3502 return -EBUSY;
3503 LOCK_FDC(drive, 1);
3505 /* do the actual eject. Fails on
3506 * non-Sparc architectures */
3507 ret = fd_eject(UNIT(drive));
3509 USETF(FD_DISK_CHANGED);
3510 USETF(FD_VERIFY);
3511 process_fd_request();
3512 return ret;
3513 case FDCLRPRM:
3514 LOCK_FDC(drive, 1);
3515 current_type[drive] = NULL;
3516 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3517 UDRS->keep_data = 0;
3518 return invalidate_drive(inode->i_bdev);
3519 case FDSETPRM:
3520 case FDDEFPRM:
3521 return set_geometry(cmd, &inparam.g,
3522 drive, type, inode->i_bdev);
3523 case FDGETPRM:
3524 ECALL(get_floppy_geometry(drive, type,
3525 (struct floppy_struct **)
3526 &outparam));
3527 break;
3529 case FDMSGON:
3530 UDP->flags |= FTD_MSG;
3531 return 0;
3532 case FDMSGOFF:
3533 UDP->flags &= ~FTD_MSG;
3534 return 0;
3536 case FDFMTBEG:
3537 LOCK_FDC(drive, 1);
3538 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3539 ret = UDRS->flags;
3540 process_fd_request();
3541 if (ret & FD_VERIFY)
3542 return -ENODEV;
3543 if (!(ret & FD_DISK_WRITABLE))
3544 return -EROFS;
3545 return 0;
3546 case FDFMTTRK:
3547 if (UDRS->fd_ref != 1)
3548 return -EBUSY;
3549 return do_format(drive, &inparam.f);
3550 case FDFMTEND:
3551 case FDFLUSH:
3552 LOCK_FDC(drive, 1);
3553 return invalidate_drive(inode->i_bdev);
3555 case FDSETEMSGTRESH:
3556 UDP->max_errors.reporting =
3557 (unsigned short)(param & 0x0f);
3558 return 0;
3559 OUT(FDGETMAXERRS, &UDP->max_errors);
3560 IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
3562 case FDGETDRVTYP:
3563 outparam = drive_name(type, drive);
3564 SUPBOUND(size, strlen(outparam) + 1);
3565 break;
3567 IN(FDSETDRVPRM, UDP, dp);
3568 OUT(FDGETDRVPRM, UDP);
3570 case FDPOLLDRVSTAT:
3571 LOCK_FDC(drive, 1);
3572 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3573 process_fd_request();
3574 /* fall through */
3575 OUT(FDGETDRVSTAT, UDRS);
3577 case FDRESET:
3578 return user_reset_fdc(drive, (int)param, 1);
3580 OUT(FDGETFDCSTAT, UFDCS);
3582 case FDWERRORCLR:
3583 CLEARSTRUCT(UDRWE);
3584 return 0;
3585 OUT(FDWERRORGET, UDRWE);
3587 case FDRAWCMD:
3588 if (type)
3589 return -EINVAL;
3590 LOCK_FDC(drive, 1);
3591 set_floppy(drive);
3592 CALL(i = raw_cmd_ioctl(cmd, (void __user *)param));
3593 process_fd_request();
3594 return i;
3596 case FDTWADDLE:
3597 LOCK_FDC(drive, 1);
3598 twaddle();
3599 process_fd_request();
3600 return 0;
3602 default:
3603 return -EINVAL;
3606 if (_IOC_DIR(cmd) & _IOC_READ)
3607 return fd_copyout((void __user *)param, outparam, size);
3608 else
3609 return 0;
3610 #undef OUT
3611 #undef IN
3614 static void __init config_types(void)
3616 int first = 1;
3617 int drive;
3619 /* read drive info out of physical CMOS */
3620 drive = 0;
3621 if (!UDP->cmos)
3622 UDP->cmos = FLOPPY0_TYPE;
3623 drive = 1;
3624 if (!UDP->cmos && FLOPPY1_TYPE)
3625 UDP->cmos = FLOPPY1_TYPE;
3627 /* XXX */
3628 /* additional physical CMOS drive detection should go here */
3630 for (drive = 0; drive < N_DRIVE; drive++) {
3631 unsigned int type = UDP->cmos;
3632 struct floppy_drive_params *params;
3633 const char *name = NULL;
3634 static char temparea[32];
3636 if (type < ARRAY_SIZE(default_drive_params)) {
3637 params = &default_drive_params[type].params;
3638 if (type) {
3639 name = default_drive_params[type].name;
3640 allowed_drive_mask |= 1 << drive;
3641 } else
3642 allowed_drive_mask &= ~(1 << drive);
3643 } else {
3644 params = &default_drive_params[0].params;
3645 sprintf(temparea, "unknown type %d (usb?)", type);
3646 name = temparea;
3648 if (name) {
3649 const char *prepend = ",";
3650 if (first) {
3651 prepend = KERN_INFO "Floppy drive(s):";
3652 first = 0;
3654 printk("%s fd%d is %s", prepend, drive, name);
3656 *UDP = *params;
3658 if (!first)
3659 printk("\n");
3662 static int floppy_release(struct inode *inode, struct file *filp)
3664 int drive = (long)inode->i_bdev->bd_disk->private_data;
3666 mutex_lock(&open_lock);
3667 if (UDRS->fd_ref < 0)
3668 UDRS->fd_ref = 0;
3669 else if (!UDRS->fd_ref--) {
3670 DPRINT("floppy_release with fd_ref == 0");
3671 UDRS->fd_ref = 0;
3673 if (!UDRS->fd_ref)
3674 opened_bdev[drive] = NULL;
3675 mutex_unlock(&open_lock);
3677 return 0;
3680 /*
3681 * floppy_open check for aliasing (/dev/fd0 can be the same as
3682 * /dev/PS0 etc), and disallows simultaneous access to the same
3683 * drive with different device numbers.
3684 */
3685 static int floppy_open(struct inode *inode, struct file *filp)
3687 int drive = (long)inode->i_bdev->bd_disk->private_data;
3688 int old_dev;
3689 int try;
3690 int res = -EBUSY;
3691 char *tmp;
3693 filp->private_data = (void *)0;
3694 mutex_lock(&open_lock);
3695 old_dev = UDRS->fd_device;
3696 if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
3697 goto out2;
3699 if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
3700 USETF(FD_DISK_CHANGED);
3701 USETF(FD_VERIFY);
3704 if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
3705 goto out2;
3707 if (filp->f_flags & O_EXCL)
3708 UDRS->fd_ref = -1;
3709 else
3710 UDRS->fd_ref++;
3712 opened_bdev[drive] = inode->i_bdev;
3714 res = -ENXIO;
3716 if (!floppy_track_buffer) {
3717 /* if opening an ED drive, reserve a big buffer,
3718 * else reserve a small one */
3719 if ((UDP->cmos == 6) || (UDP->cmos == 5))
3720 try = 64; /* Only 48 actually useful */
3721 else
3722 try = 32; /* Only 24 actually useful */
3724 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3725 if (!tmp && !floppy_track_buffer) {
3726 try >>= 1; /* buffer only one side */
3727 INFBOUND(try, 16);
3728 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3730 if (!tmp && !floppy_track_buffer) {
3731 fallback_on_nodma_alloc(&tmp, 2048 * try);
3733 if (!tmp && !floppy_track_buffer) {
3734 DPRINT("Unable to allocate DMA memory\n");
3735 goto out;
3737 if (floppy_track_buffer) {
3738 if (tmp)
3739 fd_dma_mem_free((unsigned long)tmp, try * 1024);
3740 } else {
3741 buffer_min = buffer_max = -1;
3742 floppy_track_buffer = tmp;
3743 max_buffer_sectors = try;
3747 UDRS->fd_device = iminor(inode);
3748 set_capacity(disks[drive], floppy_sizes[iminor(inode)]);
3749 if (old_dev != -1 && old_dev != iminor(inode)) {
3750 if (buffer_drive == drive)
3751 buffer_track = -1;
3754 /* Allow ioctls if we have write-permissions even if read-only open.
3755 * Needed so that programs such as fdrawcmd still can work on write
3756 * protected disks */
3757 if ((filp->f_mode & FMODE_WRITE) || !file_permission(filp, MAY_WRITE))
3758 filp->private_data = (void *)8;
3760 if (UFDCS->rawcmd == 1)
3761 UFDCS->rawcmd = 2;
3763 if (!(filp->f_flags & O_NDELAY)) {
3764 if (filp->f_mode & 3) {
3765 UDRS->last_checked = 0;
3766 check_disk_change(inode->i_bdev);
3767 if (UTESTF(FD_DISK_CHANGED))
3768 goto out;
3770 res = -EROFS;
3771 if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
3772 goto out;
3774 mutex_unlock(&open_lock);
3775 return 0;
3776 out:
3777 if (UDRS->fd_ref < 0)
3778 UDRS->fd_ref = 0;
3779 else
3780 UDRS->fd_ref--;
3781 if (!UDRS->fd_ref)
3782 opened_bdev[drive] = NULL;
3783 out2:
3784 mutex_unlock(&open_lock);
3785 return res;
3788 /*
3789 * Check if the disk has been changed or if a change has been faked.
3790 */
3791 static int check_floppy_change(struct gendisk *disk)
3793 int drive = (long)disk->private_data;
3795 if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
3796 return 1;
3798 if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
3799 lock_fdc(drive, 0);
3800 poll_drive(0, 0);
3801 process_fd_request();
3804 if (UTESTF(FD_DISK_CHANGED) ||
3805 UTESTF(FD_VERIFY) ||
3806 test_bit(drive, &fake_change) ||
3807 (!ITYPE(UDRS->fd_device) && !current_type[drive]))
3808 return 1;
3809 return 0;
3812 /*
3813 * This implements "read block 0" for floppy_revalidate().
3814 * Needed for format autodetection, checking whether there is
3815 * a disk in the drive, and whether that disk is writable.
3816 */
3818 static int floppy_rb0_complete(struct bio *bio, unsigned int bytes_done,
3819 int err)
3821 if (bio->bi_size)
3822 return 1;
3824 complete((struct completion *)bio->bi_private);
3825 return 0;
3828 static int __floppy_read_block_0(struct block_device *bdev)
3830 struct bio bio;
3831 struct bio_vec bio_vec;
3832 struct completion complete;
3833 struct page *page;
3834 size_t size;
3836 page = alloc_page(GFP_NOIO);
3837 if (!page) {
3838 process_fd_request();
3839 return -ENOMEM;
3842 size = bdev->bd_block_size;
3843 if (!size)
3844 size = 1024;
3846 bio_init(&bio);
3847 bio.bi_io_vec = &bio_vec;
3848 bio_vec.bv_page = page;
3849 bio_vec.bv_len = size;
3850 bio_vec.bv_offset = 0;
3851 bio.bi_vcnt = 1;
3852 bio.bi_idx = 0;
3853 bio.bi_size = size;
3854 bio.bi_bdev = bdev;
3855 bio.bi_sector = 0;
3856 init_completion(&complete);
3857 bio.bi_private = &complete;
3858 bio.bi_end_io = floppy_rb0_complete;
3860 submit_bio(READ, &bio);
3861 generic_unplug_device(bdev_get_queue(bdev));
3862 process_fd_request();
3863 wait_for_completion(&complete);
3865 __free_page(page);
3867 return 0;
3870 /* revalidate the floppy disk, i.e. trigger format autodetection by reading
3871 * the bootblock (block 0). "Autodetection" is also needed to check whether
3872 * there is a disk in the drive at all... Thus we also do it for fixed
3873 * geometry formats */
3874 static int floppy_revalidate(struct gendisk *disk)
3876 int drive = (long)disk->private_data;
3877 #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
3878 int cf;
3879 int res = 0;
3881 if (UTESTF(FD_DISK_CHANGED) ||
3882 UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
3883 if (usage_count == 0) {
3884 printk("VFS: revalidate called on non-open device.\n");
3885 return -EFAULT;
3887 lock_fdc(drive, 0);
3888 cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
3889 if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
3890 process_fd_request(); /*already done by another thread */
3891 return 0;
3893 UDRS->maxblock = 0;
3894 UDRS->maxtrack = 0;
3895 if (buffer_drive == drive)
3896 buffer_track = -1;
3897 clear_bit(drive, &fake_change);
3898 UCLEARF(FD_DISK_CHANGED);
3899 if (cf)
3900 UDRS->generation++;
3901 if (NO_GEOM) {
3902 /* auto-sensing */
3903 res = __floppy_read_block_0(opened_bdev[drive]);
3904 } else {
3905 if (cf)
3906 poll_drive(0, FD_RAW_NEED_DISK);
3907 process_fd_request();
3910 set_capacity(disk, floppy_sizes[UDRS->fd_device]);
3911 return res;
3914 static struct block_device_operations floppy_fops = {
3915 .owner = THIS_MODULE,
3916 .open = floppy_open,
3917 .release = floppy_release,
3918 .ioctl = fd_ioctl,
3919 .getgeo = fd_getgeo,
3920 .media_changed = check_floppy_change,
3921 .revalidate_disk = floppy_revalidate,
3922 };
3924 /*
3925 * Floppy Driver initialization
3926 * =============================
3927 */
3929 /* Determine the floppy disk controller type */
3930 /* This routine was written by David C. Niemi */
3931 static char __init get_fdc_version(void)
3933 int r;
3935 output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */
3936 if (FDCS->reset)
3937 return FDC_NONE;
3938 if ((r = result()) <= 0x00)
3939 return FDC_NONE; /* No FDC present ??? */
3940 if ((r == 1) && (reply_buffer[0] == 0x80)) {
3941 printk(KERN_INFO "FDC %d is an 8272A\n", fdc);
3942 return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
3944 if (r != 10) {
3945 printk
3946 ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
3947 fdc, r);
3948 return FDC_UNKNOWN;
3951 if (!fdc_configure()) {
3952 printk(KERN_INFO "FDC %d is an 82072\n", fdc);
3953 return FDC_82072; /* 82072 doesn't know CONFIGURE */
3956 output_byte(FD_PERPENDICULAR);
3957 if (need_more_output() == MORE_OUTPUT) {
3958 output_byte(0);
3959 } else {
3960 printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
3961 return FDC_82072A; /* 82072A as found on Sparcs. */
3964 output_byte(FD_UNLOCK);
3965 r = result();
3966 if ((r == 1) && (reply_buffer[0] == 0x80)) {
3967 printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
3968 return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
3969 * LOCK/UNLOCK */
3971 if ((r != 1) || (reply_buffer[0] != 0x00)) {
3972 printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
3973 fdc, r);
3974 return FDC_UNKNOWN;
3976 output_byte(FD_PARTID);
3977 r = result();
3978 if (r != 1) {
3979 printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
3980 fdc, r);
3981 return FDC_UNKNOWN;
3983 if (reply_buffer[0] == 0x80) {
3984 printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);
3985 return FDC_82077; /* Revised 82077AA passes all the tests */
3987 switch (reply_buffer[0] >> 5) {
3988 case 0x0:
3989 /* Either a 82078-1 or a 82078SL running at 5Volt */
3990 printk(KERN_INFO "FDC %d is an 82078.\n", fdc);
3991 return FDC_82078;
3992 case 0x1:
3993 printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);
3994 return FDC_82078;
3995 case 0x2:
3996 printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
3997 return FDC_S82078B;
3998 case 0x3:
3999 printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",
4000 fdc);
4001 return FDC_87306;
4002 default:
4003 printk(KERN_INFO
4004 "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
4005 fdc, reply_buffer[0] >> 5);
4006 return FDC_82078_UNKN;
4008 } /* get_fdc_version */
4010 /* lilo configuration */
4012 static void __init floppy_set_flags(int *ints, int param, int param2)
4014 int i;
4016 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4017 if (param)
4018 default_drive_params[i].params.flags |= param2;
4019 else
4020 default_drive_params[i].params.flags &= ~param2;
4022 DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4025 static void __init daring(int *ints, int param, int param2)
4027 int i;
4029 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4030 if (param) {
4031 default_drive_params[i].params.select_delay = 0;
4032 default_drive_params[i].params.flags |=
4033 FD_SILENT_DCL_CLEAR;
4034 } else {
4035 default_drive_params[i].params.select_delay =
4036 2 * HZ / 100;
4037 default_drive_params[i].params.flags &=
4038 ~FD_SILENT_DCL_CLEAR;
4041 DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4044 static void __init set_cmos(int *ints, int dummy, int dummy2)
4046 int current_drive = 0;
4048 if (ints[0] != 2) {
4049 DPRINT("wrong number of parameters for CMOS\n");
4050 return;
4052 current_drive = ints[1];
4053 if (current_drive < 0 || current_drive >= 8) {
4054 DPRINT("bad drive for set_cmos\n");
4055 return;
4057 #if N_FDC > 1
4058 if (current_drive >= 4 && !FDC2)
4059 FDC2 = 0x370;
4060 #endif
4061 DP->cmos = ints[2];
4062 DPRINT("setting CMOS code to %d\n", ints[2]);
4065 static struct param_table {
4066 const char *name;
4067 void (*fn) (int *ints, int param, int param2);
4068 int *var;
4069 int def_param;
4070 int param2;
4071 } config_params[] __initdata = {
4072 {"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4073 {"all_drives", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4074 {"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
4075 {"irq", NULL, &FLOPPY_IRQ, 6, 0},
4076 {"dma", NULL, &FLOPPY_DMA, 2, 0},
4077 {"daring", daring, NULL, 1, 0},
4078 #if N_FDC > 1
4079 {"two_fdc", NULL, &FDC2, 0x370, 0},
4080 {"one_fdc", NULL, &FDC2, 0, 0},
4081 #endif
4082 {"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
4083 {"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
4084 {"messages", floppy_set_flags, NULL, 1, FTD_MSG},
4085 {"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
4086 {"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
4087 {"nodma", NULL, &can_use_virtual_dma, 1, 0},
4088 {"omnibook", NULL, &can_use_virtual_dma, 1, 0},
4089 {"yesdma", NULL, &can_use_virtual_dma, 0, 0},
4090 {"fifo_depth", NULL, &fifo_depth, 0xa, 0},
4091 {"nofifo", NULL, &no_fifo, 0x20, 0},
4092 {"usefifo", NULL, &no_fifo, 0, 0},
4093 {"cmos", set_cmos, NULL, 0, 0},
4094 {"slow", NULL, &slow_floppy, 1, 0},
4095 {"unexpected_interrupts", NULL, &print_unex, 1, 0},
4096 {"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
4097 {"L40SX", NULL, &print_unex, 0, 0}
4099 EXTRA_FLOPPY_PARAMS
4100 };
4102 static int __init floppy_setup(char *str)
4104 int i;
4105 int param;
4106 int ints[11];
4108 str = get_options(str, ARRAY_SIZE(ints), ints);
4109 if (str) {
4110 for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4111 if (strcmp(str, config_params[i].name) == 0) {
4112 if (ints[0])
4113 param = ints[1];
4114 else
4115 param = config_params[i].def_param;
4116 if (config_params[i].fn)
4117 config_params[i].
4118 fn(ints, param,
4119 config_params[i].param2);
4120 if (config_params[i].var) {
4121 DPRINT("%s=%d\n", str, param);
4122 *config_params[i].var = param;
4124 return 1;
4128 if (str) {
4129 DPRINT("unknown floppy option [%s]\n", str);
4131 DPRINT("allowed options are:");
4132 for (i = 0; i < ARRAY_SIZE(config_params); i++)
4133 printk(" %s", config_params[i].name);
4134 printk("\n");
4135 } else
4136 DPRINT("botched floppy option\n");
4137 DPRINT("Read Documentation/floppy.txt\n");
4138 return 0;
4141 static int have_no_fdc = -ENODEV;
4143 static ssize_t floppy_cmos_show(struct device *dev,
4144 struct device_attribute *attr, char *buf)
4146 struct platform_device *p;
4147 int drive;
4149 p = container_of(dev, struct platform_device,dev);
4150 drive = p->id;
4151 return sprintf(buf, "%X\n", UDP->cmos);
4153 DEVICE_ATTR(cmos,S_IRUGO,floppy_cmos_show,NULL);
4155 static void floppy_device_release(struct device *dev)
4157 complete(&device_release);
4160 static struct platform_device floppy_device[N_DRIVE];
4162 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4164 int drive = (*part & 3) | ((*part & 0x80) >> 5);
4165 if (drive >= N_DRIVE ||
4166 !(allowed_drive_mask & (1 << drive)) ||
4167 fdc_state[FDC(drive)].version == FDC_NONE)
4168 return NULL;
4169 if (((*part >> 2) & 0x1f) >= ARRAY_SIZE(floppy_type))
4170 return NULL;
4171 *part = 0;
4172 return get_disk(disks[drive]);
4175 static int __init floppy_init(void)
4177 int i, unit, drive;
4178 int err, dr;
4180 #if defined(CONFIG_PPC_MERGE)
4181 if (check_legacy_ioport(FDC1))
4182 return -ENODEV;
4183 #endif
4185 raw_cmd = NULL;
4187 for (dr = 0; dr < N_DRIVE; dr++) {
4188 disks[dr] = alloc_disk(1);
4189 if (!disks[dr]) {
4190 err = -ENOMEM;
4191 goto out_put_disk;
4194 disks[dr]->major = FLOPPY_MAJOR;
4195 disks[dr]->first_minor = TOMINOR(dr);
4196 disks[dr]->fops = &floppy_fops;
4197 sprintf(disks[dr]->disk_name, "fd%d", dr);
4199 init_timer(&motor_off_timer[dr]);
4200 motor_off_timer[dr].data = dr;
4201 motor_off_timer[dr].function = motor_off_callback;
4204 err = register_blkdev(FLOPPY_MAJOR, "fd");
4205 if (err)
4206 goto out_put_disk;
4208 floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
4209 if (!floppy_queue) {
4210 err = -ENOMEM;
4211 goto out_unreg_blkdev;
4213 blk_queue_max_sectors(floppy_queue, 64);
4215 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4216 floppy_find, NULL, NULL);
4218 for (i = 0; i < 256; i++)
4219 if (ITYPE(i))
4220 floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4221 else
4222 floppy_sizes[i] = MAX_DISK_SIZE << 1;
4224 reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
4225 config_types();
4227 for (i = 0; i < N_FDC; i++) {
4228 fdc = i;
4229 CLEARSTRUCT(FDCS);
4230 FDCS->dtr = -1;
4231 FDCS->dor = 0x4;
4232 #if defined(__sparc__) || defined(__mc68000__)
4233 /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
4234 #ifdef __mc68000__
4235 if (MACH_IS_SUN3X)
4236 #endif
4237 FDCS->version = FDC_82072A;
4238 #endif
4241 use_virtual_dma = can_use_virtual_dma & 1;
4242 fdc_state[0].address = FDC1;
4243 if (fdc_state[0].address == -1) {
4244 del_timer(&fd_timeout);
4245 err = -ENODEV;
4246 goto out_unreg_region;
4248 #if N_FDC > 1
4249 fdc_state[1].address = FDC2;
4250 #endif
4252 fdc = 0; /* reset fdc in case of unexpected interrupt */
4253 err = floppy_grab_irq_and_dma();
4254 if (err) {
4255 del_timer(&fd_timeout);
4256 err = -EBUSY;
4257 goto out_unreg_region;
4260 /* initialise drive state */
4261 for (drive = 0; drive < N_DRIVE; drive++) {
4262 CLEARSTRUCT(UDRS);
4263 CLEARSTRUCT(UDRWE);
4264 USETF(FD_DISK_NEWCHANGE);
4265 USETF(FD_DISK_CHANGED);
4266 USETF(FD_VERIFY);
4267 UDRS->fd_device = -1;
4268 floppy_track_buffer = NULL;
4269 max_buffer_sectors = 0;
4271 /*
4272 * Small 10 msec delay to let through any interrupt that
4273 * initialization might have triggered, to not
4274 * confuse detection:
4275 */
4276 msleep(10);
4278 for (i = 0; i < N_FDC; i++) {
4279 fdc = i;
4280 FDCS->driver_version = FD_DRIVER_VERSION;
4281 for (unit = 0; unit < 4; unit++)
4282 FDCS->track[unit] = 0;
4283 if (FDCS->address == -1)
4284 continue;
4285 FDCS->rawcmd = 2;
4286 if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
4287 /* free ioports reserved by floppy_grab_irq_and_dma() */
4288 release_region(FDCS->address + 2, 4);
4289 release_region(FDCS->address + 7, 1);
4290 FDCS->address = -1;
4291 FDCS->version = FDC_NONE;
4292 continue;
4294 /* Try to determine the floppy controller type */
4295 FDCS->version = get_fdc_version();
4296 if (FDCS->version == FDC_NONE) {
4297 /* free ioports reserved by floppy_grab_irq_and_dma() */
4298 release_region(FDCS->address + 2, 4);
4299 release_region(FDCS->address + 7, 1);
4300 FDCS->address = -1;
4301 continue;
4303 if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
4304 can_use_virtual_dma = 0;
4306 have_no_fdc = 0;
4307 /* Not all FDCs seem to be able to handle the version command
4308 * properly, so force a reset for the standard FDC clones,
4309 * to avoid interrupt garbage.
4310 */
4311 user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
4313 fdc = 0;
4314 del_timer(&fd_timeout);
4315 current_drive = 0;
4316 initialising = 0;
4317 if (have_no_fdc) {
4318 DPRINT("no floppy controllers found\n");
4319 err = have_no_fdc;
4320 goto out_flush_work;
4323 for (drive = 0; drive < N_DRIVE; drive++) {
4324 if (!(allowed_drive_mask & (1 << drive)))
4325 continue;
4326 if (fdc_state[FDC(drive)].version == FDC_NONE)
4327 continue;
4329 floppy_device[drive].name = floppy_device_name;
4330 floppy_device[drive].id = drive;
4331 floppy_device[drive].dev.release = floppy_device_release;
4333 err = platform_device_register(&floppy_device[drive]);
4334 if (err)
4335 goto out_flush_work;
4337 device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
4338 /* to be cleaned up... */
4339 disks[drive]->private_data = (void *)(long)drive;
4340 disks[drive]->queue = floppy_queue;
4341 disks[drive]->flags |= GENHD_FL_REMOVABLE;
4342 disks[drive]->driverfs_dev = &floppy_device[drive].dev;
4343 add_disk(disks[drive]);
4346 return 0;
4348 out_flush_work:
4349 flush_scheduled_work();
4350 if (usage_count)
4351 floppy_release_irq_and_dma();
4352 out_unreg_region:
4353 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4354 blk_cleanup_queue(floppy_queue);
4355 out_unreg_blkdev:
4356 unregister_blkdev(FLOPPY_MAJOR, "fd");
4357 out_put_disk:
4358 while (dr--) {
4359 del_timer(&motor_off_timer[dr]);
4360 put_disk(disks[dr]);
4362 return err;
4365 static DEFINE_SPINLOCK(floppy_usage_lock);
4367 static int floppy_grab_irq_and_dma(void)
4369 unsigned long flags;
4371 spin_lock_irqsave(&floppy_usage_lock, flags);
4372 if (usage_count++) {
4373 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4374 return 0;
4376 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4378 /*
4379 * We might have scheduled a free_irq(), wait it to
4380 * drain first:
4381 */
4382 flush_scheduled_work();
4384 if (fd_request_irq()) {
4385 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4386 FLOPPY_IRQ);
4387 spin_lock_irqsave(&floppy_usage_lock, flags);
4388 usage_count--;
4389 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4390 return -1;
4392 if (fd_request_dma()) {
4393 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4394 FLOPPY_DMA);
4395 if (can_use_virtual_dma & 2)
4396 use_virtual_dma = can_use_virtual_dma = 1;
4397 if (!(can_use_virtual_dma & 1)) {
4398 fd_free_irq();
4399 spin_lock_irqsave(&floppy_usage_lock, flags);
4400 usage_count--;
4401 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4402 return -1;
4406 for (fdc = 0; fdc < N_FDC; fdc++) {
4407 if (FDCS->address != -1) {
4408 if (!request_region(FDCS->address + 2, 4, "floppy")) {
4409 DPRINT("Floppy io-port 0x%04lx in use\n",
4410 FDCS->address + 2);
4411 goto cleanup1;
4413 if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
4414 DPRINT("Floppy io-port 0x%04lx in use\n",
4415 FDCS->address + 7);
4416 goto cleanup2;
4418 /* address + 6 is reserved, and may be taken by IDE.
4419 * Unfortunately, Adaptec doesn't know this :-(, */
4422 for (fdc = 0; fdc < N_FDC; fdc++) {
4423 if (FDCS->address != -1) {
4424 reset_fdc_info(1);
4425 fd_outb(FDCS->dor, FD_DOR);
4428 fdc = 0;
4429 set_dor(0, ~0, 8); /* avoid immediate interrupt */
4431 for (fdc = 0; fdc < N_FDC; fdc++)
4432 if (FDCS->address != -1)
4433 fd_outb(FDCS->dor, FD_DOR);
4434 /*
4435 * The driver will try and free resources and relies on us
4436 * to know if they were allocated or not.
4437 */
4438 fdc = 0;
4439 irqdma_allocated = 1;
4440 return 0;
4441 cleanup2:
4442 release_region(FDCS->address + 2, 4);
4443 cleanup1:
4444 fd_free_irq();
4445 fd_free_dma();
4446 while (--fdc >= 0) {
4447 release_region(FDCS->address + 2, 4);
4448 release_region(FDCS->address + 7, 1);
4450 spin_lock_irqsave(&floppy_usage_lock, flags);
4451 usage_count--;
4452 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4453 return -1;
4456 static void floppy_release_irq_and_dma(void)
4458 int old_fdc;
4459 #ifdef FLOPPY_SANITY_CHECK
4460 #ifndef __sparc__
4461 int drive;
4462 #endif
4463 #endif
4464 long tmpsize;
4465 unsigned long tmpaddr;
4466 unsigned long flags;
4468 spin_lock_irqsave(&floppy_usage_lock, flags);
4469 if (--usage_count) {
4470 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4471 return;
4473 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4474 if (irqdma_allocated) {
4475 fd_disable_dma();
4476 fd_free_dma();
4477 fd_free_irq();
4478 irqdma_allocated = 0;
4480 set_dor(0, ~0, 8);
4481 #if N_FDC > 1
4482 set_dor(1, ~8, 0);
4483 #endif
4484 floppy_enable_hlt();
4486 if (floppy_track_buffer && max_buffer_sectors) {
4487 tmpsize = max_buffer_sectors * 1024;
4488 tmpaddr = (unsigned long)floppy_track_buffer;
4489 floppy_track_buffer = NULL;
4490 max_buffer_sectors = 0;
4491 buffer_min = buffer_max = -1;
4492 fd_dma_mem_free(tmpaddr, tmpsize);
4494 #ifdef FLOPPY_SANITY_CHECK
4495 #ifndef __sparc__
4496 for (drive = 0; drive < N_FDC * 4; drive++)
4497 if (timer_pending(motor_off_timer + drive))
4498 printk("motor off timer %d still active\n", drive);
4499 #endif
4501 if (timer_pending(&fd_timeout))
4502 printk("floppy timer still active:%s\n", timeout_message);
4503 if (timer_pending(&fd_timer))
4504 printk("auxiliary floppy timer still active\n");
4505 if (floppy_work.pending)
4506 printk("work still pending\n");
4507 #endif
4508 old_fdc = fdc;
4509 for (fdc = 0; fdc < N_FDC; fdc++)
4510 if (FDCS->address != -1) {
4511 release_region(FDCS->address + 2, 4);
4512 release_region(FDCS->address + 7, 1);
4514 fdc = old_fdc;
4517 #ifdef MODULE
4519 static char *floppy;
4521 static void __init parse_floppy_cfg_string(char *cfg)
4523 char *ptr;
4525 while (*cfg) {
4526 for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != '\t'; cfg++) ;
4527 if (*cfg) {
4528 *cfg = '\0';
4529 cfg++;
4531 if (*ptr)
4532 floppy_setup(ptr);
4536 int __init init_module(void)
4538 if (floppy)
4539 parse_floppy_cfg_string(floppy);
4540 return floppy_init();
4543 void cleanup_module(void)
4545 int drive;
4547 init_completion(&device_release);
4548 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4549 unregister_blkdev(FLOPPY_MAJOR, "fd");
4551 for (drive = 0; drive < N_DRIVE; drive++) {
4552 del_timer_sync(&motor_off_timer[drive]);
4554 if ((allowed_drive_mask & (1 << drive)) &&
4555 fdc_state[FDC(drive)].version != FDC_NONE) {
4556 del_gendisk(disks[drive]);
4557 device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
4558 platform_device_unregister(&floppy_device[drive]);
4560 put_disk(disks[drive]);
4563 del_timer_sync(&fd_timeout);
4564 del_timer_sync(&fd_timer);
4565 blk_cleanup_queue(floppy_queue);
4567 if (usage_count)
4568 floppy_release_irq_and_dma();
4570 /* eject disk, if any */
4571 fd_eject(0);
4573 wait_for_completion(&device_release);
4576 module_param(floppy, charp, 0);
4577 module_param(FLOPPY_IRQ, int, 0);
4578 module_param(FLOPPY_DMA, int, 0);
4579 MODULE_AUTHOR("Alain L. Knaff");
4580 MODULE_SUPPORTED_DEVICE("fd");
4581 MODULE_LICENSE("GPL");
4583 #else
4585 __setup("floppy=", floppy_setup);
4586 module_init(floppy_init)
4587 #endif
4589 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);