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