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