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