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