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(wq: floppy_wq, dwork: &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(lock: &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(nr: FD_VERIFY_BIT, addr: &drive_state[drive].flags);
758	/* verify write protection */
759
760	if (drive_state[drive].maxblock) /* mark it changed */
761	set_bit(nr: FD_DISK_CHANGED_BIT,
762	addr: &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(nr: FD_DISK_NEWCHANGE_BIT, addr: &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(dor: olddor, unit) && !is_selected(dor: 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(value: newdor, fdc, FD_DOR);
814
815	unit = newdor & 0x3;
816	if (!is_selected(dor: olddor, unit) && is_selected(dor: 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(value: fdc_state[fdc].dor & ~(0x10 << UNIT(drive)),
829	fdc, FD_DOR);
830	fdc_outb(value: 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, mask: ~0, data: 8);
872	#if N_FDC > 1
873	set_dor(fdc: 1 - fdc, mask: ~8, data: 0);
874	#endif
875	if (fdc_state[fdc].rawcmd == 2)
876	reset_fdc_info(fdc, mode: 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, message: "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(dwork: &fd_timeout);
913	do_floppy = NULL;
914	cont = NULL;
915	clear_bit(nr: 0, addr: &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, data: 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(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(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(fdc: current_fdc, mask: ~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(fdc: current_fdc, mask: ~(0x10 << UNIT(drive)), data: 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(wq: floppy_wq, work: &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(dwork: &fd_timer);
1021	cancel_work_sync(work: &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(drive: 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(dwork: &fd_timer);
1038	fd_timer_fn = fd_watchdog;
1039	queue_delayed_work(wq: floppy_wq, dwork: &fd_timer, HZ / 10);
1040	}
1041	}
1042
1043	static void main_command_interrupt(void)
1044	{
1045	cancel_delayed_work(dwork: &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(dwork: &fd_timer);
1062	fd_timer_fn = function;
1063	queue_delayed_work(wq: floppy_wq, dwork: &fd_timer, delay: 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, prefix_str: "zero dma transfer size: ",
1075	prefix_type: DUMP_PREFIX_NONE, rowsize: 16, groupsize: 1,
1076	buf: raw_cmd->fullcmd, len: raw_cmd->cmd_count, ascii: 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(flags: f);
1095	cont->done(0);
1096	fdc_state[current_fdc].reset = 1;
1097	return;
1098	}
1099	release_dma_lock(flags: 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(value: 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, byte: 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, byte: 0);
1256	output_byte(fdc, byte: 0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1257	output_byte(fdc, byte: 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, byte: 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, byte: fdc_state[fdc].spec1 = spec1);
1359	output_byte(fdc, byte: 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(value: raw_cmd->rate & 3, fdc: 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(expires: jiffies + 2UL * HZ / 100, function: 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(nr: FD_DISK_WRITABLE_BIT,
1450	addr: &drive_state[current_drive].flags);
1451	cont->done(0);
1452	bad = 2;
1453	} else if (reply_buffer[ST1] & ST1_ND) {
1454	set_bit(nr: FD_NEED_TWADDLE_BIT,
1455	addr: &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(expires: 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(fdc: current_fdc, byte: raw_cmd->fullcmd[i]);
1522
1523	debugt(func: __func__, msg: "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(fdc: 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: __func__, msg: "");
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(nr: FD_DISK_NEWCHANGE_BIT,
1562	addr: &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(nr: FD_VERIFY_BIT, addr: &drive_state[drive].flags);
1581	clear_bit(nr: FD_NEED_TWADDLE_BIT,
1582	addr: &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(nr: FD_DISK_WRITABLE_BIT,
1589	addr: &drive_state[drive].flags);
1590	else
1591	clear_bit(nr: FD_DISK_WRITABLE_BIT,
1592	addr: &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(drive: 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(nr: FD_DISK_CHANGED_BIT,
1612	addr: &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(fdc: current_fdc, mask: ~(0x10 << UNIT(current_drive)), data: 0);
1630	blind_seek = 1;
1631	raw_cmd->flags |= FD_RAW_NEED_SEEK;
1632	}
1633	track = 1;
1634	}
1635	} else {
1636	check_wp(fdc: current_fdc, drive: 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(fdc: current_fdc, FD_SEEK);
1648	output_byte(fdc: current_fdc, UNIT(current_drive));
1649	if (output_byte(fdc: current_fdc, byte: track) < 0) {
1650	reset_fdc();
1651	return;
1652	}
1653	debugt(func: __func__, msg: "");
1654	}
1655
1656	static void recal_interrupt(void)
1657	{
1658	debugt(func: __func__, msg: "");
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: __func__, msg: "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: __func__, msg: "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(nr: FD_DISK_NEWCHANGE_BIT,
1684	addr: &drive_state[current_drive].flags);
1685	drive_state[current_drive].select_date = jiffies;
1686	fallthrough;
1687	default:
1688	debugt(func: __func__, msg: "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(flags: 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: __func__, message: "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(fdc: current_fdc);
1751	if (do_print)
1752	print_result(message: "unexpected interrupt", inr);
1753	if (inr == 0) {
1754	int max_sensei = 4;
1755	do {
1756	output_byte(fdc: current_fdc, FD_SENSEI);
1757	inr = result(fdc: current_fdc);
1758	if (do_print)
1759	print_result(message: "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: __func__, message: "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: __func__, msg: "");
1778	do_floppy = recal_interrupt;
1779	output_byte(fdc: current_fdc, FD_RECALIBRATE);
1780	if (output_byte(fdc: 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: __func__, msg: "");
1790	result(fdc: 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(fdc: current_fdc, mode: 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(value: 0x80 | (fdc_state[current_fdc].dtr & 3),
1821	fdc: current_fdc, FD_STATUS);
1822	else {
1823	fdc_outb(value: fdc_state[current_fdc].dor & ~0x04, fdc: current_fdc, FD_DOR);
1824	udelay(FD_RESET_DELAY);
1825	fdc_outb(value: fdc_state[current_fdc].dor, fdc: 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, prefix_str: "", prefix_type: DUMP_PREFIX_NONE, rowsize: 16, groupsize: 1,
1850	buf: reply_buffer, len: resultsize, ascii: 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(fdc: 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: __func__, message: "");
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(timer: motor_off_timer + current_drive);
1922	set_dor(fdc: current_fdc, mask, data);
1923
1924	/* wait_for_completion also schedules reset if needed. */
1925	return fd_wait_for_completion(expires: 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(function: 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(drive: current_drive) && !drive_params[current_drive].select_delay)
1944	twaddle(fdc: current_fdc, drive: 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(fdc: current_fdc);
1957	fdc_specify(fdc: current_fdc, drive: 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(fdc: current_fdc, drive: current_drive);
1963	setup_rw_floppy();
1964	}
1965	}
1966
1967	static void floppy_start(void)
1968	{
1969	reschedule_timeout(drive: current_drive, message: "floppy start");
1970
1971	scandrives();
1972	debug_dcl(drive_params[current_drive].flags,
1973	"setting NEWCHANGE in floppy_start\n");
1974	set_bit(nr: FD_DISK_NEWCHANGE_BIT, addr: &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, message: "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(drive: 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: __func__, msg: "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(handler: redo_format, interruptible: 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(rq: req);
2268	if (blk_update_request(rq: req, error, nr_bytes: nr_sectors << 9))
2269	return;
2270	__blk_mq_end_request(rq: 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(buf: msg, size: sizeof(msg), fmt: "request done %d", uptodate);
2287	reschedule_timeout(MAXTIMEOUT, message: 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(rq: 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, error: 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(rq: 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(rq: 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	max_size: blk_rq_sectors(rq: current_req));
2441
2442	if (current_count_sectors <= 0 && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE &&
2443	buffer_max > fsector_t + blk_rq_sectors(rq: 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(rq: 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(rq: 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(bvec: &bv, from: dma_buffer);
2490	else
2491	memcpy_from_bvec(to: dma_buffer, bvec: &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(rq: current_req) / max_sector;
2571	fsector_t = (int)blk_rq_pos(rq: current_req) % max_sector;
2572	if (_floppy->track && raw_cmd->cmd[TRACK] >= _floppy->track) {
2573	if (blk_rq_cur_sectors(rq: 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(rq: 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(ssize: 1, max_sector, max_sector_2: buffer_max);
2651	return 1;
2652	}
2653	} else if (in_sector_offset || blk_rq_sectors(rq: current_req) < ssize) {
2654	if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2655	unsigned int sectors;
2656
2657	sectors = fsector_t + blk_rq_sectors(rq: 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(rq: 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	max_sector_2: 2 * max_buffer_sectors + buffer_min);
2699	} else
2700	transfer_size(ssize, max_sector,
2701	max_size: 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(entry: &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(drive: current_drive);
2781
2782	do_request:
2783	if (!current_req) {
2784	int pending;
2785
2786	spin_lock_irq(lock: &floppy_lock);
2787	pending = set_next_request();
2788	spin_unlock_irq(lock: &floppy_lock);
2789	if (!pending) {
2790	unlock_fdc();
2791	return;
2792	}
2793	}
2794	drive = (long)current_req->q->disk->private_data;
2795	set_fdc(drive);
2796	reschedule_timeout(drive: current_drive, message: "redo fd request");
2797
2798	set_floppy(drive);
2799	raw_cmd = &default_raw_cmd;
2800	raw_cmd->flags = 0;
2801	if (start_motor(function: redo_fd_request))
2802	return;
2803
2804	disk_change(drive: current_drive);
2805	if (test_bit(current_drive, &fake_change) ||
2806	test_bit(FD_DISK_CHANGED_BIT, &drive_state[current_drive].flags)) {
2807	DPRINT("disk absent or changed during operation\n");
2808	request_done(uptodate: 0);
2809	goto do_request;
2810	}
2811	if (!_floppy) { /* Autodetection */
2812	if (!probing) {
2813	drive_state[current_drive].probed_format = 0;
2814	if (next_valid_format(drive: current_drive)) {
2815	DPRINT("no autodetectable formats\n");
2816	_floppy = NULL;
2817	request_done(uptodate: 0);
2818	goto do_request;
2819	}
2820	}
2821	probing = 1;
2822	_floppy = floppy_type + drive_params[current_drive].autodetect[drive_state[current_drive].probed_format];
2823	} else
2824	probing = 0;
2825	tmp = make_raw_rw_request();
2826	if (tmp < 2) {
2827	request_done(uptodate: tmp);
2828	goto do_request;
2829	}
2830
2831	if (test_bit(FD_NEED_TWADDLE_BIT, &drive_state[current_drive].flags))
2832	twaddle(fdc: current_fdc, drive: current_drive);
2833	schedule_bh(handler: floppy_start);
2834	debugt(func: __func__, msg: "queue fd request");
2835	return;
2836	}
2837
2838	static const struct cont_t rw_cont = {
2839	.interrupt = rw_interrupt,
2840	.redo = redo_fd_request,
2841	.error = bad_flp_intr,
2842	.done = request_done
2843	};
2844
2845	/* schedule the request and automatically unlock the driver on completion */
2846	static void process_fd_request(void)
2847	{
2848	cont = &rw_cont;
2849	schedule_bh(handler: redo_fd_request);
2850	}
2851
2852	static blk_status_t floppy_queue_rq(struct blk_mq_hw_ctx *hctx,
2853	const struct blk_mq_queue_data *bd)
2854	{
2855	blk_mq_start_request(rq: bd->rq);
2856
2857	if (WARN(max_buffer_sectors == 0,
2858	"VFS: %s called on non-open device\n", __func__))
2859	return BLK_STS_IOERR;
2860
2861	if (WARN(atomic_read(&usage_count) == 0,
2862	"warning: usage count=0, current_req=%p sect=%ld flags=%llx\n",
2863	current_req, (long)blk_rq_pos(current_req),
2864	(__force unsigned long long) current_req->cmd_flags))
2865	return BLK_STS_IOERR;
2866
2867	if (test_and_set_bit(nr: 0, addr: &fdc_busy)) {
2868	/* fdc busy, this new request will be treated when the
2869	current one is done */
2870	is_alive(func: __func__, message: "old request running");
2871	return BLK_STS_RESOURCE;
2872	}
2873
2874	spin_lock_irq(lock: &floppy_lock);
2875	list_add_tail(new: &bd->rq->queuelist, head: &floppy_reqs);
2876	spin_unlock_irq(lock: &floppy_lock);
2877
2878	command_status = FD_COMMAND_NONE;
2879	__reschedule_timeout(MAXTIMEOUT, message: "fd_request");
2880	set_fdc(0);
2881	process_fd_request();
2882	is_alive(func: __func__, message: "");
2883	return BLK_STS_OK;
2884	}
2885
2886	static const struct cont_t poll_cont = {
2887	.interrupt = success_and_wakeup,
2888	.redo = floppy_ready,
2889	.error = generic_failure,
2890	.done = generic_done
2891	};
2892
2893	static int poll_drive(bool interruptible, int flag)
2894	{
2895	/* no auto-sense, just clear dcl */
2896	raw_cmd = &default_raw_cmd;
2897	raw_cmd->flags = flag;
2898	raw_cmd->track = 0;
2899	raw_cmd->cmd_count = 0;
2900	cont = &poll_cont;
2901	debug_dcl(drive_params[current_drive].flags,
2902	"setting NEWCHANGE in poll_drive\n");
2903	set_bit(nr: FD_DISK_NEWCHANGE_BIT, addr: &drive_state[current_drive].flags);
2904
2905	return wait_til_done(handler: floppy_ready, interruptible);
2906	}
2907
2908	/*
2909	* User triggered reset
2910	* ====================
2911	*/
2912
2913	static void reset_intr(void)
2914	{
2915	pr_info("weird, reset interrupt called\n");
2916	}
2917
2918	static const struct cont_t reset_cont = {
2919	.interrupt = reset_intr,
2920	.redo = success_and_wakeup,
2921	.error = generic_failure,
2922	.done = generic_done
2923	};
2924
2925	/*
2926	* Resets the FDC connected to drive <drive>.
2927	* Both current_drive and current_fdc are changed to match the new drive.
2928	*/
2929	static int user_reset_fdc(int drive, int arg, bool interruptible)
2930	{
2931	int ret;
2932
2933	if (lock_fdc(drive))
2934	return -EINTR;
2935
2936	if (arg == FD_RESET_ALWAYS)
2937	fdc_state[current_fdc].reset = 1;
2938	if (fdc_state[current_fdc].reset) {
2939	/* note: reset_fdc will take care of unlocking the driver
2940	* on completion.
2941	*/
2942	cont = &reset_cont;
2943	ret = wait_til_done(handler: reset_fdc, interruptible);
2944	if (ret == -EINTR)
2945	return -EINTR;
2946	}
2947	process_fd_request();
2948	return 0;
2949	}
2950
2951	/*
2952	* Misc Ioctl's and support
2953	* ========================
2954	*/
2955	static inline int fd_copyout(void __user *param, const void *address,
2956	unsigned long size)
2957	{
2958	return copy_to_user(to: param, from: address, n: size) ? -EFAULT : 0;
2959	}
2960
2961	static inline int fd_copyin(void __user *param, void *address,
2962	unsigned long size)
2963	{
2964	return copy_from_user(to: address, from: param, n: size) ? -EFAULT : 0;
2965	}
2966
2967	static const char *drive_name(int type, int drive)
2968	{
2969	struct floppy_struct *floppy;
2970
2971	if (type)
2972	floppy = floppy_type + type;
2973	else {
2974	if (drive_params[drive].native_format)
2975	floppy = floppy_type + drive_params[drive].native_format;
2976	else
2977	return "(null)";
2978	}
2979	if (floppy->name)
2980	return floppy->name;
2981	else
2982	return "(null)";
2983	}
2984
2985	#ifdef CONFIG_BLK_DEV_FD_RAWCMD
2986
2987	/* raw commands */
2988	static void raw_cmd_done(int flag)
2989	{
2990	if (!flag) {
2991	raw_cmd->flags |= FD_RAW_FAILURE;
2992	raw_cmd->flags |= FD_RAW_HARDFAILURE;
2993	} else {
2994	raw_cmd->reply_count = inr;
2995	if (raw_cmd->reply_count > FD_RAW_REPLY_SIZE)
2996	raw_cmd->reply_count = 0;
2997	memcpy(raw_cmd->reply, reply_buffer, raw_cmd->reply_count);
2998
2999	if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3000	unsigned long flags;
3001	flags = claim_dma_lock();
3002	raw_cmd->length = fd_get_dma_residue();
3003	release_dma_lock(flags);
3004	}
3005
3006	if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3007	(!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3008	raw_cmd->flags |= FD_RAW_FAILURE;
3009
3010	if (disk_change(drive: current_drive))
3011	raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3012	else
3013	raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3014	if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3015	motor_off_callback(t: &motor_off_timer[current_drive]);
3016
3017	if (raw_cmd->next &&
3018	(!(raw_cmd->flags & FD_RAW_FAILURE) ||
3019	!(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3020	((raw_cmd->flags & FD_RAW_FAILURE) ||
3021	!(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3022	raw_cmd = raw_cmd->next;
3023	return;
3024	}
3025	}
3026	generic_done(result: flag);
3027	}
3028
3029	static const struct cont_t raw_cmd_cont = {
3030	.interrupt = success_and_wakeup,
3031	.redo = floppy_start,
3032	.error = generic_failure,
3033	.done = raw_cmd_done
3034	};
3035
3036	static int raw_cmd_copyout(int cmd, void __user *param,
3037	struct floppy_raw_cmd *ptr)
3038	{
3039	int ret;
3040
3041	while (ptr) {
3042	struct floppy_raw_cmd cmd = *ptr;
3043	cmd.next = NULL;
3044	cmd.kernel_data = NULL;
3045	ret = copy_to_user(to: param, from: &cmd, n: sizeof(cmd));
3046	if (ret)
3047	return -EFAULT;
3048	param += sizeof(struct floppy_raw_cmd);
3049	if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3050	if (ptr->length >= 0 &&
3051	ptr->length <= ptr->buffer_length) {
3052	long length = ptr->buffer_length - ptr->length;
3053	ret = fd_copyout(param: ptr->data, address: ptr->kernel_data,
3054	size: length);
3055	if (ret)
3056	return ret;
3057	}
3058	}
3059	ptr = ptr->next;
3060	}
3061
3062	return 0;
3063	}
3064
3065	static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3066	{
3067	struct floppy_raw_cmd *next;
3068	struct floppy_raw_cmd *this;
3069
3070	this = *ptr;
3071	*ptr = NULL;
3072	while (this) {
3073	if (this->buffer_length) {
3074	fd_dma_mem_free((unsigned long)this->kernel_data,
3075	this->buffer_length);
3076	this->buffer_length = 0;
3077	}
3078	next = this->next;
3079	kfree(objp: this);
3080	this = next;
3081	}
3082	}
3083
3084	#define MAX_LEN (1UL << MAX_PAGE_ORDER << PAGE_SHIFT)
3085
3086	static int raw_cmd_copyin(int cmd, void __user *param,
3087	struct floppy_raw_cmd **rcmd)
3088	{
3089	struct floppy_raw_cmd *ptr;
3090	int ret;
3091
3092	*rcmd = NULL;
3093
3094	loop:
3095	ptr = kmalloc(size: sizeof(struct floppy_raw_cmd), GFP_KERNEL);
3096	if (!ptr)
3097	return -ENOMEM;
3098	*rcmd = ptr;
3099	ret = copy_from_user(to: ptr, from: param, n: sizeof(*ptr));
3100	ptr->next = NULL;
3101	ptr->buffer_length = 0;
3102	ptr->kernel_data = NULL;
3103	if (ret)
3104	return -EFAULT;
3105	param += sizeof(struct floppy_raw_cmd);
3106	if (ptr->cmd_count > FD_RAW_CMD_FULLSIZE)
3107	return -EINVAL;
3108
3109	memset(ptr->reply, 0, FD_RAW_REPLY_SIZE);
3110	ptr->resultcode = 0;
3111
3112	if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3113	if (ptr->length <= 0 || ptr->length > MAX_LEN)
3114	return -EINVAL;
3115	ptr->kernel_data = (char *)fd_dma_mem_alloc(ptr->length);
3116	fallback_on_nodma_alloc(addr: &ptr->kernel_data, l: ptr->length);
3117	if (!ptr->kernel_data)
3118	return -ENOMEM;
3119	ptr->buffer_length = ptr->length;
3120	}
3121	if (ptr->flags & FD_RAW_WRITE) {
3122	ret = fd_copyin(param: ptr->data, address: ptr->kernel_data, size: ptr->length);
3123	if (ret)
3124	return ret;
3125	}
3126
3127	if (ptr->flags & FD_RAW_MORE) {
3128	rcmd = &(ptr->next);
3129	ptr->rate &= 0x43;
3130	goto loop;
3131	}
3132
3133	return 0;
3134	}
3135
3136	static int raw_cmd_ioctl(int cmd, void __user *param)
3137	{
3138	struct floppy_raw_cmd *my_raw_cmd;
3139	int drive;
3140	int ret2;
3141	int ret;
3142
3143	if (fdc_state[current_fdc].rawcmd <= 1)
3144	fdc_state[current_fdc].rawcmd = 1;
3145	for (drive = 0; drive < N_DRIVE; drive++) {
3146	if (FDC(drive) != current_fdc)
3147	continue;
3148	if (drive == current_drive) {
3149	if (drive_state[drive].fd_ref > 1) {
3150	fdc_state[current_fdc].rawcmd = 2;
3151	break;
3152	}
3153	} else if (drive_state[drive].fd_ref) {
3154	fdc_state[current_fdc].rawcmd = 2;
3155	break;
3156	}
3157	}
3158
3159	if (fdc_state[current_fdc].reset)
3160	return -EIO;
3161
3162	ret = raw_cmd_copyin(cmd, param, rcmd: &my_raw_cmd);
3163	if (ret) {
3164	raw_cmd_free(ptr: &my_raw_cmd);
3165	return ret;
3166	}
3167
3168	raw_cmd = my_raw_cmd;
3169	cont = &raw_cmd_cont;
3170	ret = wait_til_done(handler: floppy_start, interruptible: true);
3171	debug_dcl(drive_params[current_drive].flags,
3172	"calling disk change from raw_cmd ioctl\n");
3173
3174	if (ret != -EINTR && fdc_state[current_fdc].reset)
3175	ret = -EIO;
3176
3177	drive_state[current_drive].track = NO_TRACK;
3178
3179	ret2 = raw_cmd_copyout(cmd, param, ptr: my_raw_cmd);
3180	if (!ret)
3181	ret = ret2;
3182	raw_cmd_free(ptr: &my_raw_cmd);
3183	return ret;
3184	}
3185
3186	static int floppy_raw_cmd_ioctl(int type, int drive, int cmd,
3187	void __user *param)
3188	{
3189	int ret;
3190
3191	pr_warn_once("Note: FDRAWCMD is deprecated and will be removed from the kernel in the near future.\n");
3192
3193	if (type)
3194	return -EINVAL;
3195	if (lock_fdc(drive))
3196	return -EINTR;
3197	set_floppy(drive);
3198	ret = raw_cmd_ioctl(cmd, param);
3199	if (ret == -EINTR)
3200	return -EINTR;
3201	process_fd_request();
3202	return ret;
3203	}
3204
3205	#else /* CONFIG_BLK_DEV_FD_RAWCMD */
3206
3207	static int floppy_raw_cmd_ioctl(int type, int drive, int cmd,
3208	void __user *param)
3209	{
3210	return -EOPNOTSUPP;
3211	}
3212
3213	#endif
3214
3215	static int invalidate_drive(struct gendisk *disk)
3216	{
3217	/* invalidate the buffer track to force a reread */
3218	set_bit(nr: (long)disk->private_data, addr: &fake_change);
3219	process_fd_request();
3220	if (disk_check_media_change(disk)) {
3221	bdev_mark_dead(bdev: disk->part0, surprise: true);
3222	floppy_revalidate(disk);
3223	}
3224	return 0;
3225	}
3226
3227	static int set_geometry(unsigned int cmd, struct floppy_struct *g,
3228	int drive, int type, struct block_device *bdev)
3229	{
3230	int cnt;
3231
3232	/* sanity checking for parameters. */
3233	if ((int)g->sect <= 0 ||
3234	(int)g->head <= 0 ||
3235	/* check for overflow in max_sector */
3236	(int)(g->sect * g->head) <= 0 ||
3237	/* check for zero in raw_cmd->cmd[F_SECT_PER_TRACK] */
3238	(unsigned char)((g->sect << 2) >> FD_SIZECODE(g)) == 0 ||
3239	g->track <= 0 || g->track > drive_params[drive].tracks >> STRETCH(g) ||
3240	/* check if reserved bits are set */
3241	(g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0)
3242	return -EINVAL;
3243	if (type) {
3244	if (!capable(CAP_SYS_ADMIN))
3245	return -EPERM;
3246	mutex_lock(&open_lock);
3247	if (lock_fdc(drive)) {
3248	mutex_unlock(lock: &open_lock);
3249	return -EINTR;
3250	}
3251	floppy_type[type] = *g;
3252	floppy_type[type].name = "user format";
3253	for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3254	floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3255	floppy_type[type].size + 1;
3256	process_fd_request();
3257	for (cnt = 0; cnt < N_DRIVE; cnt++) {
3258	struct gendisk *disk = opened_disk[cnt];
3259
3260	if (!disk || ITYPE(drive_state[cnt].fd_device) != type)
3261	continue;
3262	disk_force_media_change(disk);
3263	}
3264	mutex_unlock(lock: &open_lock);
3265	} else {
3266	int oldStretch;
3267
3268	if (lock_fdc(drive))
3269	return -EINTR;
3270	if (cmd != FDDEFPRM) {
3271	/* notice a disk change immediately, else
3272	* we lose our settings immediately*/
3273	if (poll_drive(interruptible: true, FD_RAW_NEED_DISK) == -EINTR)
3274	return -EINTR;
3275	}
3276	oldStretch = g->stretch;
3277	user_params[drive] = *g;
3278	if (buffer_drive == drive)
3279	SUPBOUND(buffer_max, user_params[drive].sect);
3280	current_type[drive] = &user_params[drive];
3281	floppy_sizes[drive] = user_params[drive].size;
3282	if (cmd == FDDEFPRM)
3283	drive_state[current_drive].keep_data = -1;
3284	else
3285	drive_state[current_drive].keep_data = 1;
3286	/* invalidation. Invalidate only when needed, i.e.
3287	* when there are already sectors in the buffer cache
3288	* whose number will change. This is useful, because
3289	* mtools often changes the geometry of the disk after
3290	* looking at the boot block */
3291	if (drive_state[current_drive].maxblock > user_params[drive].sect ||
3292	drive_state[current_drive].maxtrack ||
3293	((user_params[drive].sect ^ oldStretch) &
3294	(FD_SWAPSIDES | FD_SECTBASEMASK)))
3295	invalidate_drive(disk: bdev->bd_disk);
3296	else
3297	process_fd_request();
3298	}
3299	return 0;
3300	}
3301
3302	/* handle obsolete ioctl's */
3303	static unsigned int ioctl_table[] = {
3304	FDCLRPRM,
3305	FDSETPRM,
3306	FDDEFPRM,
3307	FDGETPRM,
3308	FDMSGON,
3309	FDMSGOFF,
3310	FDFMTBEG,
3311	FDFMTTRK,
3312	FDFMTEND,
3313	FDSETEMSGTRESH,
3314	FDFLUSH,
3315	FDSETMAXERRS,
3316	FDGETMAXERRS,
3317	FDGETDRVTYP,
3318	FDSETDRVPRM,
3319	FDGETDRVPRM,
3320	FDGETDRVSTAT,
3321	FDPOLLDRVSTAT,
3322	FDRESET,
3323	FDGETFDCSTAT,
3324	FDWERRORCLR,
3325	FDWERRORGET,
3326	FDRAWCMD,
3327	FDEJECT,
3328	FDTWADDLE
3329	};
3330
3331	static int normalize_ioctl(unsigned int *cmd, int *size)
3332	{
3333	int i;
3334
3335	for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3336	if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3337	*size = _IOC_SIZE(*cmd);
3338	*cmd = ioctl_table[i];
3339	if (*size > _IOC_SIZE(*cmd)) {
3340	pr_info("ioctl not yet supported\n");
3341	return -EFAULT;
3342	}
3343	return 0;
3344	}
3345	}
3346	return -EINVAL;
3347	}
3348
3349	static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3350	{
3351	if (type)
3352	*g = &floppy_type[type];
3353	else {
3354	if (lock_fdc(drive))
3355	return -EINTR;
3356	if (poll_drive(interruptible: false, flag: 0) == -EINTR)
3357	return -EINTR;
3358	process_fd_request();
3359	*g = current_type[drive];
3360	}
3361	if (!*g)
3362	return -ENODEV;
3363	return 0;
3364	}
3365
3366	static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3367	{
3368	int drive = (long)bdev->bd_disk->private_data;
3369	int type = ITYPE(drive_state[drive].fd_device);
3370	struct floppy_struct *g;
3371	int ret;
3372
3373	ret = get_floppy_geometry(drive, type, g: &g);
3374	if (ret)
3375	return ret;
3376
3377	geo->heads = g->head;
3378	geo->sectors = g->sect;
3379	geo->cylinders = g->track;
3380	return 0;
3381	}
3382
3383	static bool valid_floppy_drive_params(const short autodetect[FD_AUTODETECT_SIZE],
3384	int native_format)
3385	{
3386	size_t floppy_type_size = ARRAY_SIZE(floppy_type);
3387	size_t i = 0;
3388
3389	for (i = 0; i < FD_AUTODETECT_SIZE; ++i) {
3390	if (autodetect[i] < 0 ||
3391	autodetect[i] >= floppy_type_size)
3392	return false;
3393	}
3394
3395	if (native_format < 0 || native_format >= floppy_type_size)
3396	return false;
3397
3398	return true;
3399	}
3400
3401	static int fd_locked_ioctl(struct block_device *bdev, blk_mode_t mode,
3402	unsigned int cmd, unsigned long param)
3403	{
3404	int drive = (long)bdev->bd_disk->private_data;
3405	int type = ITYPE(drive_state[drive].fd_device);
3406	int ret;
3407	int size;
3408	union inparam {
3409	struct floppy_struct g; /* geometry */
3410	struct format_descr f;
3411	struct floppy_max_errors max_errors;
3412	struct floppy_drive_params dp;
3413	} inparam; /* parameters coming from user space */
3414	const void *outparam; /* parameters passed back to user space */
3415
3416	/* convert compatibility eject ioctls into floppy eject ioctl.
3417	* We do this in order to provide a means to eject floppy disks before
3418	* installing the new fdutils package */
3419	if (cmd == CDROMEJECT || /* CD-ROM eject */
3420	cmd == 0x6470) { /* SunOS floppy eject */
3421	DPRINT("obsolete eject ioctl\n");
3422	DPRINT("please use floppycontrol --eject\n");
3423	cmd = FDEJECT;
3424	}
3425
3426	if (!((cmd & 0xff00) == 0x0200))
3427	return -EINVAL;
3428
3429	/* convert the old style command into a new style command */
3430	ret = normalize_ioctl(cmd: &cmd, size: &size);
3431	if (ret)
3432	return ret;
3433
3434	/* permission checks */
3435	if (((cmd & 0x40) &&
3436	!(mode & (BLK_OPEN_WRITE | BLK_OPEN_WRITE_IOCTL))) ||
3437	((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3438	return -EPERM;
3439
3440	if (WARN_ON(size < 0 || size > sizeof(inparam)))
3441	return -EINVAL;
3442
3443	/* copyin */
3444	memset(&inparam, 0, sizeof(inparam));
3445	if (_IOC_DIR(cmd) & _IOC_WRITE) {
3446	ret = fd_copyin(param: (void __user *)param, address: &inparam, size);
3447	if (ret)
3448	return ret;
3449	}
3450
3451	switch (cmd) {
3452	case FDEJECT:
3453	if (drive_state[drive].fd_ref != 1)
3454	/* somebody else has this drive open */
3455	return -EBUSY;
3456	if (lock_fdc(drive))
3457	return -EINTR;
3458
3459	/* do the actual eject. Fails on
3460	* non-Sparc architectures */
3461	ret = fd_eject(UNIT(drive));
3462
3463	set_bit(nr: FD_DISK_CHANGED_BIT, addr: &drive_state[drive].flags);
3464	set_bit(nr: FD_VERIFY_BIT, addr: &drive_state[drive].flags);
3465	process_fd_request();
3466	return ret;
3467	case FDCLRPRM:
3468	if (lock_fdc(drive))
3469	return -EINTR;
3470	current_type[drive] = NULL;
3471	floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3472	drive_state[drive].keep_data = 0;
3473	return invalidate_drive(disk: bdev->bd_disk);
3474	case FDSETPRM:
3475	case FDDEFPRM:
3476	return set_geometry(cmd, g: &inparam.g, drive, type, bdev);
3477	case FDGETPRM:
3478	ret = get_floppy_geometry(drive, type,
3479	g: (struct floppy_struct **)&outparam);
3480	if (ret)
3481	return ret;
3482	memcpy(&inparam.g, outparam,
3483	offsetof(struct floppy_struct, name));
3484	outparam = &inparam.g;
3485	break;
3486	case FDMSGON:
3487	drive_params[drive].flags |= FTD_MSG;
3488	return 0;
3489	case FDMSGOFF:
3490	drive_params[drive].flags &= ~FTD_MSG;
3491	return 0;
3492	case FDFMTBEG:
3493	if (lock_fdc(drive))
3494	return -EINTR;
3495	if (poll_drive(interruptible: true, FD_RAW_NEED_DISK) == -EINTR)
3496	return -EINTR;
3497	ret = drive_state[drive].flags;
3498	process_fd_request();
3499	if (ret & FD_VERIFY)
3500	return -ENODEV;
3501	if (!(ret & FD_DISK_WRITABLE))
3502	return -EROFS;
3503	return 0;
3504	case FDFMTTRK:
3505	if (drive_state[drive].fd_ref != 1)
3506	return -EBUSY;
3507	return do_format(drive, tmp_format_req: &inparam.f);
3508	case FDFMTEND:
3509	case FDFLUSH:
3510	if (lock_fdc(drive))
3511	return -EINTR;
3512	return invalidate_drive(disk: bdev->bd_disk);
3513	case FDSETEMSGTRESH:
3514	drive_params[drive].max_errors.reporting = (unsigned short)(param & 0x0f);
3515	return 0;
3516	case FDGETMAXERRS:
3517	outparam = &drive_params[drive].max_errors;
3518	break;
3519	case FDSETMAXERRS:
3520	drive_params[drive].max_errors = inparam.max_errors;
3521	break;
3522	case FDGETDRVTYP:
3523	outparam = drive_name(type, drive);
3524	SUPBOUND(size, strlen((const char *)outparam) + 1);
3525	break;
3526	case FDSETDRVPRM:
3527	if (!valid_floppy_drive_params(autodetect: inparam.dp.autodetect,
3528	native_format: inparam.dp.native_format))
3529	return -EINVAL;
3530	drive_params[drive] = inparam.dp;
3531	break;
3532	case FDGETDRVPRM:
3533	outparam = &drive_params[drive];
3534	break;
3535	case FDPOLLDRVSTAT:
3536	if (lock_fdc(drive))
3537	return -EINTR;
3538	if (poll_drive(interruptible: true, FD_RAW_NEED_DISK) == -EINTR)
3539	return -EINTR;
3540	process_fd_request();
3541	fallthrough;
3542	case FDGETDRVSTAT:
3543	outparam = &drive_state[drive];
3544	break;
3545	case FDRESET:
3546	return user_reset_fdc(drive, arg: (int)param, interruptible: true);
3547	case FDGETFDCSTAT:
3548	outparam = &fdc_state[FDC(drive)];
3549	break;
3550	case FDWERRORCLR:
3551	memset(&write_errors[drive], 0, sizeof(write_errors[drive]));
3552	return 0;
3553	case FDWERRORGET:
3554	outparam = &write_errors[drive];
3555	break;
3556	case FDRAWCMD:
3557	return floppy_raw_cmd_ioctl(type, drive, cmd, param: (void __user *)param);
3558	case FDTWADDLE:
3559	if (lock_fdc(drive))
3560	return -EINTR;
3561	twaddle(fdc: current_fdc, drive: current_drive);
3562	process_fd_request();
3563	return 0;
3564	default:
3565	return -EINVAL;
3566	}
3567
3568	if (_IOC_DIR(cmd) & _IOC_READ)
3569	return fd_copyout(param: (void __user *)param, address: outparam, size);
3570
3571	return 0;
3572	}
3573
3574	static int fd_ioctl(struct block_device *bdev, blk_mode_t mode,
3575	unsigned int cmd, unsigned long param)
3576	{
3577	int ret;
3578
3579	mutex_lock(&floppy_mutex);
3580	ret = fd_locked_ioctl(bdev, mode, cmd, param);
3581	mutex_unlock(lock: &floppy_mutex);
3582
3583	return ret;
3584	}
3585
3586	#ifdef CONFIG_COMPAT
3587
3588	struct compat_floppy_drive_params {
3589	char cmos;
3590	compat_ulong_t max_dtr;
3591	compat_ulong_t hlt;
3592	compat_ulong_t hut;
3593	compat_ulong_t srt;
3594	compat_ulong_t spinup;
3595	compat_ulong_t spindown;
3596	unsigned char spindown_offset;
3597	unsigned char select_delay;
3598	unsigned char rps;
3599	unsigned char tracks;
3600	compat_ulong_t timeout;
3601	unsigned char interleave_sect;
3602	struct floppy_max_errors max_errors;
3603	char flags;
3604	char read_track;
3605	short autodetect[FD_AUTODETECT_SIZE];
3606	compat_int_t checkfreq;
3607	compat_int_t native_format;
3608	};
3609
3610	struct compat_floppy_drive_struct {
3611	signed char flags;
3612	compat_ulong_t spinup_date;
3613	compat_ulong_t select_date;
3614	compat_ulong_t first_read_date;
3615	short probed_format;
3616	short track;
3617	short maxblock;
3618	short maxtrack;
3619	compat_int_t generation;
3620	compat_int_t keep_data;
3621	compat_int_t fd_ref;
3622	compat_int_t fd_device;
3623	compat_int_t last_checked;
3624	compat_caddr_t dmabuf;
3625	compat_int_t bufblocks;
3626	};
3627
3628	struct compat_floppy_fdc_state {
3629	compat_int_t spec1;
3630	compat_int_t spec2;
3631	compat_int_t dtr;
3632	unsigned char version;
3633	unsigned char dor;
3634	compat_ulong_t address;
3635	unsigned int rawcmd:2;
3636	unsigned int reset:1;
3637	unsigned int need_configure:1;
3638	unsigned int perp_mode:2;
3639	unsigned int has_fifo:1;
3640	unsigned int driver_version;
3641	unsigned char track[4];
3642	};
3643
3644	struct compat_floppy_write_errors {
3645	unsigned int write_errors;
3646	compat_ulong_t first_error_sector;
3647	compat_int_t first_error_generation;
3648	compat_ulong_t last_error_sector;
3649	compat_int_t last_error_generation;
3650	compat_uint_t badness;
3651	};
3652
3653	#define FDSETPRM32 _IOW(2, 0x42, struct compat_floppy_struct)
3654	#define FDDEFPRM32 _IOW(2, 0x43, struct compat_floppy_struct)
3655	#define FDSETDRVPRM32 _IOW(2, 0x90, struct compat_floppy_drive_params)
3656	#define FDGETDRVPRM32 _IOR(2, 0x11, struct compat_floppy_drive_params)
3657	#define FDGETDRVSTAT32 _IOR(2, 0x12, struct compat_floppy_drive_struct)
3658	#define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct compat_floppy_drive_struct)
3659	#define FDGETFDCSTAT32 _IOR(2, 0x15, struct compat_floppy_fdc_state)
3660	#define FDWERRORGET32 _IOR(2, 0x17, struct compat_floppy_write_errors)
3661
3662	static int compat_set_geometry(struct block_device *bdev, blk_mode_t mode,
3663	unsigned int cmd, struct compat_floppy_struct __user *arg)
3664	{
3665	struct floppy_struct v;
3666	int drive, type;
3667	int err;
3668
3669	BUILD_BUG_ON(offsetof(struct floppy_struct, name) !=
3670	offsetof(struct compat_floppy_struct, name));
3671
3672	if (!(mode & (BLK_OPEN_WRITE | BLK_OPEN_WRITE_IOCTL)))
3673	return -EPERM;
3674
3675	memset(&v, 0, sizeof(struct floppy_struct));
3676	if (copy_from_user(to: &v, from: arg, offsetof(struct floppy_struct, name)))
3677	return -EFAULT;
3678
3679	mutex_lock(&floppy_mutex);
3680	drive = (long)bdev->bd_disk->private_data;
3681	type = ITYPE(drive_state[drive].fd_device);
3682	err = set_geometry(cmd: cmd == FDSETPRM32 ? FDSETPRM : FDDEFPRM,
3683	g: &v, drive, type, bdev);
3684	mutex_unlock(lock: &floppy_mutex);
3685	return err;
3686	}
3687
3688	static int compat_get_prm(int drive,
3689	struct compat_floppy_struct __user *arg)
3690	{
3691	struct compat_floppy_struct v;
3692	struct floppy_struct *p;
3693	int err;
3694
3695	memset(&v, 0, sizeof(v));
3696	mutex_lock(&floppy_mutex);
3697	err = get_floppy_geometry(drive, ITYPE(drive_state[drive].fd_device),
3698	g: &p);
3699	if (err) {
3700	mutex_unlock(lock: &floppy_mutex);
3701	return err;
3702	}
3703	memcpy(&v, p, offsetof(struct floppy_struct, name));
3704	mutex_unlock(lock: &floppy_mutex);
3705	if (copy_to_user(to: arg, from: &v, n: sizeof(struct compat_floppy_struct)))
3706	return -EFAULT;
3707	return 0;
3708	}
3709
3710	static int compat_setdrvprm(int drive,
3711	struct compat_floppy_drive_params __user *arg)
3712	{
3713	struct compat_floppy_drive_params v;
3714
3715	if (!capable(CAP_SYS_ADMIN))
3716	return -EPERM;
3717	if (copy_from_user(to: &v, from: arg, n: sizeof(struct compat_floppy_drive_params)))
3718	return -EFAULT;
3719	if (!valid_floppy_drive_params(autodetect: v.autodetect, native_format: v.native_format))
3720	return -EINVAL;
3721	mutex_lock(&floppy_mutex);
3722	drive_params[drive].cmos = v.cmos;
3723	drive_params[drive].max_dtr = v.max_dtr;
3724	drive_params[drive].hlt = v.hlt;
3725	drive_params[drive].hut = v.hut;
3726	drive_params[drive].srt = v.srt;
3727	drive_params[drive].spinup = v.spinup;
3728	drive_params[drive].spindown = v.spindown;
3729	drive_params[drive].spindown_offset = v.spindown_offset;
3730	drive_params[drive].select_delay = v.select_delay;
3731	drive_params[drive].rps = v.rps;
3732	drive_params[drive].tracks = v.tracks;
3733	drive_params[drive].timeout = v.timeout;
3734	drive_params[drive].interleave_sect = v.interleave_sect;
3735	drive_params[drive].max_errors = v.max_errors;
3736	drive_params[drive].flags = v.flags;
3737	drive_params[drive].read_track = v.read_track;
3738	memcpy(drive_params[drive].autodetect, v.autodetect,
3739	sizeof(v.autodetect));
3740	drive_params[drive].checkfreq = v.checkfreq;
3741	drive_params[drive].native_format = v.native_format;
3742	mutex_unlock(lock: &floppy_mutex);
3743	return 0;
3744	}
3745
3746	static int compat_getdrvprm(int drive,
3747	struct compat_floppy_drive_params __user *arg)
3748	{
3749	struct compat_floppy_drive_params v;
3750
3751	memset(&v, 0, sizeof(struct compat_floppy_drive_params));
3752	mutex_lock(&floppy_mutex);
3753	v.cmos = drive_params[drive].cmos;
3754	v.max_dtr = drive_params[drive].max_dtr;
3755	v.hlt = drive_params[drive].hlt;
3756	v.hut = drive_params[drive].hut;
3757	v.srt = drive_params[drive].srt;
3758	v.spinup = drive_params[drive].spinup;
3759	v.spindown = drive_params[drive].spindown;
3760	v.spindown_offset = drive_params[drive].spindown_offset;
3761	v.select_delay = drive_params[drive].select_delay;
3762	v.rps = drive_params[drive].rps;
3763	v.tracks = drive_params[drive].tracks;
3764	v.timeout = drive_params[drive].timeout;
3765	v.interleave_sect = drive_params[drive].interleave_sect;
3766	v.max_errors = drive_params[drive].max_errors;
3767	v.flags = drive_params[drive].flags;
3768	v.read_track = drive_params[drive].read_track;
3769	memcpy(v.autodetect, drive_params[drive].autodetect,
3770	sizeof(v.autodetect));
3771	v.checkfreq = drive_params[drive].checkfreq;
3772	v.native_format = drive_params[drive].native_format;
3773	mutex_unlock(lock: &floppy_mutex);
3774
3775	if (copy_to_user(to: arg, from: &v, n: sizeof(struct compat_floppy_drive_params)))
3776	return -EFAULT;
3777	return 0;
3778	}
3779
3780	static int compat_getdrvstat(int drive, bool poll,
3781	struct compat_floppy_drive_struct __user *arg)
3782	{
3783	struct compat_floppy_drive_struct v;
3784
3785	memset(&v, 0, sizeof(struct compat_floppy_drive_struct));
3786	mutex_lock(&floppy_mutex);
3787
3788	if (poll) {
3789	if (lock_fdc(drive))
3790	goto Eintr;
3791	if (poll_drive(interruptible: true, FD_RAW_NEED_DISK) == -EINTR)
3792	goto Eintr;
3793	process_fd_request();
3794	}
3795	v.spinup_date = drive_state[drive].spinup_date;
3796	v.select_date = drive_state[drive].select_date;
3797	v.first_read_date = drive_state[drive].first_read_date;
3798	v.probed_format = drive_state[drive].probed_format;
3799	v.track = drive_state[drive].track;
3800	v.maxblock = drive_state[drive].maxblock;
3801	v.maxtrack = drive_state[drive].maxtrack;
3802	v.generation = drive_state[drive].generation;
3803	v.keep_data = drive_state[drive].keep_data;
3804	v.fd_ref = drive_state[drive].fd_ref;
3805	v.fd_device = drive_state[drive].fd_device;
3806	v.last_checked = drive_state[drive].last_checked;
3807	v.dmabuf = (uintptr_t) drive_state[drive].dmabuf;
3808	v.bufblocks = drive_state[drive].bufblocks;
3809	mutex_unlock(lock: &floppy_mutex);
3810
3811	if (copy_to_user(to: arg, from: &v, n: sizeof(struct compat_floppy_drive_struct)))
3812	return -EFAULT;
3813	return 0;
3814	Eintr:
3815	mutex_unlock(lock: &floppy_mutex);
3816	return -EINTR;
3817	}
3818
3819	static int compat_getfdcstat(int drive,
3820	struct compat_floppy_fdc_state __user *arg)
3821	{
3822	struct compat_floppy_fdc_state v32;
3823	struct floppy_fdc_state v;
3824
3825	mutex_lock(&floppy_mutex);
3826	v = fdc_state[FDC(drive)];
3827	mutex_unlock(lock: &floppy_mutex);
3828
3829	memset(&v32, 0, sizeof(struct compat_floppy_fdc_state));
3830	v32.spec1 = v.spec1;
3831	v32.spec2 = v.spec2;
3832	v32.dtr = v.dtr;
3833	v32.version = v.version;
3834	v32.dor = v.dor;
3835	v32.address = v.address;
3836	v32.rawcmd = v.rawcmd;
3837	v32.reset = v.reset;
3838	v32.need_configure = v.need_configure;
3839	v32.perp_mode = v.perp_mode;
3840	v32.has_fifo = v.has_fifo;
3841	v32.driver_version = v.driver_version;
3842	memcpy(v32.track, v.track, 4);
3843	if (copy_to_user(to: arg, from: &v32, n: sizeof(struct compat_floppy_fdc_state)))
3844	return -EFAULT;
3845	return 0;
3846	}
3847
3848	static int compat_werrorget(int drive,
3849	struct compat_floppy_write_errors __user *arg)
3850	{
3851	struct compat_floppy_write_errors v32;
3852	struct floppy_write_errors v;
3853
3854	memset(&v32, 0, sizeof(struct compat_floppy_write_errors));
3855	mutex_lock(&floppy_mutex);
3856	v = write_errors[drive];
3857	mutex_unlock(lock: &floppy_mutex);
3858	v32.write_errors = v.write_errors;
3859	v32.first_error_sector = v.first_error_sector;
3860	v32.first_error_generation = v.first_error_generation;
3861	v32.last_error_sector = v.last_error_sector;
3862	v32.last_error_generation = v.last_error_generation;
3863	v32.badness = v.badness;
3864	if (copy_to_user(to: arg, from: &v32, n: sizeof(struct compat_floppy_write_errors)))
3865	return -EFAULT;
3866	return 0;
3867	}
3868
3869	static int fd_compat_ioctl(struct block_device *bdev, blk_mode_t mode,
3870	unsigned int cmd, unsigned long param)
3871	{
3872	int drive = (long)bdev->bd_disk->private_data;
3873	switch (cmd) {
3874	case CDROMEJECT: /* CD-ROM eject */
3875	case 0x6470: /* SunOS floppy eject */
3876
3877	case FDMSGON:
3878	case FDMSGOFF:
3879	case FDSETEMSGTRESH:
3880	case FDFLUSH:
3881	case FDWERRORCLR:
3882	case FDEJECT:
3883	case FDCLRPRM:
3884	case FDFMTBEG:
3885	case FDRESET:
3886	case FDTWADDLE:
3887	return fd_ioctl(bdev, mode, cmd, param);
3888	case FDSETMAXERRS:
3889	case FDGETMAXERRS:
3890	case FDGETDRVTYP:
3891	case FDFMTEND:
3892	case FDFMTTRK:
3893	case FDRAWCMD:
3894	return fd_ioctl(bdev, mode, cmd,
3895	param: (unsigned long)compat_ptr(uptr: param));
3896	case FDSETPRM32:
3897	case FDDEFPRM32:
3898	return compat_set_geometry(bdev, mode, cmd, arg: compat_ptr(uptr: param));
3899	case FDGETPRM32:
3900	return compat_get_prm(drive, arg: compat_ptr(uptr: param));
3901	case FDSETDRVPRM32:
3902	return compat_setdrvprm(drive, arg: compat_ptr(uptr: param));
3903	case FDGETDRVPRM32:
3904	return compat_getdrvprm(drive, arg: compat_ptr(uptr: param));
3905	case FDPOLLDRVSTAT32:
3906	return compat_getdrvstat(drive, poll: true, arg: compat_ptr(uptr: param));
3907	case FDGETDRVSTAT32:
3908	return compat_getdrvstat(drive, poll: false, arg: compat_ptr(uptr: param));
3909	case FDGETFDCSTAT32:
3910	return compat_getfdcstat(drive, arg: compat_ptr(uptr: param));
3911	case FDWERRORGET32:
3912	return compat_werrorget(drive, arg: compat_ptr(uptr: param));
3913	}
3914	return -EINVAL;
3915	}
3916	#endif
3917
3918	static void __init config_types(void)
3919	{
3920	bool has_drive = false;
3921	int drive;
3922
3923	/* read drive info out of physical CMOS */
3924	drive = 0;
3925	if (!drive_params[drive].cmos)
3926	drive_params[drive].cmos = FLOPPY0_TYPE;
3927	drive = 1;
3928	if (!drive_params[drive].cmos)
3929	drive_params[drive].cmos = FLOPPY1_TYPE;
3930
3931	/* FIXME: additional physical CMOS drive detection should go here */
3932
3933	for (drive = 0; drive < N_DRIVE; drive++) {
3934	unsigned int type = drive_params[drive].cmos;
3935	struct floppy_drive_params *params;
3936	const char *name = NULL;
3937	char temparea[32];
3938
3939	if (type < ARRAY_SIZE(default_drive_params)) {
3940	params = &default_drive_params[type].params;
3941	if (type) {
3942	name = default_drive_params[type].name;
3943	allowed_drive_mask |= 1 << drive;
3944	} else
3945	allowed_drive_mask &= ~(1 << drive);
3946	} else {
3947	params = &default_drive_params[0].params;
3948	snprintf(buf: temparea, size: sizeof(temparea),
3949	fmt: "unknown type %d (usb?)", type);
3950	name = temparea;
3951	}
3952	if (name) {
3953	const char *prepend;
3954	if (!has_drive) {
3955	prepend = "";
3956	has_drive = true;
3957	pr_info("Floppy drive(s):");
3958	} else {
3959	prepend = ",";
3960	}
3961
3962	pr_cont("%s fd%d is %s", prepend, drive, name);
3963	}
3964	drive_params[drive] = *params;
3965	}
3966
3967	if (has_drive)
3968	pr_cont("\n");
3969	}
3970
3971	static void floppy_release(struct gendisk *disk)
3972	{
3973	int drive = (long)disk->private_data;
3974
3975	mutex_lock(&floppy_mutex);
3976	mutex_lock(&open_lock);
3977	if (!drive_state[drive].fd_ref--) {
3978	DPRINT("floppy_release with fd_ref == 0");
3979	drive_state[drive].fd_ref = 0;
3980	}
3981	if (!drive_state[drive].fd_ref)
3982	opened_disk[drive] = NULL;
3983	mutex_unlock(lock: &open_lock);
3984	mutex_unlock(lock: &floppy_mutex);
3985	}
3986
3987	/*
3988	* floppy_open check for aliasing (/dev/fd0 can be the same as
3989	* /dev/PS0 etc), and disallows simultaneous access to the same
3990	* drive with different device numbers.
3991	*/
3992	static int floppy_open(struct gendisk *disk, blk_mode_t mode)
3993	{
3994	int drive = (long)disk->private_data;
3995	int old_dev, new_dev;
3996	int try;
3997	int res = -EBUSY;
3998	char *tmp;
3999
4000	mutex_lock(&floppy_mutex);
4001	mutex_lock(&open_lock);
4002	old_dev = drive_state[drive].fd_device;
4003	if (opened_disk[drive] && opened_disk[drive] != disk)
4004	goto out2;
4005
4006	if (!drive_state[drive].fd_ref && (drive_params[drive].flags & FD_BROKEN_DCL)) {
4007	set_bit(nr: FD_DISK_CHANGED_BIT, addr: &drive_state[drive].flags);
4008	set_bit(nr: FD_VERIFY_BIT, addr: &drive_state[drive].flags);
4009	}
4010
4011	drive_state[drive].fd_ref++;
4012
4013	opened_disk[drive] = disk;
4014
4015	res = -ENXIO;
4016
4017	if (!floppy_track_buffer) {
4018	/* if opening an ED drive, reserve a big buffer,
4019	* else reserve a small one */
4020	if ((drive_params[drive].cmos == 6) || (drive_params[drive].cmos == 5))
4021	try = 64; /* Only 48 actually useful */
4022	else
4023	try = 32; /* Only 24 actually useful */
4024
4025	tmp = (char *)fd_dma_mem_alloc(1024 * try);
4026	if (!tmp && !floppy_track_buffer) {
4027	try >>= 1; /* buffer only one side */
4028	INFBOUND(try, 16);
4029	tmp = (char *)fd_dma_mem_alloc(1024 * try);
4030	}
4031	if (!tmp && !floppy_track_buffer)
4032	fallback_on_nodma_alloc(addr: &tmp, l: 2048 * try);
4033	if (!tmp && !floppy_track_buffer) {
4034	DPRINT("Unable to allocate DMA memory\n");
4035	goto out;
4036	}
4037	if (floppy_track_buffer) {
4038	if (tmp)
4039	fd_dma_mem_free((unsigned long)tmp, try * 1024);
4040	} else {
4041	buffer_min = buffer_max = -1;
4042	floppy_track_buffer = tmp;
4043	max_buffer_sectors = try;
4044	}
4045	}
4046
4047	new_dev = disk->first_minor;
4048	drive_state[drive].fd_device = new_dev;
4049	set_capacity(disk: disks[drive][ITYPE(new_dev)], size: floppy_sizes[new_dev]);
4050	if (old_dev != -1 && old_dev != new_dev) {
4051	if (buffer_drive == drive)
4052	buffer_track = -1;
4053	}
4054
4055	if (fdc_state[FDC(drive)].rawcmd == 1)
4056	fdc_state[FDC(drive)].rawcmd = 2;
4057	if (!(mode & BLK_OPEN_NDELAY)) {
4058	if (mode & (BLK_OPEN_READ | BLK_OPEN_WRITE)) {
4059	drive_state[drive].last_checked = 0;
4060	clear_bit(nr: FD_OPEN_SHOULD_FAIL_BIT,
4061	addr: &drive_state[drive].flags);
4062	if (disk_check_media_change(disk))
4063	floppy_revalidate(disk);
4064	if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags))
4065	goto out;
4066	if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &drive_state[drive].flags))
4067	goto out;
4068	}
4069	res = -EROFS;
4070	if ((mode & BLK_OPEN_WRITE) &&
4071	!test_bit(FD_DISK_WRITABLE_BIT, &drive_state[drive].flags))
4072	goto out;
4073	}
4074	mutex_unlock(lock: &open_lock);
4075	mutex_unlock(lock: &floppy_mutex);
4076	return 0;
4077	out:
4078	drive_state[drive].fd_ref--;
4079
4080	if (!drive_state[drive].fd_ref)
4081	opened_disk[drive] = NULL;
4082	out2:
4083	mutex_unlock(lock: &open_lock);
4084	mutex_unlock(lock: &floppy_mutex);
4085	return res;
4086	}
4087
4088	/*
4089	* Check if the disk has been changed or if a change has been faked.
4090	*/
4091	static unsigned int floppy_check_events(struct gendisk *disk,
4092	unsigned int clearing)
4093	{
4094	int drive = (long)disk->private_data;
4095
4096	if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4097	test_bit(FD_VERIFY_BIT, &drive_state[drive].flags))
4098	return DISK_EVENT_MEDIA_CHANGE;
4099
4100	if (time_after(jiffies, drive_state[drive].last_checked + drive_params[drive].checkfreq)) {
4101	if (lock_fdc(drive))
4102	return 0;
4103	poll_drive(interruptible: false, flag: 0);
4104	process_fd_request();
4105	}
4106
4107	if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4108	test_bit(FD_VERIFY_BIT, &drive_state[drive].flags) ||
4109	test_bit(drive, &fake_change) ||
4110	drive_no_geom(drive))
4111	return DISK_EVENT_MEDIA_CHANGE;
4112	return 0;
4113	}
4114
4115	/*
4116	* This implements "read block 0" for floppy_revalidate().
4117	* Needed for format autodetection, checking whether there is
4118	* a disk in the drive, and whether that disk is writable.
4119	*/
4120
4121	struct rb0_cbdata {
4122	int drive;
4123	struct completion complete;
4124	};
4125
4126	static void floppy_rb0_cb(struct bio *bio)
4127	{
4128	struct rb0_cbdata *cbdata = (struct rb0_cbdata *)bio->bi_private;
4129	int drive = cbdata->drive;
4130
4131	if (bio->bi_status) {
4132	pr_info("floppy: error %d while reading block 0\n",
4133	bio->bi_status);
4134	set_bit(nr: FD_OPEN_SHOULD_FAIL_BIT, addr: &drive_state[drive].flags);
4135	}
4136	complete(&cbdata->complete);
4137	}
4138
4139	static int __floppy_read_block_0(struct block_device *bdev, int drive)
4140	{
4141	struct bio bio;
4142	struct bio_vec bio_vec;
4143	struct page *page;
4144	struct rb0_cbdata cbdata;
4145
4146	page = alloc_page(GFP_NOIO);
4147	if (!page) {
4148	process_fd_request();
4149	return -ENOMEM;
4150	}
4151
4152	cbdata.drive = drive;
4153
4154	bio_init(bio: &bio, bdev, table: &bio_vec, max_vecs: 1, opf: REQ_OP_READ);
4155	__bio_add_page(bio: &bio, page, len: block_size(bdev), off: 0);
4156
4157	bio.bi_iter.bi_sector = 0;
4158	bio.bi_flags |= (1 << BIO_QUIET);
4159	bio.bi_private = &cbdata;
4160	bio.bi_end_io = floppy_rb0_cb;
4161
4162	init_completion(x: &cbdata.complete);
4163
4164	submit_bio(bio: &bio);
4165	process_fd_request();
4166
4167	wait_for_completion(&cbdata.complete);
4168
4169	__free_page(page);
4170
4171	return 0;
4172	}
4173
4174	/* revalidate the floppy disk, i.e. trigger format autodetection by reading
4175	* the bootblock (block 0). "Autodetection" is also needed to check whether
4176	* there is a disk in the drive at all... Thus we also do it for fixed
4177	* geometry formats */
4178	static int floppy_revalidate(struct gendisk *disk)
4179	{
4180	int drive = (long)disk->private_data;
4181	int cf;
4182	int res = 0;
4183
4184	if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4185	test_bit(FD_VERIFY_BIT, &drive_state[drive].flags) ||
4186	test_bit(drive, &fake_change) ||
4187	drive_no_geom(drive)) {
4188	if (WARN(atomic_read(&usage_count) == 0,
4189	"VFS: revalidate called on non-open device.\n"))
4190	return -EFAULT;
4191
4192	res = lock_fdc(drive);
4193	if (res)
4194	return res;
4195	cf = (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4196	test_bit(FD_VERIFY_BIT, &drive_state[drive].flags));
4197	if (!(cf || test_bit(drive, &fake_change) || drive_no_geom(drive))) {
4198	process_fd_request(); /*already done by another thread */
4199	return 0;
4200	}
4201	drive_state[drive].maxblock = 0;
4202	drive_state[drive].maxtrack = 0;
4203	if (buffer_drive == drive)
4204	buffer_track = -1;
4205	clear_bit(nr: drive, addr: &fake_change);
4206	clear_bit(nr: FD_DISK_CHANGED_BIT, addr: &drive_state[drive].flags);
4207	if (cf)
4208	drive_state[drive].generation++;
4209	if (drive_no_geom(drive)) {
4210	/* auto-sensing */
4211	res = __floppy_read_block_0(bdev: opened_disk[drive]->part0,
4212	drive);
4213	} else {
4214	if (cf)
4215	poll_drive(interruptible: false, FD_RAW_NEED_DISK);
4216	process_fd_request();
4217	}
4218	}
4219	set_capacity(disk, size: floppy_sizes[drive_state[drive].fd_device]);
4220	return res;
4221	}
4222
4223	static const struct block_device_operations floppy_fops = {
4224	.owner = THIS_MODULE,
4225	.open = floppy_open,
4226	.release = floppy_release,
4227	.ioctl = fd_ioctl,
4228	.getgeo = fd_getgeo,
4229	.check_events = floppy_check_events,
4230	#ifdef CONFIG_COMPAT
4231	.compat_ioctl = fd_compat_ioctl,
4232	#endif
4233	};
4234
4235	/*
4236	* Floppy Driver initialization
4237	* =============================
4238	*/
4239
4240	/* Determine the floppy disk controller type */
4241	/* This routine was written by David C. Niemi */
4242	static char __init get_fdc_version(int fdc)
4243	{
4244	int r;
4245
4246	output_byte(fdc, FD_DUMPREGS); /* 82072 and better know DUMPREGS */
4247	if (fdc_state[fdc].reset)
4248	return FDC_NONE;
4249	r = result(fdc);
4250	if (r <= 0x00)
4251	return FDC_NONE; /* No FDC present ??? */
4252	if ((r == 1) && (reply_buffer[ST0] == 0x80)) {
4253	pr_info("FDC %d is an 8272A\n", fdc);
4254	return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
4255	}
4256	if (r != 10) {
4257	pr_info("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
4258	fdc, r);
4259	return FDC_UNKNOWN;
4260	}
4261
4262	if (!fdc_configure(fdc)) {
4263	pr_info("FDC %d is an 82072\n", fdc);
4264	return FDC_82072; /* 82072 doesn't know CONFIGURE */
4265	}
4266
4267	output_byte(fdc, FD_PERPENDICULAR);
4268	if (need_more_output(fdc) == MORE_OUTPUT) {
4269	output_byte(fdc, byte: 0);
4270	} else {
4271	pr_info("FDC %d is an 82072A\n", fdc);
4272	return FDC_82072A; /* 82072A as found on Sparcs. */
4273	}
4274
4275	output_byte(fdc, FD_UNLOCK);
4276	r = result(fdc);
4277	if ((r == 1) && (reply_buffer[ST0] == 0x80)) {
4278	pr_info("FDC %d is a pre-1991 82077\n", fdc);
4279	return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
4280	* LOCK/UNLOCK */
4281	}
4282	if ((r != 1) || (reply_buffer[ST0] != 0x00)) {
4283	pr_info("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
4284	fdc, r);
4285	return FDC_UNKNOWN;
4286	}
4287	output_byte(fdc, FD_PARTID);
4288	r = result(fdc);
4289	if (r != 1) {
4290	pr_info("FDC %d init: PARTID: unexpected return of %d bytes.\n",
4291	fdc, r);
4292	return FDC_UNKNOWN;
4293	}
4294	if (reply_buffer[ST0] == 0x80) {
4295	pr_info("FDC %d is a post-1991 82077\n", fdc);
4296	return FDC_82077; /* Revised 82077AA passes all the tests */
4297	}
4298	switch (reply_buffer[ST0] >> 5) {
4299	case 0x0:
4300	/* Either a 82078-1 or a 82078SL running at 5Volt */
4301	pr_info("FDC %d is an 82078.\n", fdc);
4302	return FDC_82078;
4303	case 0x1:
4304	pr_info("FDC %d is a 44pin 82078\n", fdc);
4305	return FDC_82078;
4306	case 0x2:
4307	pr_info("FDC %d is a S82078B\n", fdc);
4308	return FDC_S82078B;
4309	case 0x3:
4310	pr_info("FDC %d is a National Semiconductor PC87306\n", fdc);
4311	return FDC_87306;
4312	default:
4313	pr_info("FDC %d init: 82078 variant with unknown PARTID=%d.\n",
4314	fdc, reply_buffer[ST0] >> 5);
4315	return FDC_82078_UNKN;
4316	}
4317	} /* get_fdc_version */
4318
4319	/* lilo configuration */
4320
4321	static void __init floppy_set_flags(int *ints, int param, int param2)
4322	{
4323	int i;
4324
4325	for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4326	if (param)
4327	default_drive_params[i].params.flags |= param2;
4328	else
4329	default_drive_params[i].params.flags &= ~param2;
4330	}
4331	DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4332	}
4333
4334	static void __init daring(int *ints, int param, int param2)
4335	{
4336	int i;
4337
4338	for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4339	if (param) {
4340	default_drive_params[i].params.select_delay = 0;
4341	default_drive_params[i].params.flags |=
4342	FD_SILENT_DCL_CLEAR;
4343	} else {
4344	default_drive_params[i].params.select_delay =
4345	2 * HZ / 100;
4346	default_drive_params[i].params.flags &=
4347	~FD_SILENT_DCL_CLEAR;
4348	}
4349	}
4350	DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4351	}
4352
4353	static void __init set_cmos(int *ints, int dummy, int dummy2)
4354	{
4355	int current_drive = 0;
4356
4357	if (ints[0] != 2) {
4358	DPRINT("wrong number of parameters for CMOS\n");
4359	return;
4360	}
4361	current_drive = ints[1];
4362	if (current_drive < 0 || current_drive >= 8) {
4363	DPRINT("bad drive for set_cmos\n");
4364	return;
4365	}
4366	#if N_FDC > 1
4367	if (current_drive >= 4 && !FDC2)
4368	FDC2 = 0x370;
4369	#endif
4370	drive_params[current_drive].cmos = ints[2];
4371	DPRINT("setting CMOS code to %d\n", ints[2]);
4372	}
4373
4374	static struct param_table {
4375	const char *name;
4376	void (*fn) (int *ints, int param, int param2);
4377	int *var;
4378	int def_param;
4379	int param2;
4380	} config_params[] __initdata = {
4381	{"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4382	{"all_drives", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4383	{"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
4384	{"irq", NULL, &FLOPPY_IRQ, 6, 0},
4385	{"dma", NULL, &FLOPPY_DMA, 2, 0},
4386	{"daring", daring, NULL, 1, 0},
4387	#if N_FDC > 1
4388	{"two_fdc", NULL, &FDC2, 0x370, 0},
4389	{"one_fdc", NULL, &FDC2, 0, 0},
4390	#endif
4391	{"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
4392	{"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
4393	{"messages", floppy_set_flags, NULL, 1, FTD_MSG},
4394	{"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
4395	{"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
4396	{"nodma", NULL, &can_use_virtual_dma, 1, 0},
4397	{"omnibook", NULL, &can_use_virtual_dma, 1, 0},
4398	{"yesdma", NULL, &can_use_virtual_dma, 0, 0},
4399	{"fifo_depth", NULL, &fifo_depth, 0xa, 0},
4400	{"nofifo", NULL, &no_fifo, 0x20, 0},
4401	{"usefifo", NULL, &no_fifo, 0, 0},
4402	{"cmos", set_cmos, NULL, 0, 0},
4403	{"slow", NULL, &slow_floppy, 1, 0},
4404	{"unexpected_interrupts", NULL, &print_unex, 1, 0},
4405	{"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
4406	{"L40SX", NULL, &print_unex, 0, 0}
4407
4408	EXTRA_FLOPPY_PARAMS
4409	};
4410
4411	static int __init floppy_setup(char *str)
4412	{
4413	int i;
4414	int param;
4415	int ints[11];
4416
4417	str = get_options(str, ARRAY_SIZE(ints), ints);
4418	if (str) {
4419	for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4420	if (strcmp(str, config_params[i].name) == 0) {
4421	if (ints[0])
4422	param = ints[1];
4423	else
4424	param = config_params[i].def_param;
4425	if (config_params[i].fn)
4426	config_params[i].fn(ints, param,
4427	config_params[i].
4428	param2);
4429	if (config_params[i].var) {
4430	DPRINT("%s=%d\n", str, param);
4431	*config_params[i].var = param;
4432	}
4433	return 1;
4434	}
4435	}
4436	}
4437	if (str) {
4438	DPRINT("unknown floppy option [%s]\n", str);
4439
4440	DPRINT("allowed options are:");
4441	for (i = 0; i < ARRAY_SIZE(config_params); i++)
4442	pr_cont(" %s", config_params[i].name);
4443	pr_cont("\n");
4444	} else
4445	DPRINT("botched floppy option\n");
4446	DPRINT("Read Documentation/admin-guide/blockdev/floppy.rst\n");
4447	return 0;
4448	}
4449
4450	static int have_no_fdc = -ENODEV;
4451
4452	static ssize_t floppy_cmos_show(struct device *dev,
4453	struct device_attribute *attr, char *buf)
4454	{
4455	struct platform_device *p = to_platform_device(dev);
4456	int drive;
4457
4458	drive = p->id;
4459	return sprintf(buf, fmt: "%X\n", drive_params[drive].cmos);
4460	}
4461
4462	static DEVICE_ATTR(cmos, 0444, floppy_cmos_show, NULL);
4463
4464	static struct attribute *floppy_dev_attrs[] = {
4465	&dev_attr_cmos.attr,
4466	NULL
4467	};
4468
4469	ATTRIBUTE_GROUPS(floppy_dev);
4470
4471	static void floppy_device_release(struct device *dev)
4472	{
4473	}
4474
4475	static int floppy_resume(struct device *dev)
4476	{
4477	int fdc;
4478	int saved_drive;
4479
4480	saved_drive = current_drive;
4481	for (fdc = 0; fdc < N_FDC; fdc++)
4482	if (fdc_state[fdc].address != -1)
4483	user_reset_fdc(REVDRIVE(fdc, 0), arg: FD_RESET_ALWAYS, interruptible: false);
4484	set_fdc(saved_drive);
4485	return 0;
4486	}
4487
4488	static const struct dev_pm_ops floppy_pm_ops = {
4489	.resume = floppy_resume,
4490	.restore = floppy_resume,
4491	};
4492
4493	static struct platform_driver floppy_driver = {
4494	.driver = {
4495	.name = "floppy",
4496	.pm = &floppy_pm_ops,
4497	},
4498	};
4499
4500	static const struct blk_mq_ops floppy_mq_ops = {
4501	.queue_rq = floppy_queue_rq,
4502	};
4503
4504	static struct platform_device floppy_device[N_DRIVE];
4505	static bool registered[N_DRIVE];
4506
4507	static bool floppy_available(int drive)
4508	{
4509	if (!(allowed_drive_mask & (1 << drive)))
4510	return false;
4511	if (fdc_state[FDC(drive)].version == FDC_NONE)
4512	return false;
4513	return true;
4514	}
4515
4516	static int floppy_alloc_disk(unsigned int drive, unsigned int type)
4517	{
4518	struct queue_limits lim = {
4519	.max_hw_sectors = 64,
4520	};
4521	struct gendisk *disk;
4522
4523	disk = blk_mq_alloc_disk(&tag_sets[drive], &lim, NULL);
4524	if (IS_ERR(ptr: disk))
4525	return PTR_ERR(ptr: disk);
4526
4527	disk->major = FLOPPY_MAJOR;
4528	disk->first_minor = TOMINOR(drive) | (type << 2);
4529	disk->minors = 1;
4530	disk->fops = &floppy_fops;
4531	disk->flags |= GENHD_FL_NO_PART;
4532	disk->events = DISK_EVENT_MEDIA_CHANGE;
4533	if (type)
4534	sprintf(buf: disk->disk_name, fmt: "fd%d_type%d", drive, type);
4535	else
4536	sprintf(buf: disk->disk_name, fmt: "fd%d", drive);
4537	/* to be cleaned up... */
4538	disk->private_data = (void *)(long)drive;
4539	disk->flags |= GENHD_FL_REMOVABLE;
4540
4541	disks[drive][type] = disk;
4542	return 0;
4543	}
4544
4545	static DEFINE_MUTEX(floppy_probe_lock);
4546
4547	static void floppy_probe(dev_t dev)
4548	{
4549	unsigned int drive = (MINOR(dev) & 3) | ((MINOR(dev) & 0x80) >> 5);
4550	unsigned int type = (MINOR(dev) >> 2) & 0x1f;
4551
4552	if (drive >= N_DRIVE || !floppy_available(drive) ||
4553	type >= ARRAY_SIZE(floppy_type))
4554	return;
4555
4556	mutex_lock(&floppy_probe_lock);
4557	if (disks[drive][type])
4558	goto out;
4559	if (floppy_alloc_disk(drive, type))
4560	goto out;
4561	if (add_disk(disk: disks[drive][type]))
4562	goto cleanup_disk;
4563	out:
4564	mutex_unlock(lock: &floppy_probe_lock);
4565	return;
4566
4567	cleanup_disk:
4568	put_disk(disk: disks[drive][type]);
4569	disks[drive][type] = NULL;
4570	mutex_unlock(lock: &floppy_probe_lock);
4571	}
4572
4573	static int __init do_floppy_init(void)
4574	{
4575	int i, unit, drive, err;
4576
4577	set_debugt();
4578	interruptjiffies = resultjiffies = jiffies;
4579
4580	#if defined(CONFIG_PPC)
4581	if (check_legacy_ioport(FDC1))
4582	return -ENODEV;
4583	#endif
4584
4585	raw_cmd = NULL;
4586
4587	floppy_wq = alloc_ordered_workqueue("floppy", 0);
4588	if (!floppy_wq)
4589	return -ENOMEM;
4590
4591	for (drive = 0; drive < N_DRIVE; drive++) {
4592	memset(&tag_sets[drive], 0, sizeof(tag_sets[drive]));
4593	tag_sets[drive].ops = &floppy_mq_ops;
4594	tag_sets[drive].nr_hw_queues = 1;
4595	tag_sets[drive].nr_maps = 1;
4596	tag_sets[drive].queue_depth = 2;
4597	tag_sets[drive].numa_node = NUMA_NO_NODE;
4598	tag_sets[drive].flags = BLK_MQ_F_SHOULD_MERGE;
4599	err = blk_mq_alloc_tag_set(set: &tag_sets[drive]);
4600	if (err)
4601	goto out_put_disk;
4602
4603	err = floppy_alloc_disk(drive, type: 0);
4604	if (err) {
4605	blk_mq_free_tag_set(set: &tag_sets[drive]);
4606	goto out_put_disk;
4607	}
4608
4609	timer_setup(&motor_off_timer[drive], motor_off_callback, 0);
4610	}
4611
4612	err = __register_blkdev(FLOPPY_MAJOR, name: "fd", probe: floppy_probe);
4613	if (err)
4614	goto out_put_disk;
4615
4616	err = platform_driver_register(&floppy_driver);
4617	if (err)
4618	goto out_unreg_blkdev;
4619
4620	for (i = 0; i < 256; i++)
4621	if (ITYPE(i))
4622	floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4623	else
4624	floppy_sizes[i] = MAX_DISK_SIZE << 1;
4625
4626	reschedule_timeout(MAXTIMEOUT, message: "floppy init");
4627	config_types();
4628
4629	for (i = 0; i < N_FDC; i++) {
4630	memset(&fdc_state[i], 0, sizeof(*fdc_state));
4631	fdc_state[i].dtr = -1;
4632	fdc_state[i].dor = 0x4;
4633	#if defined(__sparc__) || defined(__mc68000__)
4634	/*sparcs/sun3x don't have a DOR reset which we can fall back on to */
4635	#ifdef __mc68000__
4636	if (MACH_IS_SUN3X)
4637	#endif
4638	fdc_state[i].version = FDC_82072A;
4639	#endif
4640	}
4641
4642	use_virtual_dma = can_use_virtual_dma & 1;
4643	fdc_state[0].address = FDC1;
4644	if (fdc_state[0].address == -1) {
4645	cancel_delayed_work(dwork: &fd_timeout);
4646	err = -ENODEV;
4647	goto out_unreg_driver;
4648	}
4649	#if N_FDC > 1
4650	fdc_state[1].address = FDC2;
4651	#endif
4652
4653	current_fdc = 0; /* reset fdc in case of unexpected interrupt */
4654	err = floppy_grab_irq_and_dma();
4655	if (err) {
4656	cancel_delayed_work(dwork: &fd_timeout);
4657	err = -EBUSY;
4658	goto out_unreg_driver;
4659	}
4660
4661	/* initialise drive state */
4662	for (drive = 0; drive < N_DRIVE; drive++) {
4663	memset(&drive_state[drive], 0, sizeof(drive_state[drive]));
4664	memset(&write_errors[drive], 0, sizeof(write_errors[drive]));
4665	set_bit(nr: FD_DISK_NEWCHANGE_BIT, addr: &drive_state[drive].flags);
4666	set_bit(nr: FD_DISK_CHANGED_BIT, addr: &drive_state[drive].flags);
4667	set_bit(nr: FD_VERIFY_BIT, addr: &drive_state[drive].flags);
4668	drive_state[drive].fd_device = -1;
4669	floppy_track_buffer = NULL;
4670	max_buffer_sectors = 0;
4671	}
4672	/*
4673	* Small 10 msec delay to let through any interrupt that
4674	* initialization might have triggered, to not
4675	* confuse detection:
4676	*/
4677	msleep(msecs: 10);
4678
4679	for (i = 0; i < N_FDC; i++) {
4680	fdc_state[i].driver_version = FD_DRIVER_VERSION;
4681	for (unit = 0; unit < 4; unit++)
4682	fdc_state[i].track[unit] = 0;
4683	if (fdc_state[i].address == -1)
4684	continue;
4685	fdc_state[i].rawcmd = 2;
4686	if (user_reset_fdc(REVDRIVE(i, 0), arg: FD_RESET_ALWAYS, interruptible: false)) {
4687	/* free ioports reserved by floppy_grab_irq_and_dma() */
4688	floppy_release_regions(i);
4689	fdc_state[i].address = -1;
4690	fdc_state[i].version = FDC_NONE;
4691	continue;
4692	}
4693	/* Try to determine the floppy controller type */
4694	fdc_state[i].version = get_fdc_version(fdc: i);
4695	if (fdc_state[i].version == FDC_NONE) {
4696	/* free ioports reserved by floppy_grab_irq_and_dma() */
4697	floppy_release_regions(i);
4698	fdc_state[i].address = -1;
4699	continue;
4700	}
4701	if (can_use_virtual_dma == 2 &&
4702	fdc_state[i].version < FDC_82072A)
4703	can_use_virtual_dma = 0;
4704
4705	have_no_fdc = 0;
4706	/* Not all FDCs seem to be able to handle the version command
4707	* properly, so force a reset for the standard FDC clones,
4708	* to avoid interrupt garbage.
4709	*/
4710	user_reset_fdc(REVDRIVE(i, 0), arg: FD_RESET_ALWAYS, interruptible: false);
4711	}
4712	current_fdc = 0;
4713	cancel_delayed_work(dwork: &fd_timeout);
4714	current_drive = 0;
4715	initialized = true;
4716	if (have_no_fdc) {
4717	DPRINT("no floppy controllers found\n");
4718	err = have_no_fdc;
4719	goto out_release_dma;
4720	}
4721
4722	for (drive = 0; drive < N_DRIVE; drive++) {
4723	if (!floppy_available(drive))
4724	continue;
4725
4726	floppy_device[drive].name = floppy_device_name;
4727	floppy_device[drive].id = drive;
4728	floppy_device[drive].dev.release = floppy_device_release;
4729	floppy_device[drive].dev.groups = floppy_dev_groups;
4730
4731	err = platform_device_register(&floppy_device[drive]);
4732	if (err)
4733	goto out_remove_drives;
4734
4735	registered[drive] = true;
4736
4737	err = device_add_disk(parent: &floppy_device[drive].dev,
4738	disk: disks[drive][0], NULL);
4739	if (err)
4740	goto out_remove_drives;
4741	}
4742
4743	return 0;
4744
4745	out_remove_drives:
4746	while (drive--) {
4747	if (floppy_available(drive)) {
4748	del_gendisk(gp: disks[drive][0]);
4749	if (registered[drive])
4750	platform_device_unregister(&floppy_device[drive]);
4751	}
4752	}
4753	out_release_dma:
4754	if (atomic_read(v: &usage_count))
4755	floppy_release_irq_and_dma();
4756	out_unreg_driver:
4757	platform_driver_unregister(&floppy_driver);
4758	out_unreg_blkdev:
4759	unregister_blkdev(FLOPPY_MAJOR, name: "fd");
4760	out_put_disk:
4761	destroy_workqueue(wq: floppy_wq);
4762	for (drive = 0; drive < N_DRIVE; drive++) {
4763	if (!disks[drive][0])
4764	break;
4765	del_timer_sync(timer: &motor_off_timer[drive]);
4766	put_disk(disk: disks[drive][0]);
4767	blk_mq_free_tag_set(set: &tag_sets[drive]);
4768	}
4769	return err;
4770	}
4771
4772	#ifndef MODULE
4773	static __init void floppy_async_init(void *data, async_cookie_t cookie)
4774	{
4775	do_floppy_init();
4776	}
4777	#endif
4778
4779	static int __init floppy_init(void)
4780	{
4781	#ifdef MODULE
4782	return do_floppy_init();
4783	#else
4784	/* Don't hold up the bootup by the floppy initialization */
4785	async_schedule(func: floppy_async_init, NULL);
4786	return 0;
4787	#endif
4788	}
4789
4790	static const struct io_region {
4791	int offset;
4792	int size;
4793	} io_regions[] = {
4794	{ 2, 1 },
4795	/* address + 3 is sometimes reserved by pnp bios for motherboard */
4796	{ 4, 2 },
4797	/* address + 6 is reserved, and may be taken by IDE.
4798	* Unfortunately, Adaptec doesn't know this :-(, */
4799	{ 7, 1 },
4800	};
4801
4802	static void floppy_release_allocated_regions(int fdc, const struct io_region *p)
4803	{
4804	while (p != io_regions) {
4805	p--;
4806	release_region(fdc_state[fdc].address + p->offset, p->size);
4807	}
4808	}
4809
4810	#define ARRAY_END(X) (&((X)[ARRAY_SIZE(X)]))
4811
4812	static int floppy_request_regions(int fdc)
4813	{
4814	const struct io_region *p;
4815
4816	for (p = io_regions; p < ARRAY_END(io_regions); p++) {
4817	if (!request_region(fdc_state[fdc].address + p->offset,
4818	p->size, "floppy")) {
4819	DPRINT("Floppy io-port 0x%04lx in use\n",
4820	fdc_state[fdc].address + p->offset);
4821	floppy_release_allocated_regions(fdc, p);
4822	return -EBUSY;
4823	}
4824	}
4825	return 0;
4826	}
4827
4828	static void floppy_release_regions(int fdc)
4829	{
4830	floppy_release_allocated_regions(fdc, ARRAY_END(io_regions));
4831	}
4832
4833	static int floppy_grab_irq_and_dma(void)
4834	{
4835	int fdc;
4836
4837	if (atomic_inc_return(v: &usage_count) > 1)
4838	return 0;
4839
4840	/*
4841	* We might have scheduled a free_irq(), wait it to
4842	* drain first:
4843	*/
4844	flush_workqueue(floppy_wq);
4845
4846	if (fd_request_irq()) {
4847	DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4848	FLOPPY_IRQ);
4849	atomic_dec(v: &usage_count);
4850	return -1;
4851	}
4852	if (fd_request_dma()) {
4853	DPRINT("Unable to grab DMA%d for the floppy driver\n",
4854	FLOPPY_DMA);
4855	if (can_use_virtual_dma & 2)
4856	use_virtual_dma = can_use_virtual_dma = 1;
4857	if (!(can_use_virtual_dma & 1)) {
4858	fd_free_irq();
4859	atomic_dec(v: &usage_count);
4860	return -1;
4861	}
4862	}
4863
4864	for (fdc = 0; fdc < N_FDC; fdc++) {
4865	if (fdc_state[fdc].address != -1) {
4866	if (floppy_request_regions(fdc))
4867	goto cleanup;
4868	}
4869	}
4870	for (fdc = 0; fdc < N_FDC; fdc++) {
4871	if (fdc_state[fdc].address != -1) {
4872	reset_fdc_info(fdc, mode: 1);
4873	fdc_outb(value: fdc_state[fdc].dor, fdc, FD_DOR);
4874	}
4875	}
4876
4877	set_dor(fdc: 0, mask: ~0, data: 8); /* avoid immediate interrupt */
4878
4879	for (fdc = 0; fdc < N_FDC; fdc++)
4880	if (fdc_state[fdc].address != -1)
4881	fdc_outb(value: fdc_state[fdc].dor, fdc, FD_DOR);
4882	/*
4883	* The driver will try and free resources and relies on us
4884	* to know if they were allocated or not.
4885	*/
4886	current_fdc = 0;
4887	irqdma_allocated = 1;
4888	return 0;
4889	cleanup:
4890	fd_free_irq();
4891	fd_free_dma();
4892	while (--fdc >= 0)
4893	floppy_release_regions(fdc);
4894	current_fdc = 0;
4895	atomic_dec(v: &usage_count);
4896	return -1;
4897	}
4898
4899	static void floppy_release_irq_and_dma(void)
4900	{
4901	int fdc;
4902	#ifndef __sparc__
4903	int drive;
4904	#endif
4905	long tmpsize;
4906	unsigned long tmpaddr;
4907
4908	if (!atomic_dec_and_test(v: &usage_count))
4909	return;
4910
4911	if (irqdma_allocated) {
4912	fd_disable_dma();
4913	fd_free_dma();
4914	fd_free_irq();
4915	irqdma_allocated = 0;
4916	}
4917	set_dor(fdc: 0, mask: ~0, data: 8);
4918	#if N_FDC > 1
4919	set_dor(fdc: 1, mask: ~8, data: 0);
4920	#endif
4921
4922	if (floppy_track_buffer && max_buffer_sectors) {
4923	tmpsize = max_buffer_sectors * 1024;
4924	tmpaddr = (unsigned long)floppy_track_buffer;
4925	floppy_track_buffer = NULL;
4926	max_buffer_sectors = 0;
4927	buffer_min = buffer_max = -1;
4928	fd_dma_mem_free(tmpaddr, tmpsize);
4929	}
4930	#ifndef __sparc__
4931	for (drive = 0; drive < N_FDC * 4; drive++)
4932	if (timer_pending(timer: motor_off_timer + drive))
4933	pr_info("motor off timer %d still active\n", drive);
4934	#endif
4935
4936	if (delayed_work_pending(&fd_timeout))
4937	pr_info("floppy timer still active:%s\n", timeout_message);
4938	if (delayed_work_pending(&fd_timer))
4939	pr_info("auxiliary floppy timer still active\n");
4940	if (work_pending(&floppy_work))
4941	pr_info("work still pending\n");
4942	for (fdc = 0; fdc < N_FDC; fdc++)
4943	if (fdc_state[fdc].address != -1)
4944	floppy_release_regions(fdc);
4945	}
4946
4947	#ifdef MODULE
4948
4949	static char *floppy;
4950
4951	static void __init parse_floppy_cfg_string(char *cfg)
4952	{
4953	char *ptr;
4954
4955	while (*cfg) {
4956	ptr = cfg;
4957	while (*cfg && *cfg != ' ' && *cfg != '\t')
4958	cfg++;
4959	if (*cfg) {
4960	*cfg = '\0';
4961	cfg++;
4962	}
4963	if (*ptr)
4964	floppy_setup(ptr);
4965	}
4966	}
4967
4968	static int __init floppy_module_init(void)
4969	{
4970	if (floppy)
4971	parse_floppy_cfg_string(floppy);
4972	return floppy_init();
4973	}
4974	module_init(floppy_module_init);
4975
4976	static void __exit floppy_module_exit(void)
4977	{
4978	int drive, i;
4979
4980	unregister_blkdev(FLOPPY_MAJOR, "fd");
4981	platform_driver_unregister(&floppy_driver);
4982
4983	destroy_workqueue(floppy_wq);
4984
4985	for (drive = 0; drive < N_DRIVE; drive++) {
4986	del_timer_sync(&motor_off_timer[drive]);
4987
4988	if (floppy_available(drive)) {
4989	for (i = 0; i < ARRAY_SIZE(floppy_type); i++) {
4990	if (disks[drive][i])
4991	del_gendisk(disks[drive][i]);
4992	}
4993	if (registered[drive])
4994	platform_device_unregister(&floppy_device[drive]);
4995	}
4996	for (i = 0; i < ARRAY_SIZE(floppy_type); i++) {
4997	if (disks[drive][i])
4998	put_disk(disks[drive][i]);
4999	}
5000	blk_mq_free_tag_set(&tag_sets[drive]);
5001	}
5002
5003	cancel_delayed_work_sync(&fd_timeout);
5004	cancel_delayed_work_sync(&fd_timer);
5005
5006	if (atomic_read(&usage_count))
5007	floppy_release_irq_and_dma();
5008
5009	/* eject disk, if any */
5010	fd_eject(0);
5011	}
5012
5013	module_exit(floppy_module_exit);
5014
5015	module_param(floppy, charp, 0);
5016	module_param(FLOPPY_IRQ, int, 0);
5017	module_param(FLOPPY_DMA, int, 0);
5018	MODULE_AUTHOR("Alain L. Knaff");
5019	MODULE_LICENSE("GPL");
5020
5021	/* This doesn't actually get used other than for module information */
5022	static const struct pnp_device_id floppy_pnpids[] = {
5023	{"PNP0700", 0},
5024	{}
5025	};
5026
5027	MODULE_DEVICE_TABLE(pnp, floppy_pnpids);
5028
5029	#else
5030
5031	__setup("floppy=", floppy_setup);
5032	module_init(floppy_init)
5033	#endif
5034
5035	MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);
5036