projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drivers/block/floppy.c: remove REPEAT macro
[deliverable/linux.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
671static void __reschedule_timeout(int drive, const char *message, int marg)
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)
b46df356 683 DPRINT("reschedule timeout %s %d\n", message, marg);
1da177e4
LT		 684 timeout_message = message;
685}
686
687static void reschedule_timeout(int drive, const char *message, int marg)
688{
689 unsigned long flags;
690
691 spin_lock_irqsave(&floppy_lock, flags);
692 __reschedule_timeout(drive, message, marg);
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
903 __reschedule_timeout(drive, "lock fdc", 0);
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{
1986 reschedule_timeout(current_reqD, "floppy start", 0);
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{
2010 reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
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;
2309
2310 probing = 0;
b46df356 2311 reschedule_timeout(MAXTIMEOUT, "request done", uptodate);
1da177e4
LT		 2312
2313 if (!req) {
b46df356 2314 pr_info("floppy.c: no request in request_done\n");
1da177e4
LT		 2315 return;
2316 }
2317
2318 if (uptodate) {
2319 /* maintain values for invalidation on geometry
2320 * change */
83096ebf 2321 block = current_count_sectors + blk_rq_pos(req);
1da177e4
LT		 2322 INFBOUND(DRS->maxblock, block);
2323 if (block > _floppy->sect)
2324 DRS->maxtrack = 1;
2325
2326 /* unlock chained buffers */
2327 spin_lock_irqsave(q->queue_lock, flags);
1c5093ba 2328 floppy_end_request(req, 0);
1da177e4
LT		 2329 spin_unlock_irqrestore(q->queue_lock, flags);
2330 } else {
2331 if (rq_data_dir(req) == WRITE) {
2332 /* record write error information */
2333 DRWE->write_errors++;
2334 if (DRWE->write_errors == 1) {
83096ebf 2335 DRWE->first_error_sector = blk_rq_pos(req);
1da177e4
LT		 2336 DRWE->first_error_generation = DRS->generation;
2337 }
83096ebf 2338 DRWE->last_error_sector = blk_rq_pos(req);
1da177e4
LT		 2339 DRWE->last_error_generation = DRS->generation;
2340 }
2341 spin_lock_irqsave(q->queue_lock, flags);
1c5093ba 2342 floppy_end_request(req, -EIO);
1da177e4
LT		 2343 spin_unlock_irqrestore(q->queue_lock, flags);
2344 }
2345}
2346
2347/* Interrupt handler evaluating the result of the r/w operation */
2348static void rw_interrupt(void)
2349{
06f748c4
JJ		 2350 int eoc;
2351 int ssize;
2352 int heads;
2353 int nr_sectors;
1da177e4
LT		 2354
2355 if (R_HEAD >= 2) {
2356 /* some Toshiba floppy controllers occasionnally seem to
2357 * return bogus interrupts after read/write operations, which
2358 * can be recognized by a bad head number (>= 2) */
2359 return;
2360 }
2361
2362 if (!DRS->first_read_date)
2363 DRS->first_read_date = jiffies;
2364
2365 nr_sectors = 0;
2366 CODE2SIZE;
2367
2368 if (ST1 & ST1_EOC)
2369 eoc = 1;
2370 else
2371 eoc = 0;
2372
2373 if (COMMAND & 0x80)
2374 heads = 2;
2375 else
2376 heads = 1;
2377
2378 nr_sectors = (((R_TRACK - TRACK) * heads +
2379 R_HEAD - HEAD) * SECT_PER_TRACK +
2380 R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2381
2382#ifdef FLOPPY_SANITY_CHECK
2383 if (nr_sectors / ssize >
061837bc 2384 DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {
1da177e4
LT		 2385 DPRINT("long rw: %x instead of %lx\n",
2386 nr_sectors, current_count_sectors);
b46df356
JP		 2387 pr_info("rs=%d s=%d\n", R_SECTOR, SECTOR);
2388 pr_info("rh=%d h=%d\n", R_HEAD, HEAD);
2389 pr_info("rt=%d t=%d\n", R_TRACK, TRACK);
2390 pr_info("heads=%d eoc=%d\n", heads, eoc);
2391 pr_info("spt=%d st=%d ss=%d\n",
2392 SECT_PER_TRACK, fsector_t, ssize);
2393 pr_info("in_sector_offset=%d\n", in_sector_offset);
1da177e4
LT		 2394 }
2395#endif
2396
2397 nr_sectors -= in_sector_offset;
2398 INFBOUND(nr_sectors, 0);
2399 SUPBOUND(current_count_sectors, nr_sectors);
2400
2401 switch (interpret_errors()) {
2402 case 2:
2403 cont->redo();
2404 return;
2405 case 1:
2406 if (!current_count_sectors) {
2407 cont->error();
2408 cont->redo();
2409 return;
2410 }
2411 break;
2412 case 0:
2413 if (!current_count_sectors) {
2414 cont->redo();
2415 return;
2416 }
2417 current_type[current_drive] = _floppy;
2418 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2419 break;
2420 }
2421
2422 if (probing) {
2423 if (DP->flags & FTD_MSG)
2424 DPRINT("Auto-detected floppy type %s in fd%d\n",
2425 _floppy->name, current_drive);
2426 current_type[current_drive] = _floppy;
2427 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2428 probing = 0;
2429 }
2430
2431 if (CT(COMMAND) != FD_READ ||
2432 raw_cmd->kernel_data == current_req->buffer) {
2433 /* transfer directly from buffer */
2434 cont->done(1);
2435 } else if (CT(COMMAND) == FD_READ) {
2436 buffer_track = raw_cmd->track;
2437 buffer_drive = current_drive;
2438 INFBOUND(buffer_max, nr_sectors + fsector_t);
2439 }
2440 cont->redo();
2441}
2442
2443/* Compute maximal contiguous buffer size. */
2444static int buffer_chain_size(void)
2445{
1da177e4 2446 struct bio_vec *bv;
5705f702
N		 2447 int size;
2448 struct req_iterator iter;
1da177e4
LT		 2449 char *base;
2450
2451 base = bio_data(current_req->bio);
2452 size = 0;
2453
5705f702
N		 2454 rq_for_each_segment(bv, current_req, iter) {
2455 if (page_address(bv->bv_page) + bv->bv_offset != base + size)
2456 break;
1da177e4 2457
5705f702 2458 size += bv->bv_len;
1da177e4
LT		 2459 }
2460
2461 return size >> 9;
2462}
2463
2464/* Compute the maximal transfer size */
2465static int transfer_size(int ssize, int max_sector, int max_size)
2466{
2467 SUPBOUND(max_sector, fsector_t + max_size);
2468
2469 /* alignment */
2470 max_sector -= (max_sector % _floppy->sect) % ssize;
2471
2472 /* transfer size, beginning not aligned */
2473 current_count_sectors = max_sector - fsector_t;
2474
2475 return max_sector;
2476}
2477
2478/*
2479 * Move data from/to the track buffer to/from the buffer cache.
2480 */
2481static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2482{
2483 int remaining; /* number of transferred 512-byte sectors */
2484 struct bio_vec *bv;
06f748c4
JJ		 2485 char *buffer;
2486 char *dma_buffer;
5705f702
N		 2487 int size;
2488 struct req_iterator iter;
1da177e4
LT		 2489
2490 max_sector = transfer_size(ssize,
2491 min(max_sector, max_sector_2),
83096ebf 2492 blk_rq_sectors(current_req));
1da177e4
LT		 2493
2494 if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
83096ebf 2495 buffer_max > fsector_t + blk_rq_sectors(current_req))
1da177e4 2496 current_count_sectors = min_t(int, buffer_max - fsector_t,
83096ebf 2497 blk_rq_sectors(current_req));
1da177e4
LT		 2498
2499 remaining = current_count_sectors << 9;
2500#ifdef FLOPPY_SANITY_CHECK
1011c1b9 2501 if (remaining > blk_rq_bytes(current_req) && CT(COMMAND) == FD_WRITE) {
1da177e4 2502 DPRINT("in copy buffer\n");
b46df356
JP		 2503 pr_info("current_count_sectors=%ld\n", current_count_sectors);
2504 pr_info("remaining=%d\n", remaining >> 9);
2505 pr_info("current_req->nr_sectors=%u\n",
2506 blk_rq_sectors(current_req));
2507 pr_info("current_req->current_nr_sectors=%u\n",
2508 blk_rq_cur_sectors(current_req));
2509 pr_info("max_sector=%d\n", max_sector);
2510 pr_info("ssize=%d\n", ssize);
1da177e4
LT		 2511 }
2512#endif
2513
2514 buffer_max = max(max_sector, buffer_max);
2515
2516 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2517
1011c1b9 2518 size = blk_rq_cur_bytes(current_req);
1da177e4 2519
5705f702
N		 2520 rq_for_each_segment(bv, current_req, iter) {
2521 if (!remaining)
2522 break;
1da177e4 2523
5705f702
N		 2524 size = bv->bv_len;
2525 SUPBOUND(size, remaining);
1da177e4 2526
5705f702 2527 buffer = page_address(bv->bv_page) + bv->bv_offset;
1da177e4 2528#ifdef FLOPPY_SANITY_CHECK
5705f702
N		 2529 if (dma_buffer + size >
2530 floppy_track_buffer + (max_buffer_sectors << 10) ||
2531 dma_buffer < floppy_track_buffer) {
2532 DPRINT("buffer overrun in copy buffer %d\n",
b46df356
JP		 2533 (int)((floppy_track_buffer - dma_buffer) >> 9));
2534 pr_info("fsector_t=%d buffer_min=%d\n",
2535 fsector_t, buffer_min);
2536 pr_info("current_count_sectors=%ld\n",
2537 current_count_sectors);
1da177e4 2538 if (CT(COMMAND) == FD_READ)
b46df356 2539 pr_info("read\n");
5705f702 2540 if (CT(COMMAND) == FD_WRITE)
b46df356 2541 pr_info("write\n");
5705f702 2542 break;
1da177e4 2543 }
5705f702
N		 2544 if (((unsigned long)buffer) % 512)
2545 DPRINT("%p buffer not aligned\n", buffer);
2546#endif
2547 if (CT(COMMAND) == FD_READ)
2548 memcpy(buffer, dma_buffer, size);
2549 else
2550 memcpy(dma_buffer, buffer, size);
2551
2552 remaining -= size;
2553 dma_buffer += size;
1da177e4
LT		 2554 }
2555#ifdef FLOPPY_SANITY_CHECK
2556 if (remaining) {
2557 if (remaining > 0)
2558 max_sector -= remaining >> 9;
2559 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2560 }
2561#endif
2562}
2563
1da177e4
LT		 2564/* work around a bug in pseudo DMA
2565 * (on some FDCs) pseudo DMA does not stop when the CPU stops
2566 * sending data. Hence we need a different way to signal the
2567 * transfer length: We use SECT_PER_TRACK. Unfortunately, this
2568 * does not work with MT, hence we can only transfer one head at
2569 * a time
2570 */
2571static void virtualdmabug_workaround(void)
2572{
06f748c4
JJ		 2573 int hard_sectors;
2574 int end_sector;
1da177e4
LT		 2575
2576 if (CT(COMMAND) == FD_WRITE) {
2577 COMMAND &= ~0x80; /* switch off multiple track mode */
2578
2579 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2580 end_sector = SECTOR + hard_sectors - 1;
2581#ifdef FLOPPY_SANITY_CHECK
2582 if (end_sector > SECT_PER_TRACK) {
b46df356
JP		 2583 pr_info("too many sectors %d > %d\n",
2584 end_sector, SECT_PER_TRACK);
1da177e4
LT		 2585 return;
2586 }
2587#endif
48c8cee6
JP		 2588 SECT_PER_TRACK = end_sector;
2589 /* make sure SECT_PER_TRACK
2590 * points to end of transfer */
1da177e4
LT		 2591 }
2592}
2593
2594/*
2595 * Formulate a read/write request.
2596 * this routine decides where to load the data (directly to buffer, or to
2597 * tmp floppy area), how much data to load (the size of the buffer, the whole
2598 * track, or a single sector)
2599 * All floppy_track_buffer handling goes in here. If we ever add track buffer
2600 * allocation on the fly, it should be done here. No other part should need
2601 * modification.
2602 */
2603
2604static int make_raw_rw_request(void)
2605{
2606 int aligned_sector_t;
06f748c4
JJ		 2607 int max_sector;
2608 int max_size;
2609 int tracksize;
2610 int ssize;
1da177e4
LT		 2611
2612 if (max_buffer_sectors == 0) {
b46df356 2613 pr_info("VFS: Block I/O scheduled on unopened device\n");
1da177e4
LT		 2614 return 0;
2615 }
2616
2617 set_fdc((long)current_req->rq_disk->private_data);
2618
2619 raw_cmd = &default_raw_cmd;
2620 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2621 FD_RAW_NEED_SEEK;
2622 raw_cmd->cmd_count = NR_RW;
2623 if (rq_data_dir(current_req) == READ) {
2624 raw_cmd->flags |= FD_RAW_READ;
2625 COMMAND = FM_MODE(_floppy, FD_READ);
2626 } else if (rq_data_dir(current_req) == WRITE) {
2627 raw_cmd->flags |= FD_RAW_WRITE;
2628 COMMAND = FM_MODE(_floppy, FD_WRITE);
2629 } else {
2630 DPRINT("make_raw_rw_request: unknown command\n");
2631 return 0;
2632 }
2633
2634 max_sector = _floppy->sect * _floppy->head;
2635
83096ebf
TH		 2636 TRACK = (int)blk_rq_pos(current_req) / max_sector;
2637 fsector_t = (int)blk_rq_pos(current_req) % max_sector;
1da177e4 2638 if (_floppy->track && TRACK >= _floppy->track) {
83096ebf 2639 if (blk_rq_cur_sectors(current_req) & 1) {
1da177e4
LT		 2640 current_count_sectors = 1;
2641 return 1;
2642 } else
2643 return 0;
2644 }
2645 HEAD = fsector_t / _floppy->sect;
2646
9e49184c 2647 if (((_floppy->stretch & (FD_SWAPSIDES | FD_SECTBASEMASK)) ||
e0298536
JP		 2648 test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags)) &&
2649 fsector_t < _floppy->sect)
1da177e4
LT		 2650 max_sector = _floppy->sect;
2651
2652 /* 2M disks have phantom sectors on the first track */
2653 if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2654 max_sector = 2 * _floppy->sect / 3;
2655 if (fsector_t >= max_sector) {
2656 current_count_sectors =
2657 min_t(int, _floppy->sect - fsector_t,
83096ebf 2658 blk_rq_sectors(current_req));
1da177e4
LT		 2659 return 1;
2660 }
2661 SIZECODE = 2;
2662 } else
2663 SIZECODE = FD_SIZECODE(_floppy);
2664 raw_cmd->rate = _floppy->rate & 0x43;
2665 if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2666 raw_cmd->rate = 1;
2667
2668 if (SIZECODE)
2669 SIZECODE2 = 0xff;
2670 else
2671 SIZECODE2 = 0x80;
2672 raw_cmd->track = TRACK << STRETCH(_floppy);
2673 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2674 GAP = _floppy->gap;
2675 CODE2SIZE;
2676 SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2677 SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
9e49184c 2678 FD_SECTBASE(_floppy);
1da177e4
LT		 2679
2680 /* tracksize describes the size which can be filled up with sectors
2681 * of size ssize.
2682 */
2683 tracksize = _floppy->sect - _floppy->sect % ssize;
2684 if (tracksize < _floppy->sect) {
2685 SECT_PER_TRACK++;
2686 if (tracksize <= fsector_t % _floppy->sect)
2687 SECTOR--;
2688
2689 /* if we are beyond tracksize, fill up using smaller sectors */
2690 while (tracksize <= fsector_t % _floppy->sect) {
2691 while (tracksize + ssize > _floppy->sect) {
2692 SIZECODE--;
2693 ssize >>= 1;
2694 }
2695 SECTOR++;
2696 SECT_PER_TRACK++;
2697 tracksize += ssize;
2698 }
2699 max_sector = HEAD * _floppy->sect + tracksize;
2700 } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2701 max_sector = _floppy->sect;
2702 } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2703 /* for virtual DMA bug workaround */
2704 max_sector = _floppy->sect;
2705 }
2706
2707 in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2708 aligned_sector_t = fsector_t - in_sector_offset;
83096ebf 2709 max_size = blk_rq_sectors(current_req);
1da177e4
LT		 2710 if ((raw_cmd->track == buffer_track) &&
2711 (current_drive == buffer_drive) &&
2712 (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2713 /* data already in track buffer */
2714 if (CT(COMMAND) == FD_READ) {
2715 copy_buffer(1, max_sector, buffer_max);
2716 return 1;
2717 }
83096ebf 2718 } else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {
1da177e4 2719 if (CT(COMMAND) == FD_WRITE) {
d7b2b2ec
JP		 2720 unsigned int sectors;
2721
2722 sectors = fsector_t + blk_rq_sectors(current_req);
2723 if (sectors > ssize && sectors < ssize + ssize)
1da177e4
LT		 2724 max_size = ssize + ssize;
2725 else
2726 max_size = ssize;
2727 }
2728 raw_cmd->flags &= ~FD_RAW_WRITE;
2729 raw_cmd->flags |= FD_RAW_READ;
2730 COMMAND = FM_MODE(_floppy, FD_READ);
2731 } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2732 unsigned long dma_limit;
2733 int direct, indirect;
2734
2735 indirect =
2736 transfer_size(ssize, max_sector,
2737 max_buffer_sectors * 2) - fsector_t;
2738
2739 /*
2740 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2741 * on a 64 bit machine!
2742 */
2743 max_size = buffer_chain_size();
d7b2b2ec
JP		 2744 dma_limit = (MAX_DMA_ADDRESS -
2745 ((unsigned long)current_req->buffer)) >> 9;
a81ee544 2746 if ((unsigned long)max_size > dma_limit)
1da177e4 2747 max_size = dma_limit;
1da177e4
LT		 2748 /* 64 kb boundaries */
2749 if (CROSS_64KB(current_req->buffer, max_size << 9))
2750 max_size = (K_64 -
2751 ((unsigned long)current_req->buffer) %
2752 K_64) >> 9;
2753 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2754 /*
2755 * We try to read tracks, but if we get too many errors, we
2756 * go back to reading just one sector at a time.
2757 *
2758 * This means we should be able to read a sector even if there
2759 * are other bad sectors on this track.
2760 */
2761 if (!direct ||
2762 (indirect * 2 > direct * 3 &&
d7b2b2ec
JP		 2763 *errors < DP->max_errors.read_track &&
2764 ((!probing ||
2765 (DP->read_track & (1 << DRS->probed_format)))))) {
83096ebf 2766 max_size = blk_rq_sectors(current_req);
1da177e4
LT		 2767 } else {
2768 raw_cmd->kernel_data = current_req->buffer;
2769 raw_cmd->length = current_count_sectors << 9;
2770 if (raw_cmd->length == 0) {
d7b2b2ec
JP		 2771 DPRINT("zero dma transfer attempted from make_raw_request\n");
2772 DPRINT("indirect=%d direct=%d fsector_t=%d\n",
1da177e4
LT		 2773 indirect, direct, fsector_t);
2774 return 0;
2775 }
1da177e4
LT		 2776 virtualdmabug_workaround();
2777 return 2;
2778 }
2779 }
2780
2781 if (CT(COMMAND) == FD_READ)
2782 max_size = max_sector; /* unbounded */
2783
2784 /* claim buffer track if needed */
2785 if (buffer_track != raw_cmd->track || /* bad track */
2786 buffer_drive != current_drive || /* bad drive */
2787 fsector_t > buffer_max ||
2788 fsector_t < buffer_min ||
2789 ((CT(COMMAND) == FD_READ ||
83096ebf 2790 (!in_sector_offset && blk_rq_sectors(current_req) >= ssize)) &&
1da177e4 2791 max_sector > 2 * max_buffer_sectors + buffer_min &&
bb57f0c6
JP		 2792 max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)) {
2793 /* not enough space */
1da177e4
LT		 2794 buffer_track = -1;
2795 buffer_drive = current_drive;
2796 buffer_max = buffer_min = aligned_sector_t;
2797 }
2798 raw_cmd->kernel_data = floppy_track_buffer +
bb57f0c6 2799 ((aligned_sector_t - buffer_min) << 9);
1da177e4
LT		 2800
2801 if (CT(COMMAND) == FD_WRITE) {
2802 /* copy write buffer to track buffer.
2803 * if we get here, we know that the write
2804 * is either aligned or the data already in the buffer
2805 * (buffer will be overwritten) */
2806#ifdef FLOPPY_SANITY_CHECK
2807 if (in_sector_offset && buffer_track == -1)
2808 DPRINT("internal error offset !=0 on write\n");
2809#endif
2810 buffer_track = raw_cmd->track;
2811 buffer_drive = current_drive;
2812 copy_buffer(ssize, max_sector,
2813 2 * max_buffer_sectors + buffer_min);
2814 } else
2815 transfer_size(ssize, max_sector,
2816 2 * max_buffer_sectors + buffer_min -
2817 aligned_sector_t);
2818
2819 /* round up current_count_sectors to get dma xfer size */
2820 raw_cmd->length = in_sector_offset + current_count_sectors;
2821 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2822 raw_cmd->length <<= 9;
2823#ifdef FLOPPY_SANITY_CHECK
1da177e4
LT		 2824 if ((raw_cmd->length < current_count_sectors << 9) ||
2825 (raw_cmd->kernel_data != current_req->buffer &&
2826 CT(COMMAND) == FD_WRITE &&
2827 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2828 aligned_sector_t < buffer_min)) ||
2829 raw_cmd->length % (128 << SIZECODE) ||
2830 raw_cmd->length <= 0 || current_count_sectors <= 0) {
2831 DPRINT("fractionary current count b=%lx s=%lx\n",
2832 raw_cmd->length, current_count_sectors);
2833 if (raw_cmd->kernel_data != current_req->buffer)
b46df356
JP		 2834 pr_info("addr=%d, length=%ld\n",
2835 (int)((raw_cmd->kernel_data -
2836 floppy_track_buffer) >> 9),
2837 current_count_sectors);
2838 pr_info("st=%d ast=%d mse=%d msi=%d\n",
2839 fsector_t, aligned_sector_t, max_sector, max_size);
2840 pr_info("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2841 pr_info("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2842 COMMAND, SECTOR, HEAD, TRACK);
2843 pr_info("buffer drive=%d\n", buffer_drive);
2844 pr_info("buffer track=%d\n", buffer_track);
2845 pr_info("buffer_min=%d\n", buffer_min);
2846 pr_info("buffer_max=%d\n", buffer_max);
1da177e4
LT		 2847 return 0;
2848 }
2849
2850 if (raw_cmd->kernel_data != current_req->buffer) {
2851 if (raw_cmd->kernel_data < floppy_track_buffer ||
2852 current_count_sectors < 0 ||
2853 raw_cmd->length < 0 ||
2854 raw_cmd->kernel_data + raw_cmd->length >
2855 floppy_track_buffer + (max_buffer_sectors << 10)) {
2856 DPRINT("buffer overrun in schedule dma\n");
b46df356
JP		 2857 pr_info("fsector_t=%d buffer_min=%d current_count=%ld\n",
2858 fsector_t, buffer_min, raw_cmd->length >> 9);
2859 pr_info("current_count_sectors=%ld\n",
2860 current_count_sectors);
1da177e4 2861 if (CT(COMMAND) == FD_READ)
b46df356 2862 pr_info("read\n");
1da177e4 2863 if (CT(COMMAND) == FD_WRITE)
b46df356 2864 pr_info("write\n");
1da177e4
LT		 2865 return 0;
2866 }
1011c1b9 2867 } else if (raw_cmd->length > blk_rq_bytes(current_req) ||
83096ebf 2868 current_count_sectors > blk_rq_sectors(current_req)) {
1da177e4
LT		 2869 DPRINT("buffer overrun in direct transfer\n");
2870 return 0;
2871 } else if (raw_cmd->length < current_count_sectors << 9) {
2872 DPRINT("more sectors than bytes\n");
b46df356
JP		 2873 pr_info("bytes=%ld\n", raw_cmd->length >> 9);
2874 pr_info("sectors=%ld\n", current_count_sectors);
1da177e4
LT		 2875 }
2876 if (raw_cmd->length == 0) {
2877 DPRINT("zero dma transfer attempted from make_raw_request\n");
2878 return 0;
2879 }
2880#endif
2881
2882 virtualdmabug_workaround();
2883 return 2;
2884}
2885
2886static void redo_fd_request(void)
2887{
1da177e4
LT		 2888 int drive;
2889 int tmp;
2890
2891 lastredo = jiffies;
2892 if (current_drive < N_DRIVE)
2893 floppy_off(current_drive);
2894
2895 for (;;) {
2896 if (!current_req) {
2897 struct request *req;
2898
2899 spin_lock_irq(floppy_queue->queue_lock);
9934c8c0 2900 req = blk_fetch_request(floppy_queue);
1da177e4
LT		 2901 spin_unlock_irq(floppy_queue->queue_lock);
2902 if (!req) {
2903 do_floppy = NULL;
2904 unlock_fdc();
2905 return;
2906 }
2907 current_req = req;
2908 }
2909 drive = (long)current_req->rq_disk->private_data;
2910 set_fdc(drive);
2911 reschedule_timeout(current_reqD, "redo fd request", 0);
2912
2913 set_floppy(drive);
2914 raw_cmd = &default_raw_cmd;
2915 raw_cmd->flags = 0;
2916 if (start_motor(redo_fd_request))
2917 return;
2918 disk_change(current_drive);
2919 if (test_bit(current_drive, &fake_change) ||
e0298536 2920 test_bit(FD_DISK_CHANGED_BIT, &DRS->flags)) {
1da177e4 2921 DPRINT("disk absent or changed during operation\n");
416d8d28
JP		 2922 request_done(0);
2923 continue;
1da177e4
LT		 2924 }
2925 if (!_floppy) { /* Autodetection */
2926 if (!probing) {
2927 DRS->probed_format = 0;
2928 if (next_valid_format()) {
2929 DPRINT("no autodetectable formats\n");
2930 _floppy = NULL;
416d8d28
JP		 2931 request_done(0);
2932 continue;
1da177e4
LT		 2933 }
2934 }
2935 probing = 1;
2936 _floppy =
2937 floppy_type + DP->autodetect[DRS->probed_format];
2938 } else
2939 probing = 0;
2940 errors = &(current_req->errors);
2941 tmp = make_raw_rw_request();
2942 if (tmp < 2) {
2943 request_done(tmp);
2944 continue;
2945 }
2946
e0298536 2947 if (test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags))
1da177e4
LT		 2948 twaddle();
2949 schedule_bh(floppy_start);
2950 debugt("queue fd request");
2951 return;
2952 }
1da177e4
LT		 2953}
2954
2955static struct cont_t rw_cont = {
2956 .interrupt = rw_interrupt,
2957 .redo = redo_fd_request,
2958 .error = bad_flp_intr,
2959 .done = request_done
2960};
2961
2962static void process_fd_request(void)
2963{
2964 cont = &rw_cont;
2965 schedule_bh(redo_fd_request);
2966}
2967
d7b2b2ec 2968static void do_fd_request(struct request_queue *q)
1da177e4
LT		 2969{
2970 if (max_buffer_sectors == 0) {
b46df356 2971 pr_info("VFS: do_fd_request called on non-open device\n");
1da177e4
LT		 2972 return;
2973 }
2974
2975 if (usage_count == 0) {
b46df356
JP		 2976 pr_info("warning: usage count=0, current_req=%p exiting\n",
2977 current_req);
2978 pr_info("sect=%ld type=%x flags=%x\n",
2979 (long)blk_rq_pos(current_req), current_req->cmd_type,
2980 current_req->cmd_flags);
1da177e4
LT		 2981 return;
2982 }
2983 if (test_bit(0, &fdc_busy)) {
2984 /* fdc busy, this new request will be treated when the
2985 current one is done */
2986 is_alive("do fd request, old request running");
2987 return;
2988 }
74f63f46 2989 lock_fdc(MAXTIMEOUT, false);
1da177e4
LT		 2990 process_fd_request();
2991 is_alive("do fd request");
2992}
2993
2994static struct cont_t poll_cont = {
2995 .interrupt = success_and_wakeup,
2996 .redo = floppy_ready,
2997 .error = generic_failure,
2998 .done = generic_done
2999};
3000
74f63f46 3001static int poll_drive(bool interruptible, int flag)
1da177e4 3002{
1da177e4
LT		 3003 /* no auto-sense, just clear dcl */
3004 raw_cmd = &default_raw_cmd;
3005 raw_cmd->flags = flag;
3006 raw_cmd->track = 0;
3007 raw_cmd->cmd_count = 0;
3008 cont = &poll_cont;
87f530d8 3009 debug_dcl(DP->flags, "setting NEWCHANGE in poll_drive\n");
e0298536 3010 set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
55eee80c
JP		 3011
3012 return wait_til_done(floppy_ready, interruptible);
1da177e4
LT		 3013}
3014
3015/*
3016 * User triggered reset
3017 * ====================
3018 */
3019
3020static void reset_intr(void)
3021{
b46df356 3022 pr_info("weird, reset interrupt called\n");
1da177e4
LT		 3023}
3024
3025static struct cont_t reset_cont = {
3026 .interrupt = reset_intr,
3027 .redo = success_and_wakeup,
3028 .error = generic_failure,
3029 .done = generic_done
3030};
3031
74f63f46 3032static int user_reset_fdc(int drive, int arg, bool interruptible)
1da177e4
LT		 3033{
3034 int ret;
3035
52a0d61f
JP		 3036 if (lock_fdc(drive, interruptible))
3037 return -EINTR;
3038
1da177e4
LT		 3039 if (arg == FD_RESET_ALWAYS)
3040 FDCS->reset = 1;
3041 if (FDCS->reset) {
3042 cont = &reset_cont;
55eee80c
JP		 3043 ret = wait_til_done(reset_fdc, interruptible);
3044 if (ret == -EINTR)
3045 return -EINTR;
1da177e4
LT		 3046 }
3047 process_fd_request();
52a0d61f 3048 return 0;
1da177e4
LT		 3049}
3050
3051/*
3052 * Misc Ioctl's and support
3053 * ========================
3054 */
3055static inline int fd_copyout(void __user *param, const void *address,
3056 unsigned long size)
3057{
3058 return copy_to_user(param, address, size) ? -EFAULT : 0;
3059}
3060
48c8cee6
JP		 3061static inline int fd_copyin(void __user *param, void *address,
3062 unsigned long size)
1da177e4
LT		 3063{
3064 return copy_from_user(address, param, size) ? -EFAULT : 0;
3065}
3066
1da177e4
LT		 3067static inline const char *drive_name(int type, int drive)
3068{
3069 struct floppy_struct *floppy;
3070
3071 if (type)
3072 floppy = floppy_type + type;
3073 else {
3074 if (UDP->native_format)
3075 floppy = floppy_type + UDP->native_format;
3076 else
3077 return "(null)";
3078 }
3079 if (floppy->name)
3080 return floppy->name;
3081 else
3082 return "(null)";
3083}
3084
3085/* raw commands */
3086static void raw_cmd_done(int flag)
3087{
3088 int i;
3089
3090 if (!flag) {
3091 raw_cmd->flags |= FD_RAW_FAILURE;
3092 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3093 } else {
3094 raw_cmd->reply_count = inr;
3095 if (raw_cmd->reply_count > MAX_REPLIES)
3096 raw_cmd->reply_count = 0;
3097 for (i = 0; i < raw_cmd->reply_count; i++)
3098 raw_cmd->reply[i] = reply_buffer[i];
3099
3100 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3101 unsigned long flags;
3102 flags = claim_dma_lock();
3103 raw_cmd->length = fd_get_dma_residue();
3104 release_dma_lock(flags);
3105 }
3106
3107 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3108 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3109 raw_cmd->flags |= FD_RAW_FAILURE;
3110
3111 if (disk_change(current_drive))
3112 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3113 else
3114 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3115 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3116 motor_off_callback(current_drive);
3117
3118 if (raw_cmd->next &&
3119 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3120 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3121 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3122 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3123 raw_cmd = raw_cmd->next;
3124 return;
3125 }
3126 }
3127 generic_done(flag);
3128}
3129
3130static struct cont_t raw_cmd_cont = {
3131 .interrupt = success_and_wakeup,
3132 .redo = floppy_start,
3133 .error = generic_failure,
3134 .done = raw_cmd_done
3135};
3136
3137static inline int raw_cmd_copyout(int cmd, char __user *param,
3138 struct floppy_raw_cmd *ptr)
3139{
3140 int ret;
3141
3142 while (ptr) {
86b12b48
JP		 3143 ret = copy_to_user((void __user *)param, ptr, sizeof(*ptr));
3144 if (ret)
3145 return -EFAULT;
1da177e4
LT		 3146 param += sizeof(struct floppy_raw_cmd);
3147 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
bb57f0c6
JP		 3148 if (ptr->length >= 0 &&
3149 ptr->length <= ptr->buffer_length) {
3150 long length = ptr->buffer_length - ptr->length;
4575b552
JP		 3151 ret = fd_copyout(ptr->data, ptr->kernel_data,
3152 length);
3153 if (ret)
3154 return ret;
bb57f0c6 3155 }
1da177e4
LT		 3156 }
3157 ptr = ptr->next;
3158 }
3159 return 0;
3160}
3161
3162static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3163{
06f748c4
JJ		 3164 struct floppy_raw_cmd *next;
3165 struct floppy_raw_cmd *this;
1da177e4
LT		 3166
3167 this = *ptr;
3168 *ptr = NULL;
3169 while (this) {
3170 if (this->buffer_length) {
3171 fd_dma_mem_free((unsigned long)this->kernel_data,
3172 this->buffer_length);
3173 this->buffer_length = 0;
3174 }
3175 next = this->next;
3176 kfree(this);
3177 this = next;
3178 }
3179}
3180
3181static inline int raw_cmd_copyin(int cmd, char __user *param,
3182 struct floppy_raw_cmd **rcmd)
3183{
3184 struct floppy_raw_cmd *ptr;
3185 int ret;
3186 int i;
3187
3188 *rcmd = NULL;
3189 while (1) {
3190 ptr = (struct floppy_raw_cmd *)
3191 kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3192 if (!ptr)
3193 return -ENOMEM;
3194 *rcmd = ptr;
86b12b48
JP		 3195 ret = copy_from_user(ptr, (void __user *)param, sizeof(*ptr));
3196 if (ret)
3197 return -EFAULT;
1da177e4
LT		 3198 ptr->next = NULL;
3199 ptr->buffer_length = 0;
3200 param += sizeof(struct floppy_raw_cmd);
3201 if (ptr->cmd_count > 33)
3202 /* the command may now also take up the space
3203 * initially intended for the reply & the
3204 * reply count. Needed for long 82078 commands
3205 * such as RESTORE, which takes ... 17 command
3206 * bytes. Murphy's law #137: When you reserve
3207 * 16 bytes for a structure, you'll one day
3208 * discover that you really need 17...
3209 */
3210 return -EINVAL;
3211
3212 for (i = 0; i < 16; i++)
3213 ptr->reply[i] = 0;
3214 ptr->resultcode = 0;
3215 ptr->kernel_data = NULL;
3216
3217 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3218 if (ptr->length <= 0)
3219 return -EINVAL;
3220 ptr->kernel_data =
3221 (char *)fd_dma_mem_alloc(ptr->length);
3222 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3223 if (!ptr->kernel_data)
3224 return -ENOMEM;
3225 ptr->buffer_length = ptr->length;
3226 }
4575b552
JP		 3227 if (ptr->flags & FD_RAW_WRITE) {
3228 ret = fd_copyin(ptr->data, ptr->kernel_data,
3229 ptr->length);
3230 if (ret)
3231 return ret;
3232 }
1da177e4
LT		 3233 rcmd = &(ptr->next);
3234 if (!(ptr->flags & FD_RAW_MORE))
3235 return 0;
3236 ptr->rate &= 0x43;
3237 }
3238}
3239
3240static int raw_cmd_ioctl(int cmd, void __user *param)
3241{
1da177e4 3242 struct floppy_raw_cmd *my_raw_cmd;
06f748c4
JJ		 3243 int drive;
3244 int ret2;
3245 int ret;
1da177e4
LT		 3246
3247 if (FDCS->rawcmd <= 1)
3248 FDCS->rawcmd = 1;
3249 for (drive = 0; drive < N_DRIVE; drive++) {
3250 if (FDC(drive) != fdc)
3251 continue;
3252 if (drive == current_drive) {
3253 if (UDRS->fd_ref > 1) {
3254 FDCS->rawcmd = 2;
3255 break;
3256 }
3257 } else if (UDRS->fd_ref) {
3258 FDCS->rawcmd = 2;
3259 break;
3260 }
3261 }
3262
3263 if (FDCS->reset)
3264 return -EIO;
3265
3266 ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3267 if (ret) {
3268 raw_cmd_free(&my_raw_cmd);
3269 return ret;
3270 }
3271
3272 raw_cmd = my_raw_cmd;
3273 cont = &raw_cmd_cont;
74f63f46 3274 ret = wait_til_done(floppy_start, true);
87f530d8 3275 debug_dcl(DP->flags, "calling disk change from raw_cmd ioctl\n");
1da177e4
LT		 3276
3277 if (ret != -EINTR && FDCS->reset)
3278 ret = -EIO;
3279
3280 DRS->track = NO_TRACK;
3281
3282 ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3283 if (!ret)
3284 ret = ret2;
3285 raw_cmd_free(&my_raw_cmd);
3286 return ret;
3287}
3288
3289static int invalidate_drive(struct block_device *bdev)
3290{
3291 /* invalidate the buffer track to force a reread */
3292 set_bit((long)bdev->bd_disk->private_data, &fake_change);
3293 process_fd_request();
3294 check_disk_change(bdev);
3295 return 0;
3296}
3297
3298static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
3299 int drive, int type, struct block_device *bdev)
3300{
3301 int cnt;
3302
3303 /* sanity checking for parameters. */
3304 if (g->sect <= 0 ||
3305 g->head <= 0 ||
3306 g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3307 /* check if reserved bits are set */
9e49184c 3308 (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0)
1da177e4
LT		 3309 return -EINVAL;
3310 if (type) {
3311 if (!capable(CAP_SYS_ADMIN))
3312 return -EPERM;
b1c82b5c 3313 mutex_lock(&open_lock);
74f63f46 3314 if (lock_fdc(drive, true)) {
8516a500
JS		 3315 mutex_unlock(&open_lock);
3316 return -EINTR;
3317 }
1da177e4
LT		 3318 floppy_type[type] = *g;
3319 floppy_type[type].name = "user format";
3320 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3321 floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3322 floppy_type[type].size + 1;
3323 process_fd_request();
3324 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3325 struct block_device *bdev = opened_bdev[cnt];
3326 if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3327 continue;
2ef41634 3328 __invalidate_device(bdev);
1da177e4 3329 }
b1c82b5c 3330 mutex_unlock(&open_lock);
1da177e4
LT		 3331 } else {
3332 int oldStretch;
52a0d61f 3333
74f63f46 3334 if (lock_fdc(drive, true))
52a0d61f 3335 return -EINTR;
4575b552 3336 if (cmd != FDDEFPRM) {
1da177e4
LT		 3337 /* notice a disk change immediately, else
3338 * we lose our settings immediately*/
74f63f46 3339 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
4575b552
JP		 3340 return -EINTR;
3341 }
1da177e4
LT		 3342 oldStretch = g->stretch;
3343 user_params[drive] = *g;
3344 if (buffer_drive == drive)
3345 SUPBOUND(buffer_max, user_params[drive].sect);
3346 current_type[drive] = &user_params[drive];
3347 floppy_sizes[drive] = user_params[drive].size;
3348 if (cmd == FDDEFPRM)
3349 DRS->keep_data = -1;
3350 else
3351 DRS->keep_data = 1;
3352 /* invalidation. Invalidate only when needed, i.e.
3353 * when there are already sectors in the buffer cache
3354 * whose number will change. This is useful, because
3355 * mtools often changes the geometry of the disk after
3356 * looking at the boot block */
3357 if (DRS->maxblock > user_params[drive].sect ||
3358 DRS->maxtrack ||
3359 ((user_params[drive].sect ^ oldStretch) &
9e49184c 3360 (FD_SWAPSIDES | FD_SECTBASEMASK)))
1da177e4
LT		 3361 invalidate_drive(bdev);
3362 else
3363 process_fd_request();
3364 }
3365 return 0;
3366}
3367
3368/* handle obsolete ioctl's */
3369static int ioctl_table[] = {
3370 FDCLRPRM,
3371 FDSETPRM,
3372 FDDEFPRM,
3373 FDGETPRM,
3374 FDMSGON,
3375 FDMSGOFF,
3376 FDFMTBEG,
3377 FDFMTTRK,
3378 FDFMTEND,
3379 FDSETEMSGTRESH,
3380 FDFLUSH,
3381 FDSETMAXERRS,
3382 FDGETMAXERRS,
3383 FDGETDRVTYP,
3384 FDSETDRVPRM,
3385 FDGETDRVPRM,
3386 FDGETDRVSTAT,
3387 FDPOLLDRVSTAT,
3388 FDRESET,
3389 FDGETFDCSTAT,
3390 FDWERRORCLR,
3391 FDWERRORGET,
3392 FDRAWCMD,
3393 FDEJECT,
3394 FDTWADDLE
3395};
3396
3397static inline int normalize_ioctl(int *cmd, int *size)
3398{
3399 int i;
3400
3401 for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3402 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3403 *size = _IOC_SIZE(*cmd);
3404 *cmd = ioctl_table[i];
3405 if (*size > _IOC_SIZE(*cmd)) {
b46df356 3406 pr_info("ioctl not yet supported\n");
1da177e4
LT		 3407 return -EFAULT;
3408 }
3409 return 0;
3410 }
3411 }
3412 return -EINVAL;
3413}
3414
3415static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3416{
3417 if (type)
3418 *g = &floppy_type[type];
3419 else {
74f63f46 3420 if (lock_fdc(drive, false))
52a0d61f 3421 return -EINTR;
74f63f46 3422 if (poll_drive(false, 0) == -EINTR)
4575b552 3423 return -EINTR;
1da177e4
LT		 3424 process_fd_request();
3425 *g = current_type[drive];
3426 }
3427 if (!*g)
3428 return -ENODEV;
3429 return 0;
3430}
3431
a885c8c4
CH		 3432static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3433{
3434 int drive = (long)bdev->bd_disk->private_data;
3435 int type = ITYPE(drive_state[drive].fd_device);
3436 struct floppy_struct *g;
3437 int ret;
3438
3439 ret = get_floppy_geometry(drive, type, &g);
3440 if (ret)
3441 return ret;
3442
3443 geo->heads = g->head;
3444 geo->sectors = g->sect;
3445 geo->cylinders = g->track;
3446 return 0;
3447}
3448
a4af9b48 3449static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
1da177e4
LT		 3450 unsigned long param)
3451{
a4af9b48 3452#define FD_IOCTL_ALLOWED (mode & (FMODE_WRITE|FMODE_WRITE_IOCTL))
1da177e4 3453
a4af9b48 3454 int drive = (long)bdev->bd_disk->private_data;
06f748c4
JJ		 3455 int type = ITYPE(UDRS->fd_device);
3456 int i;
1da177e4
LT		 3457 int ret;
3458 int size;
3459 union inparam {
3460 struct floppy_struct g; /* geometry */
3461 struct format_descr f;
3462 struct floppy_max_errors max_errors;
3463 struct floppy_drive_params dp;
3464 } inparam; /* parameters coming from user space */
3465 const char *outparam; /* parameters passed back to user space */
3466
3467 /* convert compatibility eject ioctls into floppy eject ioctl.
3468 * We do this in order to provide a means to eject floppy disks before
3469 * installing the new fdutils package */
3470 if (cmd == CDROMEJECT || /* CD-ROM eject */
a81ee544 3471 cmd == 0x6470) { /* SunOS floppy eject */
1da177e4
LT		 3472 DPRINT("obsolete eject ioctl\n");
3473 DPRINT("please use floppycontrol --eject\n");
3474 cmd = FDEJECT;
3475 }
3476
a81ee544 3477 if (!((cmd & 0xff00) == 0x0200))
1da177e4
LT		 3478 return -EINVAL;
3479
a81ee544 3480 /* convert the old style command into a new style command */
4575b552
JP		 3481 ret = normalize_ioctl(&cmd, &size);
3482 if (ret)
3483 return ret;
a81ee544 3484
1da177e4
LT		 3485 /* permission checks */
3486 if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
3487 ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3488 return -EPERM;
3489
2886a8bd
AV		 3490 if (WARN_ON(size < 0 || size > sizeof(inparam)))
3491 return -EINVAL;
3492
1da177e4 3493 /* copyin */
b87c9e0a 3494 memset(&inparam, 0, sizeof(inparam));
4575b552
JP		 3495 if (_IOC_DIR(cmd) & _IOC_WRITE) {
3496 ret = fd_copyin((void __user *)param, &inparam, size);
3497 if (ret)
3498 return ret;
3499 }
1da177e4 3500
da273653
JP		 3501 switch (cmd) {
3502 case FDEJECT:
3503 if (UDRS->fd_ref != 1)
3504 /* somebody else has this drive open */
3505 return -EBUSY;
74f63f46 3506 if (lock_fdc(drive, true))
52a0d61f 3507 return -EINTR;
1da177e4 3508
da273653
JP		 3509 /* do the actual eject. Fails on
3510 * non-Sparc architectures */
3511 ret = fd_eject(UNIT(drive));
1da177e4 3512
e0298536
JP		 3513 set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
3514 set_bit(FD_VERIFY_BIT, &UDRS->flags);
da273653
JP		 3515 process_fd_request();
3516 return ret;
3517 case FDCLRPRM:
74f63f46 3518 if (lock_fdc(drive, true))
52a0d61f 3519 return -EINTR;
da273653
JP		 3520 current_type[drive] = NULL;
3521 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3522 UDRS->keep_data = 0;
3523 return invalidate_drive(bdev);
3524 case FDSETPRM:
3525 case FDDEFPRM:
3526 return set_geometry(cmd, &inparam.g, drive, type, bdev);
3527 case FDGETPRM:
4575b552 3528 ret = get_floppy_geometry(drive, type,
da273653 3529 (struct floppy_struct **)
4575b552
JP		 3530 &outparam);
3531 if (ret)
3532 return ret;
da273653
JP		 3533 break;
3534 case FDMSGON:
3535 UDP->flags |= FTD_MSG;
3536 return 0;
3537 case FDMSGOFF:
3538 UDP->flags &= ~FTD_MSG;
3539 return 0;
3540 case FDFMTBEG:
74f63f46 3541 if (lock_fdc(drive, true))
52a0d61f 3542 return -EINTR;
74f63f46 3543 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
4575b552 3544 return -EINTR;
da273653
JP		 3545 ret = UDRS->flags;
3546 process_fd_request();
3547 if (ret & FD_VERIFY)
3548 return -ENODEV;
3549 if (!(ret & FD_DISK_WRITABLE))
3550 return -EROFS;
3551 return 0;
3552 case FDFMTTRK:
3553 if (UDRS->fd_ref != 1)
3554 return -EBUSY;
3555 return do_format(drive, &inparam.f);
3556 case FDFMTEND:
3557 case FDFLUSH:
74f63f46 3558 if (lock_fdc(drive, true))
52a0d61f 3559 return -EINTR;
da273653
JP		 3560 return invalidate_drive(bdev);
3561 case FDSETEMSGTRESH:
3562 UDP->max_errors.reporting = (unsigned short)(param & 0x0f);
3563 return 0;
3564 case FDGETMAXERRS:
3565 outparam = (const char *)&UDP->max_errors;
3566 break;
3567 case FDSETMAXERRS:
3568 UDP->max_errors = inparam.max_errors;
3569 break;
3570 case FDGETDRVTYP:
3571 outparam = drive_name(type, drive);
3572 SUPBOUND(size, strlen(outparam) + 1);
3573 break;
3574 case FDSETDRVPRM:
3575 *UDP = inparam.dp;
3576 break;
3577 case FDGETDRVPRM:
3578 outparam = (const char *)UDP;
3579 break;
3580 case FDPOLLDRVSTAT:
74f63f46 3581 if (lock_fdc(drive, true))
52a0d61f 3582 return -EINTR;
74f63f46 3583 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
4575b552 3584 return -EINTR;
da273653
JP		 3585 process_fd_request();
3586 /* fall through */
3587 case FDGETDRVSTAT:
3588 outparam = (const char *)UDRS;
3589 break;
3590 case FDRESET:
74f63f46 3591 return user_reset_fdc(drive, (int)param, true);
da273653
JP		 3592 case FDGETFDCSTAT:
3593 outparam = (const char *)UFDCS;
3594 break;
3595 case FDWERRORCLR:
3596 memset(UDRWE, 0, sizeof(*UDRWE));
3597 return 0;
3598 case FDWERRORGET:
3599 outparam = (const char *)UDRWE;
3600 break;
3601 case FDRAWCMD:
3602 if (type)
1da177e4 3603 return -EINVAL;
74f63f46 3604 if (lock_fdc(drive, true))
52a0d61f 3605 return -EINTR;
da273653 3606 set_floppy(drive);
4575b552
JP		 3607 i = raw_cmd_ioctl(cmd, (void __user *)param);
3608 if (i == -EINTR)
3609 return -EINTR;
da273653
JP		 3610 process_fd_request();
3611 return i;
3612 case FDTWADDLE:
74f63f46 3613 if (lock_fdc(drive, true))
52a0d61f 3614 return -EINTR;
da273653
JP		 3615 twaddle();
3616 process_fd_request();
3617 return 0;
3618 default:
3619 return -EINVAL;
3620 }
1da177e4
LT		 3621
3622 if (_IOC_DIR(cmd) & _IOC_READ)
3623 return fd_copyout((void __user *)param, outparam, size);
da273653
JP		 3624
3625 return 0;
1da177e4
LT		 3626}
3627
3628static void __init config_types(void)
3629{
b46df356 3630 bool has_drive = false;
1da177e4
LT		 3631 int drive;
3632
3633 /* read drive info out of physical CMOS */
3634 drive = 0;
3635 if (!UDP->cmos)
3636 UDP->cmos = FLOPPY0_TYPE;
3637 drive = 1;
3638 if (!UDP->cmos && FLOPPY1_TYPE)
3639 UDP->cmos = FLOPPY1_TYPE;
3640
06f748c4 3641 /* FIXME: additional physical CMOS drive detection should go here */
1da177e4
LT		 3642
3643 for (drive = 0; drive < N_DRIVE; drive++) {
3644 unsigned int type = UDP->cmos;
3645 struct floppy_drive_params *params;
3646 const char *name = NULL;
3647 static char temparea[32];
3648
945f390f 3649 if (type < ARRAY_SIZE(default_drive_params)) {
1da177e4
LT		 3650 params = &default_drive_params[type].params;
3651 if (type) {
3652 name = default_drive_params[type].name;
3653 allowed_drive_mask |= 1 << drive;
3654 } else
3655 allowed_drive_mask &= ~(1 << drive);
3656 } else {
3657 params = &default_drive_params[0].params;
3658 sprintf(temparea, "unknown type %d (usb?)", type);
3659 name = temparea;
3660 }
3661 if (name) {
b46df356
JP		 3662 const char *prepend;
3663 if (!has_drive) {
3664 prepend = "";
3665 has_drive = true;
3666 pr_info("Floppy drive(s):");
3667 } else {
3668 prepend = ",";
1da177e4 3669 }
b46df356
JP		 3670
3671 pr_cont("%s fd%d is %s", prepend, drive, name);
1da177e4
LT		 3672 }
3673 *UDP = *params;
3674 }
b46df356
JP		 3675
3676 if (has_drive)
3677 pr_cont("\n");
1da177e4
LT		 3678}
3679
a4af9b48 3680static int floppy_release(struct gendisk *disk, fmode_t mode)
1da177e4 3681{
a4af9b48 3682 int drive = (long)disk->private_data;
1da177e4 3683
b1c82b5c 3684 mutex_lock(&open_lock);
1da177e4
LT		 3685 if (UDRS->fd_ref < 0)
3686 UDRS->fd_ref = 0;
3687 else if (!UDRS->fd_ref--) {
3688 DPRINT("floppy_release with fd_ref == 0");
3689 UDRS->fd_ref = 0;
3690 }
3691 if (!UDRS->fd_ref)
3692 opened_bdev[drive] = NULL;
b1c82b5c 3693 mutex_unlock(&open_lock);
3e541a4a 3694
1da177e4
LT		 3695 return 0;
3696}
3697
3698/*
3699 * floppy_open check for aliasing (/dev/fd0 can be the same as
3700 * /dev/PS0 etc), and disallows simultaneous access to the same
3701 * drive with different device numbers.
3702 */
a4af9b48 3703static int floppy_open(struct block_device *bdev, fmode_t mode)
1da177e4 3704{
a4af9b48
AV		 3705 int drive = (long)bdev->bd_disk->private_data;
3706 int old_dev, new_dev;
1da177e4
LT		 3707 int try;
3708 int res = -EBUSY;
3709 char *tmp;
3710
b1c82b5c 3711 mutex_lock(&open_lock);
1da177e4 3712 old_dev = UDRS->fd_device;
a4af9b48 3713 if (opened_bdev[drive] && opened_bdev[drive] != bdev)
1da177e4
LT		 3714 goto out2;
3715
3716 if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
e0298536
JP		 3717 set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
3718 set_bit(FD_VERIFY_BIT, &UDRS->flags);
1da177e4
LT		 3719 }
3720
a4af9b48 3721 if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (mode & FMODE_EXCL)))
1da177e4
LT		 3722 goto out2;
3723
a4af9b48 3724 if (mode & FMODE_EXCL)
1da177e4
LT		 3725 UDRS->fd_ref = -1;
3726 else
3727 UDRS->fd_ref++;
3728
a4af9b48 3729 opened_bdev[drive] = bdev;
1da177e4
LT		 3730
3731 res = -ENXIO;
3732
3733 if (!floppy_track_buffer) {
3734 /* if opening an ED drive, reserve a big buffer,
3735 * else reserve a small one */
3736 if ((UDP->cmos == 6) || (UDP->cmos == 5))
3737 try = 64; /* Only 48 actually useful */
3738 else
3739 try = 32; /* Only 24 actually useful */
3740
3741 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3742 if (!tmp && !floppy_track_buffer) {
3743 try >>= 1; /* buffer only one side */
3744 INFBOUND(try, 16);
3745 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3746 }
a81ee544 3747 if (!tmp && !floppy_track_buffer)
1da177e4 3748 fallback_on_nodma_alloc(&tmp, 2048 * try);
1da177e4
LT		 3749 if (!tmp && !floppy_track_buffer) {
3750 DPRINT("Unable to allocate DMA memory\n");
3751 goto out;
3752 }
3753 if (floppy_track_buffer) {
3754 if (tmp)
3755 fd_dma_mem_free((unsigned long)tmp, try * 1024);
3756 } else {
3757 buffer_min = buffer_max = -1;
3758 floppy_track_buffer = tmp;
3759 max_buffer_sectors = try;
3760 }
3761 }
3762
a4af9b48
AV		 3763 new_dev = MINOR(bdev->bd_dev);
3764 UDRS->fd_device = new_dev;
3765 set_capacity(disks[drive], floppy_sizes[new_dev]);
3766 if (old_dev != -1 && old_dev != new_dev) {
1da177e4
LT		 3767 if (buffer_drive == drive)
3768 buffer_track = -1;
3769 }
3770
1da177e4
LT		 3771 if (UFDCS->rawcmd == 1)
3772 UFDCS->rawcmd = 2;
3773
a4af9b48
AV		 3774 if (!(mode & FMODE_NDELAY)) {
3775 if (mode & (FMODE_READ|FMODE_WRITE)) {
1da177e4 3776 UDRS->last_checked = 0;
a4af9b48 3777 check_disk_change(bdev);
e0298536 3778 if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags))
1da177e4
LT		 3779 goto out;
3780 }
3781 res = -EROFS;
e0298536
JP		 3782 if ((mode & FMODE_WRITE) &&
3783 !test_bit(FD_DISK_WRITABLE_BIT, &UDRS->flags))
1da177e4
LT		 3784 goto out;
3785 }
b1c82b5c 3786 mutex_unlock(&open_lock);
1da177e4
LT		 3787 return 0;
3788out:
3789 if (UDRS->fd_ref < 0)
3790 UDRS->fd_ref = 0;
3791 else
3792 UDRS->fd_ref--;
3793 if (!UDRS->fd_ref)
3794 opened_bdev[drive] = NULL;
1da177e4 3795out2:
b1c82b5c 3796 mutex_unlock(&open_lock);
1da177e4
LT		 3797 return res;
3798}
3799
3800/*
3801 * Check if the disk has been changed or if a change has been faked.
3802 */
3803static int check_floppy_change(struct gendisk *disk)
3804{
3805 int drive = (long)disk->private_data;
3806
e0298536
JP		 3807 if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
3808 test_bit(FD_VERIFY_BIT, &UDRS->flags))
1da177e4
LT		 3809 return 1;
3810
50297cbf 3811 if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
74f63f46
JP		 3812 lock_fdc(drive, false);
3813 poll_drive(false, 0);
1da177e4 3814 process_fd_request();
1da177e4
LT		 3815 }
3816
e0298536
JP		 3817 if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
3818 test_bit(FD_VERIFY_BIT, &UDRS->flags) ||
1da177e4
LT		 3819 test_bit(drive, &fake_change) ||
3820 (!ITYPE(UDRS->fd_device) && !current_type[drive]))
3821 return 1;
3822 return 0;
3823}
3824
3825/*
3826 * This implements "read block 0" for floppy_revalidate().
3827 * Needed for format autodetection, checking whether there is
3828 * a disk in the drive, and whether that disk is writable.
3829 */
3830
bb57f0c6 3831static void floppy_rb0_complete(struct bio *bio, int err)
1da177e4 3832{
1da177e4 3833 complete((struct completion *)bio->bi_private);
1da177e4
LT		 3834}
3835
3836static int __floppy_read_block_0(struct block_device *bdev)
3837{
3838 struct bio bio;
3839 struct bio_vec bio_vec;
3840 struct completion complete;
3841 struct page *page;
3842 size_t size;
3843
3844 page = alloc_page(GFP_NOIO);
3845 if (!page) {
3846 process_fd_request();
3847 return -ENOMEM;
3848 }
3849
3850 size = bdev->bd_block_size;
3851 if (!size)
3852 size = 1024;
3853
3854 bio_init(&bio);
3855 bio.bi_io_vec = &bio_vec;
3856 bio_vec.bv_page = page;
3857 bio_vec.bv_len = size;
3858 bio_vec.bv_offset = 0;
3859 bio.bi_vcnt = 1;
3860 bio.bi_idx = 0;
3861 bio.bi_size = size;
3862 bio.bi_bdev = bdev;
3863 bio.bi_sector = 0;
3864 init_completion(&complete);
3865 bio.bi_private = &complete;
3866 bio.bi_end_io = floppy_rb0_complete;
3867
3868 submit_bio(READ, &bio);
3869 generic_unplug_device(bdev_get_queue(bdev));
3870 process_fd_request();
3871 wait_for_completion(&complete);
3872
3873 __free_page(page);
3874
3875 return 0;
3876}
3877
3878/* revalidate the floppy disk, i.e. trigger format autodetection by reading
3879 * the bootblock (block 0). "Autodetection" is also needed to check whether
3880 * there is a disk in the drive at all... Thus we also do it for fixed
3881 * geometry formats */
3882static int floppy_revalidate(struct gendisk *disk)
3883{
3884 int drive = (long)disk->private_data;
3885#define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
3886 int cf;
3887 int res = 0;
3888
e0298536
JP		 3889 if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
3890 test_bit(FD_VERIFY_BIT, &UDRS->flags) ||
3891 test_bit(drive, &fake_change) || NO_GEOM) {
1da177e4 3892 if (usage_count == 0) {
b46df356 3893 pr_info("VFS: revalidate called on non-open device.\n");
1da177e4
LT		 3894 return -EFAULT;
3895 }
74f63f46 3896 lock_fdc(drive, false);
e0298536
JP		 3897 cf = (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
3898 test_bit(FD_VERIFY_BIT, &UDRS->flags));
1da177e4
LT		 3899 if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
3900 process_fd_request(); /*already done by another thread */
3901 return 0;
3902 }
3903 UDRS->maxblock = 0;
3904 UDRS->maxtrack = 0;
3905 if (buffer_drive == drive)
3906 buffer_track = -1;
3907 clear_bit(drive, &fake_change);
e0298536 3908 clear_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
1da177e4
LT		 3909 if (cf)
3910 UDRS->generation++;
3911 if (NO_GEOM) {
3912 /* auto-sensing */
3913 res = __floppy_read_block_0(opened_bdev[drive]);
3914 } else {
3915 if (cf)
74f63f46 3916 poll_drive(false, FD_RAW_NEED_DISK);
1da177e4
LT		 3917 process_fd_request();
3918 }
3919 }
3920 set_capacity(disk, floppy_sizes[UDRS->fd_device]);
3921 return res;
3922}
3923
83d5cde4 3924static const struct block_device_operations floppy_fops = {
06f748c4 3925 .owner = THIS_MODULE,
a4af9b48
AV		 3926 .open = floppy_open,
3927 .release = floppy_release,
3928 .locked_ioctl = fd_ioctl,
06f748c4
JJ		 3929 .getgeo = fd_getgeo,
3930 .media_changed = check_floppy_change,
3931 .revalidate_disk = floppy_revalidate,
1da177e4 3932};
1da177e4 3933
1da177e4
LT		 3934/*
3935 * Floppy Driver initialization
3936 * =============================
3937 */
3938
3939/* Determine the floppy disk controller type */
3940/* This routine was written by David C. Niemi */
3941static char __init get_fdc_version(void)
3942{
3943 int r;
3944
3945 output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */
3946 if (FDCS->reset)
3947 return FDC_NONE;
d7b2b2ec
JP		 3948 r = result();
3949 if (r <= 0x00)
1da177e4
LT		 3950 return FDC_NONE; /* No FDC present ??? */
3951 if ((r == 1) && (reply_buffer[0] == 0x80)) {
b46df356 3952 pr_info("FDC %d is an 8272A\n", fdc);
1da177e4
LT		 3953 return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
3954 }
3955 if (r != 10) {
b46df356
JP		 3956 pr_info("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
3957 fdc, r);
1da177e4
LT		 3958 return FDC_UNKNOWN;
3959 }
3960
3961 if (!fdc_configure()) {
b46df356 3962 pr_info("FDC %d is an 82072\n", fdc);
1da177e4
LT		 3963 return FDC_82072; /* 82072 doesn't know CONFIGURE */
3964 }
3965
3966 output_byte(FD_PERPENDICULAR);
3967 if (need_more_output() == MORE_OUTPUT) {
3968 output_byte(0);
3969 } else {
b46df356 3970 pr_info("FDC %d is an 82072A\n", fdc);
1da177e4
LT		 3971 return FDC_82072A; /* 82072A as found on Sparcs. */
3972 }
3973
3974 output_byte(FD_UNLOCK);
3975 r = result();
3976 if ((r == 1) && (reply_buffer[0] == 0x80)) {
b46df356 3977 pr_info("FDC %d is a pre-1991 82077\n", fdc);
d7b2b2ec 3978 return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
1da177e4
LT		 3979 * LOCK/UNLOCK */
3980 }
3981 if ((r != 1) || (reply_buffer[0] != 0x00)) {
b46df356
JP		 3982 pr_info("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
3983 fdc, r);
1da177e4
LT		 3984 return FDC_UNKNOWN;
3985 }
3986 output_byte(FD_PARTID);
3987 r = result();
3988 if (r != 1) {
b46df356
JP		 3989 pr_info("FDC %d init: PARTID: unexpected return of %d bytes.\n",
3990 fdc, r);
1da177e4
LT		 3991 return FDC_UNKNOWN;
3992 }
3993 if (reply_buffer[0] == 0x80) {
b46df356 3994 pr_info("FDC %d is a post-1991 82077\n", fdc);
1da177e4
LT		 3995 return FDC_82077; /* Revised 82077AA passes all the tests */
3996 }
3997 switch (reply_buffer[0] >> 5) {
3998 case 0x0:
3999 /* Either a 82078-1 or a 82078SL running at 5Volt */
b46df356 4000 pr_info("FDC %d is an 82078.\n", fdc);
1da177e4
LT		 4001 return FDC_82078;
4002 case 0x1:
b46df356 4003 pr_info("FDC %d is a 44pin 82078\n", fdc);
1da177e4
LT		 4004 return FDC_82078;
4005 case 0x2:
b46df356 4006 pr_info("FDC %d is a S82078B\n", fdc);
1da177e4
LT		 4007 return FDC_S82078B;
4008 case 0x3:
b46df356 4009 pr_info("FDC %d is a National Semiconductor PC87306\n", fdc);
1da177e4
LT		 4010 return FDC_87306;
4011 default:
b46df356
JP		 4012 pr_info("FDC %d init: 82078 variant with unknown PARTID=%d.\n",
4013 fdc, reply_buffer[0] >> 5);
1da177e4
LT		 4014 return FDC_82078_UNKN;
4015 }
4016} /* get_fdc_version */
4017
4018/* lilo configuration */
4019
4020static void __init floppy_set_flags(int *ints, int param, int param2)
4021{
4022 int i;
4023
4024 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4025 if (param)
4026 default_drive_params[i].params.flags |= param2;
4027 else
4028 default_drive_params[i].params.flags &= ~param2;
4029 }
4030 DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4031}
4032
4033static void __init daring(int *ints, int param, int param2)
4034{
4035 int i;
4036
4037 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4038 if (param) {
4039 default_drive_params[i].params.select_delay = 0;
4040 default_drive_params[i].params.flags |=
4041 FD_SILENT_DCL_CLEAR;
4042 } else {
4043 default_drive_params[i].params.select_delay =
4044 2 * HZ / 100;
4045 default_drive_params[i].params.flags &=
4046 ~FD_SILENT_DCL_CLEAR;
4047 }
4048 }
4049 DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4050}
4051
4052static void __init set_cmos(int *ints, int dummy, int dummy2)
4053{
4054 int current_drive = 0;
4055
4056 if (ints[0] != 2) {
4057 DPRINT("wrong number of parameters for CMOS\n");
4058 return;
4059 }
4060 current_drive = ints[1];
4061 if (current_drive < 0 || current_drive >= 8) {
4062 DPRINT("bad drive for set_cmos\n");
4063 return;
4064 }
4065#if N_FDC > 1
4066 if (current_drive >= 4 && !FDC2)
4067 FDC2 = 0x370;
4068#endif
4069 DP->cmos = ints[2];
4070 DPRINT("setting CMOS code to %d\n", ints[2]);
4071}
4072
4073static struct param_table {
4074 const char *name;
4075 void (*fn) (int *ints, int param, int param2);
4076 int *var;
4077 int def_param;
4078 int param2;
4079} config_params[] __initdata = {
4080 {"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4081 {"all_drives", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4082 {"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
4083 {"irq", NULL, &FLOPPY_IRQ, 6, 0},
4084 {"dma", NULL, &FLOPPY_DMA, 2, 0},
4085 {"daring", daring, NULL, 1, 0},
4086#if N_FDC > 1
4087 {"two_fdc", NULL, &FDC2, 0x370, 0},
4088 {"one_fdc", NULL, &FDC2, 0, 0},
4089#endif
4090 {"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
4091 {"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
4092 {"messages", floppy_set_flags, NULL, 1, FTD_MSG},
4093 {"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
4094 {"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
4095 {"nodma", NULL, &can_use_virtual_dma, 1, 0},
4096 {"omnibook", NULL, &can_use_virtual_dma, 1, 0},
4097 {"yesdma", NULL, &can_use_virtual_dma, 0, 0},
4098 {"fifo_depth", NULL, &fifo_depth, 0xa, 0},
4099 {"nofifo", NULL, &no_fifo, 0x20, 0},
4100 {"usefifo", NULL, &no_fifo, 0, 0},
4101 {"cmos", set_cmos, NULL, 0, 0},
4102 {"slow", NULL, &slow_floppy, 1, 0},
4103 {"unexpected_interrupts", NULL, &print_unex, 1, 0},
4104 {"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
4105 {"L40SX", NULL, &print_unex, 0, 0}
4106
4107 EXTRA_FLOPPY_PARAMS
4108};
4109
4110static int __init floppy_setup(char *str)
4111{
4112 int i;
4113 int param;
4114 int ints[11];
4115
4116 str = get_options(str, ARRAY_SIZE(ints), ints);
4117 if (str) {
4118 for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4119 if (strcmp(str, config_params[i].name) == 0) {
4120 if (ints[0])
4121 param = ints[1];
4122 else
4123 param = config_params[i].def_param;
4124 if (config_params[i].fn)
bb57f0c6
JP		 4125 config_params[i].fn(ints, param,
4126 config_params[i].
4127 param2);
1da177e4
LT		 4128 if (config_params[i].var) {
4129 DPRINT("%s=%d\n", str, param);
4130 *config_params[i].var = param;
4131 }
4132 return 1;
4133 }
4134 }
4135 }
4136 if (str) {
4137 DPRINT("unknown floppy option [%s]\n", str);
4138
4139 DPRINT("allowed options are:");
4140 for (i = 0; i < ARRAY_SIZE(config_params); i++)
b46df356
JP		 4141 pr_cont(" %s", config_params[i].name);
4142 pr_cont("\n");
1da177e4
LT		 4143 } else
4144 DPRINT("botched floppy option\n");
31c00fc1 4145 DPRINT("Read Documentation/blockdev/floppy.txt\n");
1da177e4
LT		 4146 return 0;
4147}
4148
4149static int have_no_fdc = -ENODEV;
4150
9a8af6b3
AM		 4151static ssize_t floppy_cmos_show(struct device *dev,
4152 struct device_attribute *attr, char *buf)
94fd0db7 4153{
71b3e0c1 4154 struct platform_device *p = to_platform_device(dev);
9a8af6b3 4155 int drive;
94fd0db7 4156
9a8af6b3
AM		 4157 drive = p->id;
4158 return sprintf(buf, "%X\n", UDP->cmos);
94fd0db7 4159}
48c8cee6
JP		 4160
4161DEVICE_ATTR(cmos, S_IRUGO, floppy_cmos_show, NULL);
94fd0db7 4162
1da177e4
LT		 4163static void floppy_device_release(struct device *dev)
4164{
1da177e4
LT		 4165}
4166
c90cd332 4167static int floppy_resume(struct device *dev)
5e50b9ef
OZ		 4168{
4169 int fdc;
4170
4171 for (fdc = 0; fdc < N_FDC; fdc++)
4172 if (FDCS->address != -1)
74f63f46 4173 user_reset_fdc(-1, FD_RESET_ALWAYS, false);
5e50b9ef
OZ		 4174
4175 return 0;
4176}
4177
47145210 4178static const struct dev_pm_ops floppy_pm_ops = {
5e50b9ef 4179 .resume = floppy_resume,
c90cd332
FP		 4180 .restore = floppy_resume,
4181};
4182
4183static struct platform_driver floppy_driver = {
5e50b9ef 4184 .driver = {
bb57f0c6
JP		 4185 .name = "floppy",
4186 .pm = &floppy_pm_ops,
5e50b9ef
OZ		 4187 },
4188};
4189
94fd0db7 4190static struct platform_device floppy_device[N_DRIVE];
1da177e4
LT		 4191
4192static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4193{
4194 int drive = (*part & 3) | ((*part & 0x80) >> 5);
4195 if (drive >= N_DRIVE ||
4196 !(allowed_drive_mask & (1 << drive)) ||
4197 fdc_state[FDC(drive)].version == FDC_NONE)
4198 return NULL;
945f390f 4199 if (((*part >> 2) & 0x1f) >= ARRAY_SIZE(floppy_type))
1da177e4
LT		 4200 return NULL;
4201 *part = 0;
4202 return get_disk(disks[drive]);
4203}
4204
4205static int __init floppy_init(void)
4206{
4207 int i, unit, drive;
4208 int err, dr;
4209
68e1ee62 4210#if defined(CONFIG_PPC)
ef16b519
OH		 4211 if (check_legacy_ioport(FDC1))
4212 return -ENODEV;
4213#endif
4214
1da177e4
LT		 4215 raw_cmd = NULL;
4216
4217 for (dr = 0; dr < N_DRIVE; dr++) {
4218 disks[dr] = alloc_disk(1);
4219 if (!disks[dr]) {
4220 err = -ENOMEM;
4221 goto out_put_disk;
4222 }
4223
4224 disks[dr]->major = FLOPPY_MAJOR;
4225 disks[dr]->first_minor = TOMINOR(dr);
4226 disks[dr]->fops = &floppy_fops;
4227 sprintf(disks[dr]->disk_name, "fd%d", dr);
4228
4229 init_timer(&motor_off_timer[dr]);
4230 motor_off_timer[dr].data = dr;
4231 motor_off_timer[dr].function = motor_off_callback;
4232 }
4233
1da177e4
LT		 4234 err = register_blkdev(FLOPPY_MAJOR, "fd");
4235 if (err)
8ab5e4c1 4236 goto out_put_disk;
1da177e4 4237
5e50b9ef
OZ		 4238 err = platform_driver_register(&floppy_driver);
4239 if (err)
4240 goto out_unreg_blkdev;
4241
1da177e4
LT		 4242 floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
4243 if (!floppy_queue) {
4244 err = -ENOMEM;
5e50b9ef 4245 goto out_unreg_driver;
1da177e4 4246 }
086fa5ff 4247 blk_queue_max_hw_sectors(floppy_queue, 64);
1da177e4
LT		 4248
4249 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4250 floppy_find, NULL, NULL);
4251
4252 for (i = 0; i < 256; i++)
4253 if (ITYPE(i))
4254 floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4255 else
4256 floppy_sizes[i] = MAX_DISK_SIZE << 1;
4257
4258 reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
4259 config_types();
4260
4261 for (i = 0; i < N_FDC; i++) {
4262 fdc = i;
b87c9e0a 4263 memset(FDCS, 0, sizeof(*FDCS));
1da177e4
LT		 4264 FDCS->dtr = -1;
4265 FDCS->dor = 0x4;
4266#if defined(__sparc__) || defined(__mc68000__)
96534f1d 4267 /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
1da177e4
LT		 4268#ifdef __mc68000__
4269 if (MACH_IS_SUN3X)
4270#endif
4271 FDCS->version = FDC_82072A;
4272#endif
4273 }
4274
4275 use_virtual_dma = can_use_virtual_dma & 1;
1da177e4
LT		 4276 fdc_state[0].address = FDC1;
4277 if (fdc_state[0].address == -1) {
4278 del_timer(&fd_timeout);
4279 err = -ENODEV;
4280 goto out_unreg_region;
4281 }
4282#if N_FDC > 1
4283 fdc_state[1].address = FDC2;
4284#endif
4285
4286 fdc = 0; /* reset fdc in case of unexpected interrupt */
4287 err = floppy_grab_irq_and_dma();
4288 if (err) {
4289 del_timer(&fd_timeout);
4290 err = -EBUSY;
4291 goto out_unreg_region;
4292 }
4293
4294 /* initialise drive state */
4295 for (drive = 0; drive < N_DRIVE; drive++) {
b87c9e0a
JP		 4296 memset(UDRS, 0, sizeof(*UDRS));
4297 memset(UDRWE, 0, sizeof(*UDRWE));
e0298536
JP		 4298 set_bit(FD_DISK_NEWCHANGE_BIT, &UDRS->flags);
4299 set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
4300 set_bit(FD_VERIFY_BIT, &UDRS->flags);
1da177e4
LT		 4301 UDRS->fd_device = -1;
4302 floppy_track_buffer = NULL;
4303 max_buffer_sectors = 0;
4304 }
4305 /*
4306 * Small 10 msec delay to let through any interrupt that
4307 * initialization might have triggered, to not
4308 * confuse detection:
4309 */
4310 msleep(10);
4311
4312 for (i = 0; i < N_FDC; i++) {
4313 fdc = i;
4314 FDCS->driver_version = FD_DRIVER_VERSION;
4315 for (unit = 0; unit < 4; unit++)
4316 FDCS->track[unit] = 0;
4317 if (FDCS->address == -1)
4318 continue;
4319 FDCS->rawcmd = 2;
74f63f46 4320 if (user_reset_fdc(-1, FD_RESET_ALWAYS, false)) {
1da177e4 4321 /* free ioports reserved by floppy_grab_irq_and_dma() */
5a74db06 4322 floppy_release_regions(fdc);
1da177e4
LT		 4323 FDCS->address = -1;
4324 FDCS->version = FDC_NONE;
4325 continue;
4326 }
4327 /* Try to determine the floppy controller type */
4328 FDCS->version = get_fdc_version();
4329 if (FDCS->version == FDC_NONE) {
4330 /* free ioports reserved by floppy_grab_irq_and_dma() */
5a74db06 4331 floppy_release_regions(fdc);
1da177e4
LT		 4332 FDCS->address = -1;
4333 continue;
4334 }
4335 if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
4336 can_use_virtual_dma = 0;
4337
4338 have_no_fdc = 0;
4339 /* Not all FDCs seem to be able to handle the version command
4340 * properly, so force a reset for the standard FDC clones,
4341 * to avoid interrupt garbage.
4342 */
74f63f46 4343 user_reset_fdc(-1, FD_RESET_ALWAYS, false);
1da177e4
LT		 4344 }
4345 fdc = 0;
4346 del_timer(&fd_timeout);
4347 current_drive = 0;
29f1c784 4348 initialized = true;
1da177e4
LT		 4349 if (have_no_fdc) {
4350 DPRINT("no floppy controllers found\n");
4351 err = have_no_fdc;
4352 goto out_flush_work;
4353 }
4354
1da177e4
LT		 4355 for (drive = 0; drive < N_DRIVE; drive++) {
4356 if (!(allowed_drive_mask & (1 << drive)))
4357 continue;
4358 if (fdc_state[FDC(drive)].version == FDC_NONE)
4359 continue;
94fd0db7
HR		 4360
4361 floppy_device[drive].name = floppy_device_name;
4362 floppy_device[drive].id = drive;
4363 floppy_device[drive].dev.release = floppy_device_release;
4364
4365 err = platform_device_register(&floppy_device[drive]);
4366 if (err)
4367 goto out_flush_work;
4368
d7b2b2ec
JP		 4369 err = device_create_file(&floppy_device[drive].dev,
4370 &dev_attr_cmos);
4ea1b0f4
DM		 4371 if (err)
4372 goto out_unreg_platform_dev;
4373
1da177e4
LT		 4374 /* to be cleaned up... */
4375 disks[drive]->private_data = (void *)(long)drive;
4376 disks[drive]->queue = floppy_queue;
4377 disks[drive]->flags |= GENHD_FL_REMOVABLE;
94fd0db7 4378 disks[drive]->driverfs_dev = &floppy_device[drive].dev;
1da177e4
LT		 4379 add_disk(disks[drive]);
4380 }
4381
4382 return 0;
4383
4ea1b0f4
DM		 4384out_unreg_platform_dev:
4385 platform_device_unregister(&floppy_device[drive]);
1da177e4
LT		 4386out_flush_work:
4387 flush_scheduled_work();
4388 if (usage_count)
4389 floppy_release_irq_and_dma();
4390out_unreg_region:
4391 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4392 blk_cleanup_queue(floppy_queue);
5e50b9ef
OZ		 4393out_unreg_driver:
4394 platform_driver_unregister(&floppy_driver);
1da177e4
LT		 4395out_unreg_blkdev:
4396 unregister_blkdev(FLOPPY_MAJOR, "fd");
1da177e4
LT		 4397out_put_disk:
4398 while (dr--) {
4399 del_timer(&motor_off_timer[dr]);
4400 put_disk(disks[dr]);
4401 }
4402 return err;
4403}
4404
4405static DEFINE_SPINLOCK(floppy_usage_lock);
4406
5a74db06
PDM		 4407static const struct io_region {
4408 int offset;
4409 int size;
4410} io_regions[] = {
4411 { 2, 1 },
4412 /* address + 3 is sometimes reserved by pnp bios for motherboard */
4413 { 4, 2 },
4414 /* address + 6 is reserved, and may be taken by IDE.
4415 * Unfortunately, Adaptec doesn't know this :-(, */
4416 { 7, 1 },
4417};
4418
4419static void floppy_release_allocated_regions(int fdc, const struct io_region *p)
4420{
4421 while (p != io_regions) {
4422 p--;
4423 release_region(FDCS->address + p->offset, p->size);
4424 }
4425}
4426
4427#define ARRAY_END(X) (&((X)[ARRAY_SIZE(X)]))
4428
4429static int floppy_request_regions(int fdc)
4430{
4431 const struct io_region *p;
4432
4433 for (p = io_regions; p < ARRAY_END(io_regions); p++) {
bb57f0c6
JP		 4434 if (!request_region(FDCS->address + p->offset,
4435 p->size, "floppy")) {
4436 DPRINT("Floppy io-port 0x%04lx in use\n",
4437 FDCS->address + p->offset);
5a74db06
PDM		 4438 floppy_release_allocated_regions(fdc, p);
4439 return -EBUSY;
4440 }
4441 }
4442 return 0;
4443}
4444
4445static void floppy_release_regions(int fdc)
4446{
4447 floppy_release_allocated_regions(fdc, ARRAY_END(io_regions));
4448}
4449
1da177e4
LT		 4450static int floppy_grab_irq_and_dma(void)
4451{
4452 unsigned long flags;
4453
4454 spin_lock_irqsave(&floppy_usage_lock, flags);
4455 if (usage_count++) {
4456 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4457 return 0;
4458 }
4459 spin_unlock_irqrestore(&floppy_usage_lock, flags);
6dc659d8
IM		 4460
4461 /*
4462 * We might have scheduled a free_irq(), wait it to
4463 * drain first:
4464 */
4465 flush_scheduled_work();
4466
1da177e4
LT		 4467 if (fd_request_irq()) {
4468 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4469 FLOPPY_IRQ);
4470 spin_lock_irqsave(&floppy_usage_lock, flags);
4471 usage_count--;
4472 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4473 return -1;
4474 }
4475 if (fd_request_dma()) {
4476 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4477 FLOPPY_DMA);
2e9c47cd
JB		 4478 if (can_use_virtual_dma & 2)
4479 use_virtual_dma = can_use_virtual_dma = 1;
4480 if (!(can_use_virtual_dma & 1)) {
4481 fd_free_irq();
4482 spin_lock_irqsave(&floppy_usage_lock, flags);
4483 usage_count--;
4484 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4485 return -1;
4486 }
1da177e4
LT		 4487 }
4488
4489 for (fdc = 0; fdc < N_FDC; fdc++) {
4490 if (FDCS->address != -1) {
5a74db06
PDM		 4491 if (floppy_request_regions(fdc))
4492 goto cleanup;
1da177e4
LT		 4493 }
4494 }
4495 for (fdc = 0; fdc < N_FDC; fdc++) {
4496 if (FDCS->address != -1) {
4497 reset_fdc_info(1);
4498 fd_outb(FDCS->dor, FD_DOR);
4499 }
4500 }
4501 fdc = 0;
4502 set_dor(0, ~0, 8); /* avoid immediate interrupt */
4503
4504 for (fdc = 0; fdc < N_FDC; fdc++)
4505 if (FDCS->address != -1)
4506 fd_outb(FDCS->dor, FD_DOR);
4507 /*
06f748c4
JJ		 4508 * The driver will try and free resources and relies on us
4509 * to know if they were allocated or not.
1da177e4
LT		 4510 */
4511 fdc = 0;
4512 irqdma_allocated = 1;
4513 return 0;
5a74db06 4514cleanup:
1da177e4
LT		 4515 fd_free_irq();
4516 fd_free_dma();
5a74db06
PDM		 4517 while (--fdc >= 0)
4518 floppy_release_regions(fdc);
1da177e4
LT		 4519 spin_lock_irqsave(&floppy_usage_lock, flags);
4520 usage_count--;
4521 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4522 return -1;
4523}
4524
4525static void floppy_release_irq_and_dma(void)
4526{
4527 int old_fdc;
4528#ifdef FLOPPY_SANITY_CHECK
4529#ifndef __sparc__
4530 int drive;
4531#endif
4532#endif
4533 long tmpsize;
4534 unsigned long tmpaddr;
4535 unsigned long flags;
4536
4537 spin_lock_irqsave(&floppy_usage_lock, flags);
4538 if (--usage_count) {
4539 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4540 return;
4541 }
4542 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4543 if (irqdma_allocated) {
4544 fd_disable_dma();
4545 fd_free_dma();
3e541a4a 4546 fd_free_irq();
1da177e4
LT		 4547 irqdma_allocated = 0;
4548 }
4549 set_dor(0, ~0, 8);
4550#if N_FDC > 1
4551 set_dor(1, ~8, 0);
4552#endif
4553 floppy_enable_hlt();
4554
4555 if (floppy_track_buffer && max_buffer_sectors) {
4556 tmpsize = max_buffer_sectors * 1024;
4557 tmpaddr = (unsigned long)floppy_track_buffer;
4558 floppy_track_buffer = NULL;
4559 max_buffer_sectors = 0;
4560 buffer_min = buffer_max = -1;
4561 fd_dma_mem_free(tmpaddr, tmpsize);
4562 }
4563#ifdef FLOPPY_SANITY_CHECK
4564#ifndef __sparc__
4565 for (drive = 0; drive < N_FDC * 4; drive++)
4566 if (timer_pending(motor_off_timer + drive))
b46df356 4567 pr_info("motor off timer %d still active\n", drive);
1da177e4
LT		 4568#endif
4569
4570 if (timer_pending(&fd_timeout))
b46df356 4571 pr_info("floppy timer still active:%s\n", timeout_message);
1da177e4 4572 if (timer_pending(&fd_timer))
b46df356 4573 pr_info("auxiliary floppy timer still active\n");
365970a1 4574 if (work_pending(&floppy_work))
b46df356 4575 pr_info("work still pending\n");
1da177e4
LT		 4576#endif
4577 old_fdc = fdc;
4578 for (fdc = 0; fdc < N_FDC; fdc++)
5a74db06
PDM		 4579 if (FDCS->address != -1)
4580 floppy_release_regions(fdc);
1da177e4
LT		 4581 fdc = old_fdc;
4582}
4583
4584#ifdef MODULE
4585
4586static char *floppy;
4587
1da177e4
LT		 4588static void __init parse_floppy_cfg_string(char *cfg)
4589{
4590 char *ptr;
4591
4592 while (*cfg) {
bb57f0c6
JP		 4593 ptr = cfg;
4594 while (*cfg && *cfg != ' ' && *cfg != '\t')
4595 cfg++;
1da177e4
LT		 4596 if (*cfg) {
4597 *cfg = '\0';
4598 cfg++;
4599 }
4600 if (*ptr)
4601 floppy_setup(ptr);
4602 }
4603}
4604
7afea3bc 4605static int __init floppy_module_init(void)
1da177e4
LT		 4606{
4607 if (floppy)
4608 parse_floppy_cfg_string(floppy);
4609 return floppy_init();
4610}
7afea3bc 4611module_init(floppy_module_init);
1da177e4 4612
7afea3bc 4613static void __exit floppy_module_exit(void)
1da177e4
LT		 4614{
4615 int drive;
4616
1da177e4
LT		 4617 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4618 unregister_blkdev(FLOPPY_MAJOR, "fd");
5e50b9ef 4619 platform_driver_unregister(&floppy_driver);
1da177e4
LT		 4620
4621 for (drive = 0; drive < N_DRIVE; drive++) {
4622 del_timer_sync(&motor_off_timer[drive]);
4623
4624 if ((allowed_drive_mask & (1 << drive)) &&
4625 fdc_state[FDC(drive)].version != FDC_NONE) {
4626 del_gendisk(disks[drive]);
94fd0db7
HR		 4627 device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
4628 platform_device_unregister(&floppy_device[drive]);
1da177e4
LT		 4629 }
4630 put_disk(disks[drive]);
4631 }
1da177e4
LT		 4632
4633 del_timer_sync(&fd_timeout);
4634 del_timer_sync(&fd_timer);
4635 blk_cleanup_queue(floppy_queue);
4636
4637 if (usage_count)
4638 floppy_release_irq_and_dma();
4639
4640 /* eject disk, if any */
4641 fd_eject(0);
1da177e4 4642}
48c8cee6 4643
7afea3bc 4644module_exit(floppy_module_exit);
1da177e4
LT		 4645
4646module_param(floppy, charp, 0);
4647module_param(FLOPPY_IRQ, int, 0);
4648module_param(FLOPPY_DMA, int, 0);
4649MODULE_AUTHOR("Alain L. Knaff");
4650MODULE_SUPPORTED_DEVICE("fd");
4651MODULE_LICENSE("GPL");
4652
83f9ef46
SJR		 4653/* This doesn't actually get used other than for module information */
4654static const struct pnp_device_id floppy_pnpids[] = {
48c8cee6
JP		 4655 {"PNP0700", 0},
4656 {}
83f9ef46 4657};
48c8cee6 4658
83f9ef46
SJR		 4659MODULE_DEVICE_TABLE(pnp, floppy_pnpids);
4660
1da177e4
LT		 4661#else
4662
4663__setup("floppy=", floppy_setup);
4664module_init(floppy_init)
4665#endif
4666
4667MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);
Linux kernel - Deliverables
This page took 1.150531 seconds and 5 git commands to generate.