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