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