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