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