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