linux - drivers/block/floppy.c

5027 lines · 133.8 KiB

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