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