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