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