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