1/*
2 * linux/drivers/block/floppy.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1993, 1994 Alain Knaff
6 * Copyright (C) 1998 Alan Cox
7 */
8
9/*
10 * 02.12.91 - Changed to static variables to indicate need for reset
11 * and recalibrate. This makes some things easier (output_byte reset
12 * checking etc), and means less interrupt jumping in case of errors,
13 * so the code is hopefully easier to understand.
14 */
15
16/*
17 * This file is certainly a mess. I've tried my best to get it working,
18 * but I don't like programming floppies, and I have only one anyway.
19 * Urgel. I should check for more errors, and do more graceful error
20 * recovery. Seems there are problems with several drives. I've tried to
21 * correct them. No promises.
22 */
23
24/*
25 * As with hd.c, all routines within this file can (and will) be called
26 * by interrupts, so extreme caution is needed. A hardware interrupt
27 * handler may not sleep, or a kernel panic will happen. Thus I cannot
28 * call "floppy-on" directly, but have to set a special timer interrupt
29 * etc.
30 */
31
32/*
33 * 28.02.92 - made track-buffering routines, based on the routines written
34 * by entropy@wintermute.wpi.edu (Lawrence Foard). Linus.
35 */
36
37/*
38 * Automatic floppy-detection and formatting written by Werner Almesberger
39 * (almesber@nessie.cs.id.ethz.ch), who also corrected some problems with
40 * the floppy-change signal detection.
41 */
42
43/*
44 * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
45 * FDC data overrun bug, added some preliminary stuff for vertical
46 * recording support.
47 *
48 * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
49 *
50 * TODO: Errors are still not counted properly.
51 */
52
53/* 1992/9/20
54 * Modifications for ``Sector Shifting'' by Rob Hooft (hooft@chem.ruu.nl)
55 * modeled after the freeware MS-DOS program fdformat/88 V1.8 by
56 * Christoph H. Hochst\"atter.
57 * I have fixed the shift values to the ones I always use. Maybe a new
58 * ioctl() should be created to be able to modify them.
59 * There is a bug in the driver that makes it impossible to format a
60 * floppy as the first thing after bootup.
61 */
62
63/*
64 * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
65 * this helped the floppy driver as well. Much cleaner, and still seems to
66 * work.
67 */
68
69/* 1994/6/24 --bbroad-- added the floppy table entries and made
70 * minor modifications to allow 2.88 floppies to be run.
71 */
72
73/* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
74 * disk types.
75 */
76
77/*
78 * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
79 * format bug fixes, but unfortunately some new bugs too...
80 */
81
82/* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
83 * errors to allow safe writing by specialized programs.
84 */
85
86/* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
87 * by defining bit 1 of the "stretch" parameter to mean put sectors on the
88 * opposite side of the disk, leaving the sector IDs alone (i.e. Commodore's
89 * drives are "upside-down").
90 */
91
92/*
93 * 1995/8/26 -- Andreas Busse -- added Mips support.
94 */
95
96/*
97 * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
98 * features to asm/floppy.h.
99 */
100
101/*
102 * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
103 */
104
105/*
106 * 1998/05/07 -- Russell King -- More portability cleanups; moved definition of
107 * interrupt and dma channel to asm/floppy.h. Cleaned up some formatting &
108 * use of '0' for NULL.
109 */
110
111/*
112 * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
113 * failures.
114 */
115
116/*
117 * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
118 */
119
120/*
121 * 1999/08/13 -- Paul Slootman -- floppy stopped working on Alpha after 24
122 * days, 6 hours, 32 minutes and 32 seconds (i.e. MAXINT jiffies; ints were
123 * being used to store jiffies, which are unsigned longs).
124 */
125
126/*
127 * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
128 * - get rid of check_region
129 * - s/suser/capable/
130 */
131
132/*
133 * 2001/08/26 -- Paul Gortmaker - fix insmod oops on machines with no
134 * floppy controller (lingering task on list after module is gone... boom.)
135 */
136
137/*
138 * 2002/02/07 -- Anton Altaparmakov - Fix io ports reservation to correct range
139 * (0x3f2-0x3f5, 0x3f7). This fix is a bit of a hack but the proper fix
140 * requires many non-obvious changes in arch dependent code.
141 */
142
143/* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
144 * Better audit of register_blkdev.
145 */
146
147#undef FLOPPY_SILENT_DCL_CLEAR
148
149#define REALLY_SLOW_IO
150
151#define DEBUGT 2
152
153#define DPRINT(format, args...) \
154 pr_info("floppy%d: " format, current_drive, ##args)
155
156#define DCL_DEBUG /* debug disk change line */
157#ifdef DCL_DEBUG
158#define debug_dcl(test, fmt, args...) \
159 do { if ((test) & FD_DEBUG) DPRINT(fmt, ##args); } while (0)
160#else
161#define debug_dcl(test, fmt, args...) \
162 do { if (0) DPRINT(fmt, ##args); } while (0)
163#endif
164
165/* do print messages for unexpected interrupts */
166static int print_unex = 1;
167#include <linux/module.h>
168#include <linux/sched.h>
169#include <linux/fs.h>
170#include <linux/kernel.h>
171#include <linux/timer.h>
172#include <linux/workqueue.h>
173#define FDPATCHES
174#include <linux/fdreg.h>
175#include <linux/fd.h>
176#include <linux/hdreg.h>
177#include <linux/errno.h>
178#include <linux/slab.h>
179#include <linux/mm.h>
180#include <linux/bio.h>
181#include <linux/string.h>
182#include <linux/jiffies.h>
183#include <linux/fcntl.h>
184#include <linux/delay.h>
185#include <linux/mc146818rtc.h> /* CMOS defines */
186#include <linux/ioport.h>
187#include <linux/interrupt.h>
188#include <linux/init.h>
189#include <linux/platform_device.h>
190#include <linux/mod_devicetable.h>
191#include <linux/mutex.h>
192#include <linux/io.h>
193#include <linux/uaccess.h>
194#include <linux/async.h>
195#include <linux/compat.h>
196
197/*
198 * PS/2 floppies have much slower step rates than regular floppies.
199 * It's been recommended that take about 1/4 of the default speed
200 * in some more extreme cases.
201 */
202static DEFINE_MUTEX(floppy_mutex);
203static int slow_floppy;
204
205#include <asm/dma.h>
206#include <asm/irq.h>
207
208static int FLOPPY_IRQ = 6;
209static int FLOPPY_DMA = 2;
210static int can_use_virtual_dma = 2;
211/* =======
212 * can use virtual DMA:
213 * 0 = use of virtual DMA disallowed by config
214 * 1 = use of virtual DMA prescribed by config
215 * 2 = no virtual DMA preference configured. By default try hard DMA,
216 * but fall back on virtual DMA when not enough memory available
217 */
218
219static int use_virtual_dma;
220/* =======
221 * use virtual DMA
222 * 0 using hard DMA
223 * 1 using virtual DMA
224 * This variable is set to virtual when a DMA mem problem arises, and
225 * reset back in floppy_grab_irq_and_dma.
226 * It is not safe to reset it in other circumstances, because the floppy
227 * driver may have several buffers in use at once, and we do currently not
228 * record each buffers capabilities
229 */
230
231static DEFINE_SPINLOCK(floppy_lock);
232
233static unsigned short virtual_dma_port = 0x3f0;
234irqreturn_t floppy_interrupt(int irq, void *dev_id);
235static int set_dor(int fdc, char mask, char data);
236
237#define K_64 0x10000 /* 64KB */
238
239/* the following is the mask of allowed drives. By default units 2 and
240 * 3 of both floppy controllers are disabled, because switching on the
241 * motor of these drives causes system hangs on some PCI computers. drive
242 * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
243 * a drive is allowed.
244 *
245 * NOTE: This must come before we include the arch floppy header because
246 * some ports reference this variable from there. -DaveM
247 */
248
249static int allowed_drive_mask = 0x33;
250
251#include <asm/floppy.h>
252
253static int irqdma_allocated;
254
255#include <linux/blk-mq.h>
256#include <linux/blkpg.h>
257#include <linux/cdrom.h> /* for the compatibility eject ioctl */
258#include <linux/completion.h>
259
260static LIST_HEAD(floppy_reqs);
261static struct request *current_req;
262static int set_next_request(void);
263
264#ifndef fd_get_dma_residue
265#define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
266#endif
267
268/* Dma Memory related stuff */
269
270#ifndef fd_dma_mem_free
271#define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
272#endif
273
274#ifndef fd_dma_mem_alloc
275#define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL, get_order(size))
276#endif
277
278#ifndef fd_cacheflush
279#define fd_cacheflush(addr, size) /* nothing... */
280#endif
281
282static inline void fallback_on_nodma_alloc(char **addr, size_t l)
283{
284#ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
285 if (*addr)
286 return; /* we have the memory */
287 if (can_use_virtual_dma != 2)
288 return; /* no fallback allowed */
289 pr_info("DMA memory shortage. Temporarily falling back on virtual DMA\n");
290 *addr = (char *)nodma_mem_alloc(l);
291#else
292 return;
293#endif
294}
295
296/* End dma memory related stuff */
297
298static unsigned long fake_change;
299static bool initialized;
300
301#define ITYPE(x) (((x) >> 2) & 0x1f)
302#define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
303#define UNIT(x) ((x) & 0x03) /* drive on fdc */
304#define FDC(x) (((x) & 0x04) >> 2) /* fdc of drive */
305 /* reverse mapping from unit and fdc to drive */
306#define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
307
308#define DP (&drive_params[current_drive])
309#define DRS (&drive_state[current_drive])
310#define DRWE (&write_errors[current_drive])
311#define FDCS (&fdc_state[fdc])
312
313#define UDP (&drive_params[drive])
314#define UDRS (&drive_state[drive])
315#define UDRWE (&write_errors[drive])
316#define UFDCS (&fdc_state[FDC(drive)])
317
318#define PH_HEAD(floppy, head) (((((floppy)->stretch & 2) >> 1) ^ head) << 2)
319#define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
320
321/* read/write */
322#define COMMAND (raw_cmd->cmd[0])
323#define DR_SELECT (raw_cmd->cmd[1])
324#define TRACK (raw_cmd->cmd[2])
325#define HEAD (raw_cmd->cmd[3])
326#define SECTOR (raw_cmd->cmd[4])
327#define SIZECODE (raw_cmd->cmd[5])
328#define SECT_PER_TRACK (raw_cmd->cmd[6])
329#define GAP (raw_cmd->cmd[7])
330#define SIZECODE2 (raw_cmd->cmd[8])
331#define NR_RW 9
332
333/* format */
334#define F_SIZECODE (raw_cmd->cmd[2])
335#define F_SECT_PER_TRACK (raw_cmd->cmd[3])
336#define F_GAP (raw_cmd->cmd[4])
337#define F_FILL (raw_cmd->cmd[5])
338#define NR_F 6
339
340/*
341 * Maximum disk size (in kilobytes).
342 * This default is used whenever the current disk size is unknown.
343 * [Now it is rather a minimum]
344 */
345#define MAX_DISK_SIZE 4 /* 3984 */
346
347/*
348 * globals used by 'result()'
349 */
350#define MAX_REPLIES 16
351static unsigned char reply_buffer[MAX_REPLIES];
352static int inr; /* size of reply buffer, when called from interrupt */
353#define ST0 (reply_buffer[0])
354#define ST1 (reply_buffer[1])
355#define ST2 (reply_buffer[2])
356#define ST3 (reply_buffer[0]) /* result of GETSTATUS */
357#define R_TRACK (reply_buffer[3])
358#define R_HEAD (reply_buffer[4])
359#define R_SECTOR (reply_buffer[5])
360#define R_SIZECODE (reply_buffer[6])
361
362#define SEL_DLY (2 * HZ / 100)
363
364/*
365 * this struct defines the different floppy drive types.
366 */
367static struct {
368 struct floppy_drive_params params;
369 const char *name; /* name printed while booting */
370} default_drive_params[] = {
371/* NOTE: the time values in jiffies should be in msec!
372 CMOS drive type
373 | Maximum data rate supported by drive type
374 | | Head load time, msec
375 | | | Head unload time, msec (not used)
376 | | | | Step rate interval, usec
377 | | | | | Time needed for spinup time (jiffies)
378 | | | | | | Timeout for spinning down (jiffies)
379 | | | | | | | Spindown offset (where disk stops)
380 | | | | | | | | Select delay
381 | | | | | | | | | RPS
382 | | | | | | | | | | Max number of tracks
383 | | | | | | | | | | | Interrupt timeout
384 | | | | | | | | | | | | Max nonintlv. sectors
385 | | | | | | | | | | | | | -Max Errors- flags */
386{{0, 500, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 80, 3*HZ, 20, {3,1,2,0,2}, 0,
387 0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
388
389{{1, 300, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 40, 3*HZ, 17, {3,1,2,0,2}, 0,
390 0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
391
392{{2, 500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6, 83, 3*HZ, 17, {3,1,2,0,2}, 0,
393 0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
394
395{{3, 250, 16, 16, 3000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
396 0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
397
398{{4, 500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
399 0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
400
401{{5, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
402 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
403
404{{6, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
405 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
406/* | --autodetected formats--- | | |
407 * read_track | | Name printed when booting
408 * | Native format
409 * Frequency of disk change checks */
410};
411
412static struct floppy_drive_params drive_params[N_DRIVE];
413static struct floppy_drive_struct drive_state[N_DRIVE];
414static struct floppy_write_errors write_errors[N_DRIVE];
415static struct timer_list motor_off_timer[N_DRIVE];
416static struct gendisk *disks[N_DRIVE];
417static struct blk_mq_tag_set tag_sets[N_DRIVE];
418static struct block_device *opened_bdev[N_DRIVE];
419static DEFINE_MUTEX(open_lock);
420static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
421
422/*
423 * This struct defines the different floppy types.
424 *
425 * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
426 * types (e.g. 360kB diskette in 1.2MB drive, etc.). Bit 1 of 'stretch'
427 * tells if the disk is in Commodore 1581 format, which means side 0 sectors
428 * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
429 * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
430 * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
431 * side 0 is on physical side 0 (but with the misnamed sector IDs).
432 * 'stretch' should probably be renamed to something more general, like
433 * 'options'.
434 *
435 * Bits 2 through 9 of 'stretch' tell the number of the first sector.
436 * The LSB (bit 2) is flipped. For most disks, the first sector
437 * is 1 (represented by 0x00<<2). For some CP/M and music sampler
438 * disks (such as Ensoniq EPS 16plus) it is 0 (represented as 0x01<<2).
439 * For Amstrad CPC disks it is 0xC1 (represented as 0xC0<<2).
440 *
441 * Other parameters should be self-explanatory (see also setfdprm(8)).
442 */
443/*
444 Size
445 | Sectors per track
446 | | Head
447 | | | Tracks
448 | | | | Stretch
449 | | | | | Gap 1 size
450 | | | | | | Data rate, | 0x40 for perp
451 | | | | | | | Spec1 (stepping rate, head unload
452 | | | | | | | | /fmt gap (gap2) */
453static struct floppy_struct floppy_type[32] = {
454 { 0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL }, /* 0 no testing */
455 { 720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360" }, /* 1 360KB PC */
456 { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /* 2 1.2MB AT */
457 { 720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360" }, /* 3 360KB SS 3.5" */
458 { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720" }, /* 4 720KB 3.5" */
459 { 720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360" }, /* 5 360KB AT */
460 { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720" }, /* 6 720KB AT */
461 { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /* 7 1.44MB 3.5" */
462 { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /* 8 2.88MB 3.5" */
463 { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /* 9 3.12MB 3.5" */
464
465 { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25" */
466 { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5" */
467 { 820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410" }, /* 12 410KB 5.25" */
468 { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820" }, /* 13 820KB 3.5" */
469 { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25" */
470 { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5" */
471 { 840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420" }, /* 16 420KB 5.25" */
472 { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830" }, /* 17 830KB 3.5" */
473 { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25" */
474 { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5" */
475
476 { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880" }, /* 20 880KB 5.25" */
477 { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5" */
478 { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5" */
479 { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25" */
480 { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5" */
481 { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5" */
482 { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5" */
483 { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5" */
484 { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5" */
485 { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5" */
486
487 { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800" }, /* 30 800KB 3.5" */
488 { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5" */
489};
490
491#define SECTSIZE (_FD_SECTSIZE(*floppy))
492
493/* Auto-detection: Disk type used until the next media change occurs. */
494static struct floppy_struct *current_type[N_DRIVE];
495
496/*
497 * User-provided type information. current_type points to
498 * the respective entry of this array.
499 */
500static struct floppy_struct user_params[N_DRIVE];
501
502static sector_t floppy_sizes[256];
503
504static char floppy_device_name[] = "floppy";
505
506/*
507 * The driver is trying to determine the correct media format
508 * while probing is set. rw_interrupt() clears it after a
509 * successful access.
510 */
511static int probing;
512
513/* Synchronization of FDC access. */
514#define FD_COMMAND_NONE -1
515#define FD_COMMAND_ERROR 2
516#define FD_COMMAND_OKAY 3
517
518static volatile int command_status = FD_COMMAND_NONE;
519static unsigned long fdc_busy;
520static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
521static DECLARE_WAIT_QUEUE_HEAD(command_done);
522
523/* Errors during formatting are counted here. */
524static int format_errors;
525
526/* Format request descriptor. */
527static struct format_descr format_req;
528
529/*
530 * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
531 * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
532 * H is head unload time (1=16ms, 2=32ms, etc)
533 */
534
535/*
536 * Track buffer
537 * Because these are written to by the DMA controller, they must
538 * not contain a 64k byte boundary crossing, or data will be
539 * corrupted/lost.
540 */
541static char *floppy_track_buffer;
542static int max_buffer_sectors;
543
544static int *errors;
545typedef void (*done_f)(int);
546static const struct cont_t {
547 void (*interrupt)(void);
548 /* this is called after the interrupt of the
549 * main command */
550 void (*redo)(void); /* this is called to retry the operation */
551 void (*error)(void); /* this is called to tally an error */
552 done_f done; /* this is called to say if the operation has
553 * succeeded/failed */
554} *cont;
555
556static void floppy_ready(void);
557static void floppy_start(void);
558static void process_fd_request(void);
559static void recalibrate_floppy(void);
560static void floppy_shutdown(struct work_struct *);
561
562static int floppy_request_regions(int);
563static void floppy_release_regions(int);
564static int floppy_grab_irq_and_dma(void);
565static void floppy_release_irq_and_dma(void);
566
567/*
568 * The "reset" variable should be tested whenever an interrupt is scheduled,
569 * after the commands have been sent. This is to ensure that the driver doesn't
570 * get wedged when the interrupt doesn't come because of a failed command.
571 * reset doesn't need to be tested before sending commands, because
572 * output_byte is automatically disabled when reset is set.
573 */
574static void reset_fdc(void);
575
576/*
577 * These are global variables, as that's the easiest way to give
578 * information to interrupts. They are the data used for the current
579 * request.
580 */
581#define NO_TRACK -1
582#define NEED_1_RECAL -2
583#define NEED_2_RECAL -3
584
585static atomic_t usage_count = ATOMIC_INIT(0);
586
587/* buffer related variables */
588static int buffer_track = -1;
589static int buffer_drive = -1;
590static int buffer_min = -1;
591static int buffer_max = -1;
592
593/* fdc related variables, should end up in a struct */
594static struct floppy_fdc_state fdc_state[N_FDC];
595static int fdc; /* current fdc */
596
597static struct workqueue_struct *floppy_wq;
598
599static struct floppy_struct *_floppy = floppy_type;
600static unsigned char current_drive;
601static long current_count_sectors;
602static unsigned char fsector_t; /* sector in track */
603static unsigned char in_sector_offset; /* offset within physical sector,
604 * expressed in units of 512 bytes */
605
606static inline bool drive_no_geom(int drive)
607{
608 return !current_type[drive] && !ITYPE(UDRS->fd_device);
609}
610
611#ifndef fd_eject
612static inline int fd_eject(int drive)
613{
614 return -EINVAL;
615}
616#endif
617
618/*
619 * Debugging
620 * =========
621 */
622#ifdef DEBUGT
623static long unsigned debugtimer;
624
625static inline void set_debugt(void)
626{
627 debugtimer = jiffies;
628}
629
630static inline void debugt(const char *func, const char *msg)
631{
632 if (DP->flags & DEBUGT)
633 pr_info("%s:%s dtime=%lu\n", func, msg, jiffies - debugtimer);
634}
635#else
636static inline void set_debugt(void) { }
637static inline void debugt(const char *func, const char *msg) { }
638#endif /* DEBUGT */
639
640
641static DECLARE_DELAYED_WORK(fd_timeout, floppy_shutdown);
642static const char *timeout_message;
643
644static void is_alive(const char *func, const char *message)
645{
646 /* this routine checks whether the floppy driver is "alive" */
647 if (test_bit(0, &fdc_busy) && command_status < 2 &&
648 !delayed_work_pending(&fd_timeout)) {
649 DPRINT("%s: timeout handler died. %s\n", func, message);
650 }
651}
652
653static void (*do_floppy)(void) = NULL;
654
655#define OLOGSIZE 20
656
657static void (*lasthandler)(void);
658static unsigned long interruptjiffies;
659static unsigned long resultjiffies;
660static int resultsize;
661static unsigned long lastredo;
662
663static struct output_log {
664 unsigned char data;
665 unsigned char status;
666 unsigned long jiffies;
667} output_log[OLOGSIZE];
668
669static int output_log_pos;
670
671#define current_reqD -1
672#define MAXTIMEOUT -2
673
674static void __reschedule_timeout(int drive, const char *message)
675{
676 unsigned long delay;
677
678 if (drive == current_reqD)
679 drive = current_drive;
680
681 if (drive < 0 || drive >= N_DRIVE) {
682 delay = 20UL * HZ;
683 drive = 0;
684 } else
685 delay = UDP->timeout;
686
687 mod_delayed_work(floppy_wq, &fd_timeout, delay);
688 if (UDP->flags & FD_DEBUG)
689 DPRINT("reschedule timeout %s\n", message);
690 timeout_message = message;
691}
692
693static void reschedule_timeout(int drive, const char *message)
694{
695 unsigned long flags;
696
697 spin_lock_irqsave(&floppy_lock, flags);
698 __reschedule_timeout(drive, message);
699 spin_unlock_irqrestore(&floppy_lock, flags);
700}
701
702#define INFBOUND(a, b) (a) = max_t(int, a, b)
703#define SUPBOUND(a, b) (a) = min_t(int, a, b)
704
705/*
706 * Bottom half floppy driver.
707 * ==========================
708 *
709 * This part of the file contains the code talking directly to the hardware,
710 * and also the main service loop (seek-configure-spinup-command)
711 */
712
713/*
714 * disk change.
715 * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
716 * and the last_checked date.
717 *
718 * last_checked is the date of the last check which showed 'no disk change'
719 * FD_DISK_CHANGE is set under two conditions:
720 * 1. The floppy has been changed after some i/o to that floppy already
721 * took place.
722 * 2. No floppy disk is in the drive. This is done in order to ensure that
723 * requests are quickly flushed in case there is no disk in the drive. It
724 * follows that FD_DISK_CHANGE can only be cleared if there is a disk in
725 * the drive.
726 *
727 * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
728 * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
729 * each seek. If a disk is present, the disk change line should also be
730 * cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
731 * change line is set, this means either that no disk is in the drive, or
732 * that it has been removed since the last seek.
733 *
734 * This means that we really have a third possibility too:
735 * The floppy has been changed after the last seek.
736 */
737
738static int disk_change(int drive)
739{
740 int fdc = FDC(drive);
741
742 if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
743 DPRINT("WARNING disk change called early\n");
744 if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
745 (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
746 DPRINT("probing disk change on unselected drive\n");
747 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
748 (unsigned int)FDCS->dor);
749 }
750
751 debug_dcl(UDP->flags,
752 "checking disk change line for drive %d\n", drive);
753 debug_dcl(UDP->flags, "jiffies=%lu\n", jiffies);
754 debug_dcl(UDP->flags, "disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
755 debug_dcl(UDP->flags, "flags=%lx\n", UDRS->flags);
756
757 if (UDP->flags & FD_BROKEN_DCL)
758 return test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
759 if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
760 set_bit(FD_VERIFY_BIT, &UDRS->flags);
761 /* verify write protection */
762
763 if (UDRS->maxblock) /* mark it changed */
764 set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
765
766 /* invalidate its geometry */
767 if (UDRS->keep_data >= 0) {
768 if ((UDP->flags & FTD_MSG) &&
769 current_type[drive] != NULL)
770 DPRINT("Disk type is undefined after disk change\n");
771 current_type[drive] = NULL;
772 floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
773 }
774
775 return 1;
776 } else {
777 UDRS->last_checked = jiffies;
778 clear_bit(FD_DISK_NEWCHANGE_BIT, &UDRS->flags);
779 }
780 return 0;
781}
782
783static inline int is_selected(int dor, int unit)
784{
785 return ((dor & (0x10 << unit)) && (dor & 3) == unit);
786}
787
788static bool is_ready_state(int status)
789{
790 int state = status & (STATUS_READY | STATUS_DIR | STATUS_DMA);
791 return state == STATUS_READY;
792}
793
794static int set_dor(int fdc, char mask, char data)
795{
796 unsigned char unit;
797 unsigned char drive;
798 unsigned char newdor;
799 unsigned char olddor;
800
801 if (FDCS->address == -1)
802 return -1;
803
804 olddor = FDCS->dor;
805 newdor = (olddor & mask) | data;
806 if (newdor != olddor) {
807 unit = olddor & 0x3;
808 if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
809 drive = REVDRIVE(fdc, unit);
810 debug_dcl(UDP->flags,
811 "calling disk change from set_dor\n");
812 disk_change(drive);
813 }
814 FDCS->dor = newdor;
815 fd_outb(newdor, FD_DOR);
816
817 unit = newdor & 0x3;
818 if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
819 drive = REVDRIVE(fdc, unit);
820 UDRS->select_date = jiffies;
821 }
822 }
823 return olddor;
824}
825
826static void twaddle(void)
827{
828 if (DP->select_delay)
829 return;
830 fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
831 fd_outb(FDCS->dor, FD_DOR);
832 DRS->select_date = jiffies;
833}
834
835/*
836 * Reset all driver information about the current fdc.
837 * This is needed after a reset, and after a raw command.
838 */
839static void reset_fdc_info(int mode)
840{
841 int drive;
842
843 FDCS->spec1 = FDCS->spec2 = -1;
844 FDCS->need_configure = 1;
845 FDCS->perp_mode = 1;
846 FDCS->rawcmd = 0;
847 for (drive = 0; drive < N_DRIVE; drive++)
848 if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
849 UDRS->track = NEED_2_RECAL;
850}
851
852/* selects the fdc and drive, and enables the fdc's input/dma. */
853static void set_fdc(int drive)
854{
855 if (drive >= 0 && drive < N_DRIVE) {
856 fdc = FDC(drive);
857 current_drive = drive;
858 }
859 if (fdc != 1 && fdc != 0) {
860 pr_info("bad fdc value\n");
861 return;
862 }
863 set_dor(fdc, ~0, 8);
864#if N_FDC > 1
865 set_dor(1 - fdc, ~8, 0);
866#endif
867 if (FDCS->rawcmd == 2)
868 reset_fdc_info(1);
869 if (fd_inb(FD_STATUS) != STATUS_READY)
870 FDCS->reset = 1;
871}
872
873/* locks the driver */
874static int lock_fdc(int drive)
875{
876 if (WARN(atomic_read(&usage_count) == 0,
877 "Trying to lock fdc while usage count=0\n"))
878 return -1;
879
880 if (wait_event_interruptible(fdc_wait, !test_and_set_bit(0, &fdc_busy)))
881 return -EINTR;
882
883 command_status = FD_COMMAND_NONE;
884
885 reschedule_timeout(drive, "lock fdc");
886 set_fdc(drive);
887 return 0;
888}
889
890/* unlocks the driver */
891static void unlock_fdc(void)
892{
893 if (!test_bit(0, &fdc_busy))
894 DPRINT("FDC access conflict!\n");
895
896 raw_cmd = NULL;
897 command_status = FD_COMMAND_NONE;
898 cancel_delayed_work(&fd_timeout);
899 do_floppy = NULL;
900 cont = NULL;
901 clear_bit(0, &fdc_busy);
902 wake_up(&fdc_wait);
903}
904
905/* switches the motor off after a given timeout */
906static void motor_off_callback(struct timer_list *t)
907{
908 unsigned long nr = t - motor_off_timer;
909 unsigned char mask = ~(0x10 << UNIT(nr));
910
911 if (WARN_ON_ONCE(nr >= N_DRIVE))
912 return;
913
914 set_dor(FDC(nr), mask, 0);
915}
916
917/* schedules motor off */
918static void floppy_off(unsigned int drive)
919{
920 unsigned long volatile delta;
921 int fdc = FDC(drive);
922
923 if (!(FDCS->dor & (0x10 << UNIT(drive))))
924 return;
925
926 del_timer(motor_off_timer + drive);
927
928 /* make spindle stop in a position which minimizes spinup time
929 * next time */
930 if (UDP->rps) {
931 delta = jiffies - UDRS->first_read_date + HZ -
932 UDP->spindown_offset;
933 delta = ((delta * UDP->rps) % HZ) / UDP->rps;
934 motor_off_timer[drive].expires =
935 jiffies + UDP->spindown - delta;
936 }
937 add_timer(motor_off_timer + drive);
938}
939
940/*
941 * cycle through all N_DRIVE floppy drives, for disk change testing.
942 * stopping at current drive. This is done before any long operation, to
943 * be sure to have up to date disk change information.
944 */
945static void scandrives(void)
946{
947 int i;
948 int drive;
949 int saved_drive;
950
951 if (DP->select_delay)
952 return;
953
954 saved_drive = current_drive;
955 for (i = 0; i < N_DRIVE; i++) {
956 drive = (saved_drive + i + 1) % N_DRIVE;
957 if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
958 continue; /* skip closed drives */
959 set_fdc(drive);
960 if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
961 (0x10 << UNIT(drive))))
962 /* switch the motor off again, if it was off to
963 * begin with */
964 set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
965 }
966 set_fdc(saved_drive);
967}
968
969static void empty(void)
970{
971}
972
973static void (*floppy_work_fn)(void);
974
975static void floppy_work_workfn(struct work_struct *work)
976{
977 floppy_work_fn();
978}
979
980static DECLARE_WORK(floppy_work, floppy_work_workfn);
981
982static void schedule_bh(void (*handler)(void))
983{
984 WARN_ON(work_pending(&floppy_work));
985
986 floppy_work_fn = handler;
987 queue_work(floppy_wq, &floppy_work);
988}
989
990static void (*fd_timer_fn)(void) = NULL;
991
992static void fd_timer_workfn(struct work_struct *work)
993{
994 fd_timer_fn();
995}
996
997static DECLARE_DELAYED_WORK(fd_timer, fd_timer_workfn);
998
999static void cancel_activity(void)
1000{
1001 do_floppy = NULL;
1002 cancel_delayed_work_sync(&fd_timer);
1003 cancel_work_sync(&floppy_work);
1004}
1005
1006/* this function makes sure that the disk stays in the drive during the
1007 * transfer */
1008static void fd_watchdog(void)
1009{
1010 debug_dcl(DP->flags, "calling disk change from watchdog\n");
1011
1012 if (disk_change(current_drive)) {
1013 DPRINT("disk removed during i/o\n");
1014 cancel_activity();
1015 cont->done(0);
1016 reset_fdc();
1017 } else {
1018 cancel_delayed_work(&fd_timer);
1019 fd_timer_fn = fd_watchdog;
1020 queue_delayed_work(floppy_wq, &fd_timer, HZ / 10);
1021 }
1022}
1023
1024static void main_command_interrupt(void)
1025{
1026 cancel_delayed_work(&fd_timer);
1027 cont->interrupt();
1028}
1029
1030/* waits for a delay (spinup or select) to pass */
1031static int fd_wait_for_completion(unsigned long expires,
1032 void (*function)(void))
1033{
1034 if (FDCS->reset) {
1035 reset_fdc(); /* do the reset during sleep to win time
1036 * if we don't need to sleep, it's a good
1037 * occasion anyways */
1038 return 1;
1039 }
1040
1041 if (time_before(jiffies, expires)) {
1042 cancel_delayed_work(&fd_timer);
1043 fd_timer_fn = function;
1044 queue_delayed_work(floppy_wq, &fd_timer, expires - jiffies);
1045 return 1;
1046 }
1047 return 0;
1048}
1049
1050static void setup_DMA(void)
1051{
1052 unsigned long f;
1053
1054 if (raw_cmd->length == 0) {
1055 int i;
1056
1057 pr_info("zero dma transfer size:");
1058 for (i = 0; i < raw_cmd->cmd_count; i++)
1059 pr_cont("%x,", raw_cmd->cmd[i]);
1060 pr_cont("\n");
1061 cont->done(0);
1062 FDCS->reset = 1;
1063 return;
1064 }
1065 if (((unsigned long)raw_cmd->kernel_data) % 512) {
1066 pr_info("non aligned address: %p\n", raw_cmd->kernel_data);
1067 cont->done(0);
1068 FDCS->reset = 1;
1069 return;
1070 }
1071 f = claim_dma_lock();
1072 fd_disable_dma();
1073#ifdef fd_dma_setup
1074 if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1075 (raw_cmd->flags & FD_RAW_READ) ?
1076 DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
1077 release_dma_lock(f);
1078 cont->done(0);
1079 FDCS->reset = 1;
1080 return;
1081 }
1082 release_dma_lock(f);
1083#else
1084 fd_clear_dma_ff();
1085 fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1086 fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
1087 DMA_MODE_READ : DMA_MODE_WRITE);
1088 fd_set_dma_addr(raw_cmd->kernel_data);
1089 fd_set_dma_count(raw_cmd->length);
1090 virtual_dma_port = FDCS->address;
1091 fd_enable_dma();
1092 release_dma_lock(f);
1093#endif
1094}
1095
1096static void show_floppy(void);
1097
1098/* waits until the fdc becomes ready */
1099static int wait_til_ready(void)
1100{
1101 int status;
1102 int counter;
1103
1104 if (FDCS->reset)
1105 return -1;
1106 for (counter = 0; counter < 10000; counter++) {
1107 status = fd_inb(FD_STATUS);
1108 if (status & STATUS_READY)
1109 return status;
1110 }
1111 if (initialized) {
1112 DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
1113 show_floppy();
1114 }
1115 FDCS->reset = 1;
1116 return -1;
1117}
1118
1119/* sends a command byte to the fdc */
1120static int output_byte(char byte)
1121{
1122 int status = wait_til_ready();
1123
1124 if (status < 0)
1125 return -1;
1126
1127 if (is_ready_state(status)) {
1128 fd_outb(byte, FD_DATA);
1129 output_log[output_log_pos].data = byte;
1130 output_log[output_log_pos].status = status;
1131 output_log[output_log_pos].jiffies = jiffies;
1132 output_log_pos = (output_log_pos + 1) % OLOGSIZE;
1133 return 0;
1134 }
1135 FDCS->reset = 1;
1136 if (initialized) {
1137 DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
1138 byte, fdc, status);
1139 show_floppy();
1140 }
1141 return -1;
1142}
1143
1144/* gets the response from the fdc */
1145static int result(void)
1146{
1147 int i;
1148 int status = 0;
1149
1150 for (i = 0; i < MAX_REPLIES; i++) {
1151 status = wait_til_ready();
1152 if (status < 0)
1153 break;
1154 status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
1155 if ((status & ~STATUS_BUSY) == STATUS_READY) {
1156 resultjiffies = jiffies;
1157 resultsize = i;
1158 return i;
1159 }
1160 if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
1161 reply_buffer[i] = fd_inb(FD_DATA);
1162 else
1163 break;
1164 }
1165 if (initialized) {
1166 DPRINT("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
1167 fdc, status, i);
1168 show_floppy();
1169 }
1170 FDCS->reset = 1;
1171 return -1;
1172}
1173
1174#define MORE_OUTPUT -2
1175/* does the fdc need more output? */
1176static int need_more_output(void)
1177{
1178 int status = wait_til_ready();
1179
1180 if (status < 0)
1181 return -1;
1182
1183 if (is_ready_state(status))
1184 return MORE_OUTPUT;
1185
1186 return result();
1187}
1188
1189/* Set perpendicular mode as required, based on data rate, if supported.
1190 * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
1191 */
1192static void perpendicular_mode(void)
1193{
1194 unsigned char perp_mode;
1195
1196 if (raw_cmd->rate & 0x40) {
1197 switch (raw_cmd->rate & 3) {
1198 case 0:
1199 perp_mode = 2;
1200 break;
1201 case 3:
1202 perp_mode = 3;
1203 break;
1204 default:
1205 DPRINT("Invalid data rate for perpendicular mode!\n");
1206 cont->done(0);
1207 FDCS->reset = 1;
1208 /*
1209 * convenient way to return to
1210 * redo without too much hassle
1211 * (deep stack et al.)
1212 */
1213 return;
1214 }
1215 } else
1216 perp_mode = 0;
1217
1218 if (FDCS->perp_mode == perp_mode)
1219 return;
1220 if (FDCS->version >= FDC_82077_ORIG) {
1221 output_byte(FD_PERPENDICULAR);
1222 output_byte(perp_mode);
1223 FDCS->perp_mode = perp_mode;
1224 } else if (perp_mode) {
1225 DPRINT("perpendicular mode not supported by this FDC.\n");
1226 }
1227} /* perpendicular_mode */
1228
1229static int fifo_depth = 0xa;
1230static int no_fifo;
1231
1232static int fdc_configure(void)
1233{
1234 /* Turn on FIFO */
1235 output_byte(FD_CONFIGURE);
1236 if (need_more_output() != MORE_OUTPUT)
1237 return 0;
1238 output_byte(0);
1239 output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1240 output_byte(0); /* pre-compensation from track
1241 0 upwards */
1242 return 1;
1243}
1244
1245#define NOMINAL_DTR 500
1246
1247/* Issue a "SPECIFY" command to set the step rate time, head unload time,
1248 * head load time, and DMA disable flag to values needed by floppy.
1249 *
1250 * The value "dtr" is the data transfer rate in Kbps. It is needed
1251 * to account for the data rate-based scaling done by the 82072 and 82077
1252 * FDC types. This parameter is ignored for other types of FDCs (i.e.
1253 * 8272a).
1254 *
1255 * Note that changing the data transfer rate has a (probably deleterious)
1256 * effect on the parameters subject to scaling for 82072/82077 FDCs, so
1257 * fdc_specify is called again after each data transfer rate
1258 * change.
1259 *
1260 * srt: 1000 to 16000 in microseconds
1261 * hut: 16 to 240 milliseconds
1262 * hlt: 2 to 254 milliseconds
1263 *
1264 * These values are rounded up to the next highest available delay time.
1265 */
1266static void fdc_specify(void)
1267{
1268 unsigned char spec1;
1269 unsigned char spec2;
1270 unsigned long srt;
1271 unsigned long hlt;
1272 unsigned long hut;
1273 unsigned long dtr = NOMINAL_DTR;
1274 unsigned long scale_dtr = NOMINAL_DTR;
1275 int hlt_max_code = 0x7f;
1276 int hut_max_code = 0xf;
1277
1278 if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
1279 fdc_configure();
1280 FDCS->need_configure = 0;
1281 }
1282
1283 switch (raw_cmd->rate & 0x03) {
1284 case 3:
1285 dtr = 1000;
1286 break;
1287 case 1:
1288 dtr = 300;
1289 if (FDCS->version >= FDC_82078) {
1290 /* chose the default rate table, not the one
1291 * where 1 = 2 Mbps */
1292 output_byte(FD_DRIVESPEC);
1293 if (need_more_output() == MORE_OUTPUT) {
1294 output_byte(UNIT(current_drive));
1295 output_byte(0xc0);
1296 }
1297 }
1298 break;
1299 case 2:
1300 dtr = 250;
1301 break;
1302 }
1303
1304 if (FDCS->version >= FDC_82072) {
1305 scale_dtr = dtr;
1306 hlt_max_code = 0x00; /* 0==256msec*dtr0/dtr (not linear!) */
1307 hut_max_code = 0x0; /* 0==256msec*dtr0/dtr (not linear!) */
1308 }
1309
1310 /* Convert step rate from microseconds to milliseconds and 4 bits */
1311 srt = 16 - DIV_ROUND_UP(DP->srt * scale_dtr / 1000, NOMINAL_DTR);
1312 if (slow_floppy)
1313 srt = srt / 4;
1314
1315 SUPBOUND(srt, 0xf);
1316 INFBOUND(srt, 0);
1317
1318 hlt = DIV_ROUND_UP(DP->hlt * scale_dtr / 2, NOMINAL_DTR);
1319 if (hlt < 0x01)
1320 hlt = 0x01;
1321 else if (hlt > 0x7f)
1322 hlt = hlt_max_code;
1323
1324 hut = DIV_ROUND_UP(DP->hut * scale_dtr / 16, NOMINAL_DTR);
1325 if (hut < 0x1)
1326 hut = 0x1;
1327 else if (hut > 0xf)
1328 hut = hut_max_code;
1329
1330 spec1 = (srt << 4) | hut;
1331 spec2 = (hlt << 1) | (use_virtual_dma & 1);
1332
1333 /* If these parameters did not change, just return with success */
1334 if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
1335 /* Go ahead and set spec1 and spec2 */
1336 output_byte(FD_SPECIFY);
1337 output_byte(FDCS->spec1 = spec1);
1338 output_byte(FDCS->spec2 = spec2);
1339 }
1340} /* fdc_specify */
1341
1342/* Set the FDC's data transfer rate on behalf of the specified drive.
1343 * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
1344 * of the specify command (i.e. using the fdc_specify function).
1345 */
1346static int fdc_dtr(void)
1347{
1348 /* If data rate not already set to desired value, set it. */
1349 if ((raw_cmd->rate & 3) == FDCS->dtr)
1350 return 0;
1351
1352 /* Set dtr */
1353 fd_outb(raw_cmd->rate & 3, FD_DCR);
1354
1355 /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1356 * need a stabilization period of several milliseconds to be
1357 * enforced after data rate changes before R/W operations.
1358 * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
1359 */
1360 FDCS->dtr = raw_cmd->rate & 3;
1361 return fd_wait_for_completion(jiffies + 2UL * HZ / 100, floppy_ready);
1362} /* fdc_dtr */
1363
1364static void tell_sector(void)
1365{
1366 pr_cont(": track %d, head %d, sector %d, size %d",
1367 R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
1368} /* tell_sector */
1369
1370static void print_errors(void)
1371{
1372 DPRINT("");
1373 if (ST0 & ST0_ECE) {
1374 pr_cont("Recalibrate failed!");
1375 } else if (ST2 & ST2_CRC) {
1376 pr_cont("data CRC error");
1377 tell_sector();
1378 } else if (ST1 & ST1_CRC) {
1379 pr_cont("CRC error");
1380 tell_sector();
1381 } else if ((ST1 & (ST1_MAM | ST1_ND)) ||
1382 (ST2 & ST2_MAM)) {
1383 if (!probing) {
1384 pr_cont("sector not found");
1385 tell_sector();
1386 } else
1387 pr_cont("probe failed...");
1388 } else if (ST2 & ST2_WC) { /* seek error */
1389 pr_cont("wrong cylinder");
1390 } else if (ST2 & ST2_BC) { /* cylinder marked as bad */
1391 pr_cont("bad cylinder");
1392 } else {
1393 pr_cont("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
1394 ST0, ST1, ST2);
1395 tell_sector();
1396 }
1397 pr_cont("\n");
1398}
1399
1400/*
1401 * OK, this error interpreting routine is called after a
1402 * DMA read/write has succeeded
1403 * or failed, so we check the results, and copy any buffers.
1404 * hhb: Added better error reporting.
1405 * ak: Made this into a separate routine.
1406 */
1407static int interpret_errors(void)
1408{
1409 char bad;
1410
1411 if (inr != 7) {
1412 DPRINT("-- FDC reply error\n");
1413 FDCS->reset = 1;
1414 return 1;
1415 }
1416
1417 /* check IC to find cause of interrupt */
1418 switch (ST0 & ST0_INTR) {
1419 case 0x40: /* error occurred during command execution */
1420 if (ST1 & ST1_EOC)
1421 return 0; /* occurs with pseudo-DMA */
1422 bad = 1;
1423 if (ST1 & ST1_WP) {
1424 DPRINT("Drive is write protected\n");
1425 clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
1426 cont->done(0);
1427 bad = 2;
1428 } else if (ST1 & ST1_ND) {
1429 set_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
1430 } else if (ST1 & ST1_OR) {
1431 if (DP->flags & FTD_MSG)
1432 DPRINT("Over/Underrun - retrying\n");
1433 bad = 0;
1434 } else if (*errors >= DP->max_errors.reporting) {
1435 print_errors();
1436 }
1437 if (ST2 & ST2_WC || ST2 & ST2_BC)
1438 /* wrong cylinder => recal */
1439 DRS->track = NEED_2_RECAL;
1440 return bad;
1441 case 0x80: /* invalid command given */
1442 DPRINT("Invalid FDC command given!\n");
1443 cont->done(0);
1444 return 2;
1445 case 0xc0:
1446 DPRINT("Abnormal termination caused by polling\n");
1447 cont->error();
1448 return 2;
1449 default: /* (0) Normal command termination */
1450 return 0;
1451 }
1452}
1453
1454/*
1455 * This routine is called when everything should be correctly set up
1456 * for the transfer (i.e. floppy motor is on, the correct floppy is
1457 * selected, and the head is sitting on the right track).
1458 */
1459static void setup_rw_floppy(void)
1460{
1461 int i;
1462 int r;
1463 int flags;
1464 unsigned long ready_date;
1465 void (*function)(void);
1466
1467 flags = raw_cmd->flags;
1468 if (flags & (FD_RAW_READ | FD_RAW_WRITE))
1469 flags |= FD_RAW_INTR;
1470
1471 if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
1472 ready_date = DRS->spinup_date + DP->spinup;
1473 /* If spinup will take a long time, rerun scandrives
1474 * again just before spinup completion. Beware that
1475 * after scandrives, we must again wait for selection.
1476 */
1477 if (time_after(ready_date, jiffies + DP->select_delay)) {
1478 ready_date -= DP->select_delay;
1479 function = floppy_start;
1480 } else
1481 function = setup_rw_floppy;
1482
1483 /* wait until the floppy is spinning fast enough */
1484 if (fd_wait_for_completion(ready_date, function))
1485 return;
1486 }
1487 if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
1488 setup_DMA();
1489
1490 if (flags & FD_RAW_INTR)
1491 do_floppy = main_command_interrupt;
1492
1493 r = 0;
1494 for (i = 0; i < raw_cmd->cmd_count; i++)
1495 r |= output_byte(raw_cmd->cmd[i]);
1496
1497 debugt(__func__, "rw_command");
1498
1499 if (r) {
1500 cont->error();
1501 reset_fdc();
1502 return;
1503 }
1504
1505 if (!(flags & FD_RAW_INTR)) {
1506 inr = result();
1507 cont->interrupt();
1508 } else if (flags & FD_RAW_NEED_DISK)
1509 fd_watchdog();
1510}
1511
1512static int blind_seek;
1513
1514/*
1515 * This is the routine called after every seek (or recalibrate) interrupt
1516 * from the floppy controller.
1517 */
1518static void seek_interrupt(void)
1519{
1520 debugt(__func__, "");
1521 if (inr != 2 || (ST0 & 0xF8) != 0x20) {
1522 DPRINT("seek failed\n");
1523 DRS->track = NEED_2_RECAL;
1524 cont->error();
1525 cont->redo();
1526 return;
1527 }
1528 if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
1529 debug_dcl(DP->flags,
1530 "clearing NEWCHANGE flag because of effective seek\n");
1531 debug_dcl(DP->flags, "jiffies=%lu\n", jiffies);
1532 clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
1533 /* effective seek */
1534 DRS->select_date = jiffies;
1535 }
1536 DRS->track = ST1;
1537 floppy_ready();
1538}
1539
1540static void check_wp(void)
1541{
1542 if (test_bit(FD_VERIFY_BIT, &DRS->flags)) {
1543 /* check write protection */
1544 output_byte(FD_GETSTATUS);
1545 output_byte(UNIT(current_drive));
1546 if (result() != 1) {
1547 FDCS->reset = 1;
1548 return;
1549 }
1550 clear_bit(FD_VERIFY_BIT, &DRS->flags);
1551 clear_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
1552 debug_dcl(DP->flags,
1553 "checking whether disk is write protected\n");
1554 debug_dcl(DP->flags, "wp=%x\n", ST3 & 0x40);
1555 if (!(ST3 & 0x40))
1556 set_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
1557 else
1558 clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
1559 }
1560}
1561
1562static void seek_floppy(void)
1563{
1564 int track;
1565
1566 blind_seek = 0;
1567
1568 debug_dcl(DP->flags, "calling disk change from %s\n", __func__);
1569
1570 if (!test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
1571 disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1572 /* the media changed flag should be cleared after the seek.
1573 * If it isn't, this means that there is really no disk in
1574 * the drive.
1575 */
1576 set_bit(FD_DISK_CHANGED_BIT, &DRS->flags);
1577 cont->done(0);
1578 cont->redo();
1579 return;
1580 }
1581 if (DRS->track <= NEED_1_RECAL) {
1582 recalibrate_floppy();
1583 return;
1584 } else if (test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
1585 (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1586 (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
1587 /* we seek to clear the media-changed condition. Does anybody
1588 * know a more elegant way, which works on all drives? */
1589 if (raw_cmd->track)
1590 track = raw_cmd->track - 1;
1591 else {
1592 if (DP->flags & FD_SILENT_DCL_CLEAR) {
1593 set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
1594 blind_seek = 1;
1595 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1596 }
1597 track = 1;
1598 }
1599 } else {
1600 check_wp();
1601 if (raw_cmd->track != DRS->track &&
1602 (raw_cmd->flags & FD_RAW_NEED_SEEK))
1603 track = raw_cmd->track;
1604 else {
1605 setup_rw_floppy();
1606 return;
1607 }
1608 }
1609
1610 do_floppy = seek_interrupt;
1611 output_byte(FD_SEEK);
1612 output_byte(UNIT(current_drive));
1613 if (output_byte(track) < 0) {
1614 reset_fdc();
1615 return;
1616 }
1617 debugt(__func__, "");
1618}
1619
1620static void recal_interrupt(void)
1621{
1622 debugt(__func__, "");
1623 if (inr != 2)
1624 FDCS->reset = 1;
1625 else if (ST0 & ST0_ECE) {
1626 switch (DRS->track) {
1627 case NEED_1_RECAL:
1628 debugt(__func__, "need 1 recal");
1629 /* after a second recalibrate, we still haven't
1630 * reached track 0. Probably no drive. Raise an
1631 * error, as failing immediately might upset
1632 * computers possessed by the Devil :-) */
1633 cont->error();
1634 cont->redo();
1635 return;
1636 case NEED_2_RECAL:
1637 debugt(__func__, "need 2 recal");
1638 /* If we already did a recalibrate,
1639 * and we are not at track 0, this
1640 * means we have moved. (The only way
1641 * not to move at recalibration is to
1642 * be already at track 0.) Clear the
1643 * new change flag */
1644 debug_dcl(DP->flags,
1645 "clearing NEWCHANGE flag because of second recalibrate\n");
1646
1647 clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
1648 DRS->select_date = jiffies;
1649 /* fall through */
1650 default:
1651 debugt(__func__, "default");
1652 /* Recalibrate moves the head by at
1653 * most 80 steps. If after one
1654 * recalibrate we don't have reached
1655 * track 0, this might mean that we
1656 * started beyond track 80. Try
1657 * again. */
1658 DRS->track = NEED_1_RECAL;
1659 break;
1660 }
1661 } else
1662 DRS->track = ST1;
1663 floppy_ready();
1664}
1665
1666static void print_result(char *message, int inr)
1667{
1668 int i;
1669
1670 DPRINT("%s ", message);
1671 if (inr >= 0)
1672 for (i = 0; i < inr; i++)
1673 pr_cont("repl[%d]=%x ", i, reply_buffer[i]);
1674 pr_cont("\n");
1675}
1676
1677/* interrupt handler. Note that this can be called externally on the Sparc */
1678irqreturn_t floppy_interrupt(int irq, void *dev_id)
1679{
1680 int do_print;
1681 unsigned long f;
1682 void (*handler)(void) = do_floppy;
1683
1684 lasthandler = handler;
1685 interruptjiffies = jiffies;
1686
1687 f = claim_dma_lock();
1688 fd_disable_dma();
1689 release_dma_lock(f);
1690
1691 do_floppy = NULL;
1692 if (fdc >= N_FDC || FDCS->address == -1) {
1693 /* we don't even know which FDC is the culprit */
1694 pr_info("DOR0=%x\n", fdc_state[0].dor);
1695 pr_info("floppy interrupt on bizarre fdc %d\n", fdc);
1696 pr_info("handler=%pf\n", handler);
1697 is_alive(__func__, "bizarre fdc");
1698 return IRQ_NONE;
1699 }
1700
1701 FDCS->reset = 0;
1702 /* We have to clear the reset flag here, because apparently on boxes
1703 * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
1704 * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
1705 * emission of the SENSEI's.
1706 * It is OK to emit floppy commands because we are in an interrupt
1707 * handler here, and thus we have to fear no interference of other
1708 * activity.
1709 */
1710
1711 do_print = !handler && print_unex && initialized;
1712
1713 inr = result();
1714 if (do_print)
1715 print_result("unexpected interrupt", inr);
1716 if (inr == 0) {
1717 int max_sensei = 4;
1718 do {
1719 output_byte(FD_SENSEI);
1720 inr = result();
1721 if (do_print)
1722 print_result("sensei", inr);
1723 max_sensei--;
1724 } while ((ST0 & 0x83) != UNIT(current_drive) &&
1725 inr == 2 && max_sensei);
1726 }
1727 if (!handler) {
1728 FDCS->reset = 1;
1729 return IRQ_NONE;
1730 }
1731 schedule_bh(handler);
1732 is_alive(__func__, "normal interrupt end");
1733
1734 /* FIXME! Was it really for us? */
1735 return IRQ_HANDLED;
1736}
1737
1738static void recalibrate_floppy(void)
1739{
1740 debugt(__func__, "");
1741 do_floppy = recal_interrupt;
1742 output_byte(FD_RECALIBRATE);
1743 if (output_byte(UNIT(current_drive)) < 0)
1744 reset_fdc();
1745}
1746
1747/*
1748 * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1749 */
1750static void reset_interrupt(void)
1751{
1752 debugt(__func__, "");
1753 result(); /* get the status ready for set_fdc */
1754 if (FDCS->reset) {
1755 pr_info("reset set in interrupt, calling %pf\n", cont->error);
1756 cont->error(); /* a reset just after a reset. BAD! */
1757 }
1758 cont->redo();
1759}
1760
1761/*
1762 * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1763 * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1764 */
1765static void reset_fdc(void)
1766{
1767 unsigned long flags;
1768
1769 do_floppy = reset_interrupt;
1770 FDCS->reset = 0;
1771 reset_fdc_info(0);
1772
1773 /* Pseudo-DMA may intercept 'reset finished' interrupt. */
1774 /* Irrelevant for systems with true DMA (i386). */
1775
1776 flags = claim_dma_lock();
1777 fd_disable_dma();
1778 release_dma_lock(flags);
1779
1780 if (FDCS->version >= FDC_82072A)
1781 fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
1782 else {
1783 fd_outb(FDCS->dor & ~0x04, FD_DOR);
1784 udelay(FD_RESET_DELAY);
1785 fd_outb(FDCS->dor, FD_DOR);
1786 }
1787}
1788
1789static void show_floppy(void)
1790{
1791 int i;
1792
1793 pr_info("\n");
1794 pr_info("floppy driver state\n");
1795 pr_info("-------------------\n");
1796 pr_info("now=%lu last interrupt=%lu diff=%lu last called handler=%pf\n",
1797 jiffies, interruptjiffies, jiffies - interruptjiffies,
1798 lasthandler);
1799
1800 pr_info("timeout_message=%s\n", timeout_message);
1801 pr_info("last output bytes:\n");
1802 for (i = 0; i < OLOGSIZE; i++)
1803 pr_info("%2x %2x %lu\n",
1804 output_log[(i + output_log_pos) % OLOGSIZE].data,
1805 output_log[(i + output_log_pos) % OLOGSIZE].status,
1806 output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1807 pr_info("last result at %lu\n", resultjiffies);
1808 pr_info("last redo_fd_request at %lu\n", lastredo);
1809 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1,
1810 reply_buffer, resultsize, true);
1811
1812 pr_info("status=%x\n", fd_inb(FD_STATUS));
1813 pr_info("fdc_busy=%lu\n", fdc_busy);
1814 if (do_floppy)
1815 pr_info("do_floppy=%pf\n", do_floppy);
1816 if (work_pending(&floppy_work))
1817 pr_info("floppy_work.func=%pf\n", floppy_work.func);
1818 if (delayed_work_pending(&fd_timer))
1819 pr_info("delayed work.function=%p expires=%ld\n",
1820 fd_timer.work.func,
1821 fd_timer.timer.expires - jiffies);
1822 if (delayed_work_pending(&fd_timeout))
1823 pr_info("timer_function=%p expires=%ld\n",
1824 fd_timeout.work.func,
1825 fd_timeout.timer.expires - jiffies);
1826
1827 pr_info("cont=%p\n", cont);
1828 pr_info("current_req=%p\n", current_req);
1829 pr_info("command_status=%d\n", command_status);
1830 pr_info("\n");
1831}
1832
1833static void floppy_shutdown(struct work_struct *arg)
1834{
1835 unsigned long flags;
1836
1837 if (initialized)
1838 show_floppy();
1839 cancel_activity();
1840
1841 flags = claim_dma_lock();
1842 fd_disable_dma();
1843 release_dma_lock(flags);
1844
1845 /* avoid dma going to a random drive after shutdown */
1846
1847 if (initialized)
1848 DPRINT("floppy timeout called\n");
1849 FDCS->reset = 1;
1850 if (cont) {
1851 cont->done(0);
1852 cont->redo(); /* this will recall reset when needed */
1853 } else {
1854 pr_info("no cont in shutdown!\n");
1855 process_fd_request();
1856 }
1857 is_alive(__func__, "");
1858}
1859
1860/* start motor, check media-changed condition and write protection */
1861static int start_motor(void (*function)(void))
1862{
1863 int mask;
1864 int data;
1865
1866 mask = 0xfc;
1867 data = UNIT(current_drive);
1868 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1869 if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
1870 set_debugt();
1871 /* no read since this drive is running */
1872 DRS->first_read_date = 0;
1873 /* note motor start time if motor is not yet running */
1874 DRS->spinup_date = jiffies;
1875 data |= (0x10 << UNIT(current_drive));
1876 }
1877 } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
1878 mask &= ~(0x10 << UNIT(current_drive));
1879
1880 /* starts motor and selects floppy */
1881 del_timer(motor_off_timer + current_drive);
1882 set_dor(fdc, mask, data);
1883
1884 /* wait_for_completion also schedules reset if needed. */
1885 return fd_wait_for_completion(DRS->select_date + DP->select_delay,
1886 function);
1887}
1888
1889static void floppy_ready(void)
1890{
1891 if (FDCS->reset) {
1892 reset_fdc();
1893 return;
1894 }
1895 if (start_motor(floppy_ready))
1896 return;
1897 if (fdc_dtr())
1898 return;
1899
1900 debug_dcl(DP->flags, "calling disk change from floppy_ready\n");
1901 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1902 disk_change(current_drive) && !DP->select_delay)
1903 twaddle(); /* this clears the dcl on certain
1904 * drive/controller combinations */
1905
1906#ifdef fd_chose_dma_mode
1907 if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1908 unsigned long flags = claim_dma_lock();
1909 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1910 release_dma_lock(flags);
1911 }
1912#endif
1913
1914 if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1915 perpendicular_mode();
1916 fdc_specify(); /* must be done here because of hut, hlt ... */
1917 seek_floppy();
1918 } else {
1919 if ((raw_cmd->flags & FD_RAW_READ) ||
1920 (raw_cmd->flags & FD_RAW_WRITE))
1921 fdc_specify();
1922 setup_rw_floppy();
1923 }
1924}
1925
1926static void floppy_start(void)
1927{
1928 reschedule_timeout(current_reqD, "floppy start");
1929
1930 scandrives();
1931 debug_dcl(DP->flags, "setting NEWCHANGE in floppy_start\n");
1932 set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
1933 floppy_ready();
1934}
1935
1936/*
1937 * ========================================================================
1938 * here ends the bottom half. Exported routines are:
1939 * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
1940 * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
1941 * Initialization also uses output_byte, result, set_dor, floppy_interrupt
1942 * and set_dor.
1943 * ========================================================================
1944 */
1945/*
1946 * General purpose continuations.
1947 * ==============================
1948 */
1949
1950static void do_wakeup(void)
1951{
1952 reschedule_timeout(MAXTIMEOUT, "do wakeup");
1953 cont = NULL;
1954 command_status += 2;
1955 wake_up(&command_done);
1956}
1957
1958static const struct cont_t wakeup_cont = {
1959 .interrupt = empty,
1960 .redo = do_wakeup,
1961 .error = empty,
1962 .done = (done_f)empty
1963};
1964
1965static const struct cont_t intr_cont = {
1966 .interrupt = empty,
1967 .redo = process_fd_request,
1968 .error = empty,
1969 .done = (done_f)empty
1970};
1971
1972static int wait_til_done(void (*handler)(void), bool interruptible)
1973{
1974 int ret;
1975
1976 schedule_bh(handler);
1977
1978 if (interruptible)
1979 wait_event_interruptible(command_done, command_status >= 2);
1980 else
1981 wait_event(command_done, command_status >= 2);
1982
1983 if (command_status < 2) {
1984 cancel_activity();
1985 cont = &intr_cont;
1986 reset_fdc();
1987 return -EINTR;
1988 }
1989
1990 if (FDCS->reset)
1991 command_status = FD_COMMAND_ERROR;
1992 if (command_status == FD_COMMAND_OKAY)
1993 ret = 0;
1994 else
1995 ret = -EIO;
1996 command_status = FD_COMMAND_NONE;
1997 return ret;
1998}
1999
2000static void generic_done(int result)
2001{
2002 command_status = result;
2003 cont = &wakeup_cont;
2004}
2005
2006static void generic_success(void)
2007{
2008 cont->done(1);
2009}
2010
2011static void generic_failure(void)
2012{
2013 cont->done(0);
2014}
2015
2016static void success_and_wakeup(void)
2017{
2018 generic_success();
2019 cont->redo();
2020}
2021
2022/*
2023 * formatting and rw support.
2024 * ==========================
2025 */
2026
2027static int next_valid_format(void)
2028{
2029 int probed_format;
2030
2031 probed_format = DRS->probed_format;
2032 while (1) {
2033 if (probed_format >= 8 || !DP->autodetect[probed_format]) {
2034 DRS->probed_format = 0;
2035 return 1;
2036 }
2037 if (floppy_type[DP->autodetect[probed_format]].sect) {
2038 DRS->probed_format = probed_format;
2039 return 0;
2040 }
2041 probed_format++;
2042 }
2043}
2044
2045static void bad_flp_intr(void)
2046{
2047 int err_count;
2048
2049 if (probing) {
2050 DRS->probed_format++;
2051 if (!next_valid_format())
2052 return;
2053 }
2054 err_count = ++(*errors);
2055 INFBOUND(DRWE->badness, err_count);
2056 if (err_count > DP->max_errors.abort)
2057 cont->done(0);
2058 if (err_count > DP->max_errors.reset)
2059 FDCS->reset = 1;
2060 else if (err_count > DP->max_errors.recal)
2061 DRS->track = NEED_2_RECAL;
2062}
2063
2064static void set_floppy(int drive)
2065{
2066 int type = ITYPE(UDRS->fd_device);
2067
2068 if (type)
2069 _floppy = floppy_type + type;
2070 else
2071 _floppy = current_type[drive];
2072}
2073
2074/*
2075 * formatting support.
2076 * ===================
2077 */
2078static void format_interrupt(void)
2079{
2080 switch (interpret_errors()) {
2081 case 1:
2082 cont->error();
2083 case 2:
2084 break;
2085 case 0:
2086 cont->done(1);
2087 }
2088 cont->redo();
2089}
2090
2091#define FM_MODE(x, y) ((y) & ~(((x)->rate & 0x80) >> 1))
2092#define CT(x) ((x) | 0xc0)
2093
2094static void setup_format_params(int track)
2095{
2096 int n;
2097 int il;
2098 int count;
2099 int head_shift;
2100 int track_shift;
2101 struct fparm {
2102 unsigned char track, head, sect, size;
2103 } *here = (struct fparm *)floppy_track_buffer;
2104
2105 raw_cmd = &default_raw_cmd;
2106 raw_cmd->track = track;
2107
2108 raw_cmd->flags = (FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2109 FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK);
2110 raw_cmd->rate = _floppy->rate & 0x43;
2111 raw_cmd->cmd_count = NR_F;
2112 COMMAND = FM_MODE(_floppy, FD_FORMAT);
2113 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2114 F_SIZECODE = FD_SIZECODE(_floppy);
2115 F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2116 F_GAP = _floppy->fmt_gap;
2117 F_FILL = FD_FILL_BYTE;
2118
2119 raw_cmd->kernel_data = floppy_track_buffer;
2120 raw_cmd->length = 4 * F_SECT_PER_TRACK;
2121
2122 /* allow for about 30ms for data transport per track */
2123 head_shift = (F_SECT_PER_TRACK + 5) / 6;
2124
2125 /* a ``cylinder'' is two tracks plus a little stepping time */
2126 track_shift = 2 * head_shift + 3;
2127
2128 /* position of logical sector 1 on this track */
2129 n = (track_shift * format_req.track + head_shift * format_req.head)
2130 % F_SECT_PER_TRACK;
2131
2132 /* determine interleave */
2133 il = 1;
2134 if (_floppy->fmt_gap < 0x22)
2135 il++;
2136
2137 /* initialize field */
2138 for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2139 here[count].track = format_req.track;
2140 here[count].head = format_req.head;
2141 here[count].sect = 0;
2142 here[count].size = F_SIZECODE;
2143 }
2144 /* place logical sectors */
2145 for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2146 here[n].sect = count;
2147 n = (n + il) % F_SECT_PER_TRACK;
2148 if (here[n].sect) { /* sector busy, find next free sector */
2149 ++n;
2150 if (n >= F_SECT_PER_TRACK) {
2151 n -= F_SECT_PER_TRACK;
2152 while (here[n].sect)
2153 ++n;
2154 }
2155 }
2156 }
2157 if (_floppy->stretch & FD_SECTBASEMASK) {
2158 for (count = 0; count < F_SECT_PER_TRACK; count++)
2159 here[count].sect += FD_SECTBASE(_floppy) - 1;
2160 }
2161}
2162
2163static void redo_format(void)
2164{
2165 buffer_track = -1;
2166 setup_format_params(format_req.track << STRETCH(_floppy));
2167 floppy_start();
2168 debugt(__func__, "queue format request");
2169}
2170
2171static const struct cont_t format_cont = {
2172 .interrupt = format_interrupt,
2173 .redo = redo_format,
2174 .error = bad_flp_intr,
2175 .done = generic_done
2176};
2177
2178static int do_format(int drive, struct format_descr *tmp_format_req)
2179{
2180 int ret;
2181
2182 if (lock_fdc(drive))
2183 return -EINTR;
2184
2185 set_floppy(drive);
2186 if (!_floppy ||
2187 _floppy->track > DP->tracks ||
2188 tmp_format_req->track >= _floppy->track ||
2189 tmp_format_req->head >= _floppy->head ||
2190 (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2191 !_floppy->fmt_gap) {
2192 process_fd_request();
2193 return -EINVAL;
2194 }
2195 format_req = *tmp_format_req;
2196 format_errors = 0;
2197 cont = &format_cont;
2198 errors = &format_errors;
2199 ret = wait_til_done(redo_format, true);
2200 if (ret == -EINTR)
2201 return -EINTR;
2202 process_fd_request();
2203 return ret;
2204}
2205
2206/*
2207 * Buffer read/write and support
2208 * =============================
2209 */
2210
2211static void floppy_end_request(struct request *req, blk_status_t error)
2212{
2213 unsigned int nr_sectors = current_count_sectors;
2214 unsigned int drive = (unsigned long)req->rq_disk->private_data;
2215
2216 /* current_count_sectors can be zero if transfer failed */
2217 if (error)
2218 nr_sectors = blk_rq_cur_sectors(req);
2219 if (blk_update_request(req, error, nr_sectors << 9))
2220 return;
2221 __blk_mq_end_request(req, error);
2222
2223 /* We're done with the request */
2224 floppy_off(drive);
2225 current_req = NULL;
2226}
2227
2228/* new request_done. Can handle physical sectors which are smaller than a
2229 * logical buffer */
2230static void request_done(int uptodate)
2231{
2232 struct request *req = current_req;
2233 int block;
2234 char msg[sizeof("request done ") + sizeof(int) * 3];
2235
2236 probing = 0;
2237 snprintf(msg, sizeof(msg), "request done %d", uptodate);
2238 reschedule_timeout(MAXTIMEOUT, msg);
2239
2240 if (!req) {
2241 pr_info("floppy.c: no request in request_done\n");
2242 return;
2243 }
2244
2245 if (uptodate) {
2246 /* maintain values for invalidation on geometry
2247 * change */
2248 block = current_count_sectors + blk_rq_pos(req);
2249 INFBOUND(DRS->maxblock, block);
2250 if (block > _floppy->sect)
2251 DRS->maxtrack = 1;
2252
2253 floppy_end_request(req, 0);
2254 } else {
2255 if (rq_data_dir(req) == WRITE) {
2256 /* record write error information */
2257 DRWE->write_errors++;
2258 if (DRWE->write_errors == 1) {
2259 DRWE->first_error_sector = blk_rq_pos(req);
2260 DRWE->first_error_generation = DRS->generation;
2261 }
2262 DRWE->last_error_sector = blk_rq_pos(req);
2263 DRWE->last_error_generation = DRS->generation;
2264 }
2265 floppy_end_request(req, BLK_STS_IOERR);
2266 }
2267}
2268
2269/* Interrupt handler evaluating the result of the r/w operation */
2270static void rw_interrupt(void)
2271{
2272 int eoc;
2273 int ssize;
2274 int heads;
2275 int nr_sectors;
2276
2277 if (R_HEAD >= 2) {
2278 /* some Toshiba floppy controllers occasionnally seem to
2279 * return bogus interrupts after read/write operations, which
2280 * can be recognized by a bad head number (>= 2) */
2281 return;
2282 }
2283
2284 if (!DRS->first_read_date)
2285 DRS->first_read_date = jiffies;
2286
2287 nr_sectors = 0;
2288 ssize = DIV_ROUND_UP(1 << SIZECODE, 4);
2289
2290 if (ST1 & ST1_EOC)
2291 eoc = 1;
2292 else
2293 eoc = 0;
2294
2295 if (COMMAND & 0x80)
2296 heads = 2;
2297 else
2298 heads = 1;
2299
2300 nr_sectors = (((R_TRACK - TRACK) * heads +
2301 R_HEAD - HEAD) * SECT_PER_TRACK +
2302 R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2303
2304 if (nr_sectors / ssize >
2305 DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {
2306 DPRINT("long rw: %x instead of %lx\n",
2307 nr_sectors, current_count_sectors);
2308 pr_info("rs=%d s=%d\n", R_SECTOR, SECTOR);
2309 pr_info("rh=%d h=%d\n", R_HEAD, HEAD);
2310 pr_info("rt=%d t=%d\n", R_TRACK, TRACK);
2311 pr_info("heads=%d eoc=%d\n", heads, eoc);
2312 pr_info("spt=%d st=%d ss=%d\n",
2313 SECT_PER_TRACK, fsector_t, ssize);
2314 pr_info("in_sector_offset=%d\n", in_sector_offset);
2315 }
2316
2317 nr_sectors -= in_sector_offset;
2318 INFBOUND(nr_sectors, 0);
2319 SUPBOUND(current_count_sectors, nr_sectors);
2320
2321 switch (interpret_errors()) {
2322 case 2:
2323 cont->redo();
2324 return;
2325 case 1:
2326 if (!current_count_sectors) {
2327 cont->error();
2328 cont->redo();
2329 return;
2330 }
2331 break;
2332 case 0:
2333 if (!current_count_sectors) {
2334 cont->redo();
2335 return;
2336 }
2337 current_type[current_drive] = _floppy;
2338 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2339 break;
2340 }
2341
2342 if (probing) {
2343 if (DP->flags & FTD_MSG)
2344 DPRINT("Auto-detected floppy type %s in fd%d\n",
2345 _floppy->name, current_drive);
2346 current_type[current_drive] = _floppy;
2347 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2348 probing = 0;
2349 }
2350
2351 if (CT(COMMAND) != FD_READ ||
2352 raw_cmd->kernel_data == bio_data(current_req->bio)) {
2353 /* transfer directly from buffer */
2354 cont->done(1);
2355 } else if (CT(COMMAND) == FD_READ) {
2356 buffer_track = raw_cmd->track;
2357 buffer_drive = current_drive;
2358 INFBOUND(buffer_max, nr_sectors + fsector_t);
2359 }
2360 cont->redo();
2361}
2362
2363/* Compute maximal contiguous buffer size. */
2364static int buffer_chain_size(void)
2365{
2366 struct bio_vec bv;
2367 int size;
2368 struct req_iterator iter;
2369 char *base;
2370
2371 base = bio_data(current_req->bio);
2372 size = 0;
2373
2374 rq_for_each_segment(bv, current_req, iter) {
2375 if (page_address(bv.bv_page) + bv.bv_offset != base + size)
2376 break;
2377
2378 size += bv.bv_len;
2379 }
2380
2381 return size >> 9;
2382}
2383
2384/* Compute the maximal transfer size */
2385static int transfer_size(int ssize, int max_sector, int max_size)
2386{
2387 SUPBOUND(max_sector, fsector_t + max_size);
2388
2389 /* alignment */
2390 max_sector -= (max_sector % _floppy->sect) % ssize;
2391
2392 /* transfer size, beginning not aligned */
2393 current_count_sectors = max_sector - fsector_t;
2394
2395 return max_sector;
2396}
2397
2398/*
2399 * Move data from/to the track buffer to/from the buffer cache.
2400 */
2401static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2402{
2403 int remaining; /* number of transferred 512-byte sectors */
2404 struct bio_vec bv;
2405 char *buffer;
2406 char *dma_buffer;
2407 int size;
2408 struct req_iterator iter;
2409
2410 max_sector = transfer_size(ssize,
2411 min(max_sector, max_sector_2),
2412 blk_rq_sectors(current_req));
2413
2414 if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2415 buffer_max > fsector_t + blk_rq_sectors(current_req))
2416 current_count_sectors = min_t(int, buffer_max - fsector_t,
2417 blk_rq_sectors(current_req));
2418
2419 remaining = current_count_sectors << 9;
2420 if (remaining > blk_rq_bytes(current_req) && CT(COMMAND) == FD_WRITE) {
2421 DPRINT("in copy buffer\n");
2422 pr_info("current_count_sectors=%ld\n", current_count_sectors);
2423 pr_info("remaining=%d\n", remaining >> 9);
2424 pr_info("current_req->nr_sectors=%u\n",
2425 blk_rq_sectors(current_req));
2426 pr_info("current_req->current_nr_sectors=%u\n",
2427 blk_rq_cur_sectors(current_req));
2428 pr_info("max_sector=%d\n", max_sector);
2429 pr_info("ssize=%d\n", ssize);
2430 }
2431
2432 buffer_max = max(max_sector, buffer_max);
2433
2434 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2435
2436 size = blk_rq_cur_bytes(current_req);
2437
2438 rq_for_each_segment(bv, current_req, iter) {
2439 if (!remaining)
2440 break;
2441
2442 size = bv.bv_len;
2443 SUPBOUND(size, remaining);
2444
2445 buffer = page_address(bv.bv_page) + bv.bv_offset;
2446 if (dma_buffer + size >
2447 floppy_track_buffer + (max_buffer_sectors << 10) ||
2448 dma_buffer < floppy_track_buffer) {
2449 DPRINT("buffer overrun in copy buffer %d\n",
2450 (int)((floppy_track_buffer - dma_buffer) >> 9));
2451 pr_info("fsector_t=%d buffer_min=%d\n",
2452 fsector_t, buffer_min);
2453 pr_info("current_count_sectors=%ld\n",
2454 current_count_sectors);
2455 if (CT(COMMAND) == FD_READ)
2456 pr_info("read\n");
2457 if (CT(COMMAND) == FD_WRITE)
2458 pr_info("write\n");
2459 break;
2460 }
2461 if (((unsigned long)buffer) % 512)
2462 DPRINT("%p buffer not aligned\n", buffer);
2463
2464 if (CT(COMMAND) == FD_READ)
2465 memcpy(buffer, dma_buffer, size);
2466 else
2467 memcpy(dma_buffer, buffer, size);
2468
2469 remaining -= size;
2470 dma_buffer += size;
2471 }
2472 if (remaining) {
2473 if (remaining > 0)
2474 max_sector -= remaining >> 9;
2475 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2476 }
2477}
2478
2479/* work around a bug in pseudo DMA
2480 * (on some FDCs) pseudo DMA does not stop when the CPU stops
2481 * sending data. Hence we need a different way to signal the
2482 * transfer length: We use SECT_PER_TRACK. Unfortunately, this
2483 * does not work with MT, hence we can only transfer one head at
2484 * a time
2485 */
2486static void virtualdmabug_workaround(void)
2487{
2488 int hard_sectors;
2489 int end_sector;
2490
2491 if (CT(COMMAND) == FD_WRITE) {
2492 COMMAND &= ~0x80; /* switch off multiple track mode */
2493
2494 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2495 end_sector = SECTOR + hard_sectors - 1;
2496 if (end_sector > SECT_PER_TRACK) {
2497 pr_info("too many sectors %d > %d\n",
2498 end_sector, SECT_PER_TRACK);
2499 return;
2500 }
2501 SECT_PER_TRACK = end_sector;
2502 /* make sure SECT_PER_TRACK
2503 * points to end of transfer */
2504 }
2505}
2506
2507/*
2508 * Formulate a read/write request.
2509 * this routine decides where to load the data (directly to buffer, or to
2510 * tmp floppy area), how much data to load (the size of the buffer, the whole
2511 * track, or a single sector)
2512 * All floppy_track_buffer handling goes in here. If we ever add track buffer
2513 * allocation on the fly, it should be done here. No other part should need
2514 * modification.
2515 */
2516
2517static int make_raw_rw_request(void)
2518{
2519 int aligned_sector_t;
2520 int max_sector;
2521 int max_size;
2522 int tracksize;
2523 int ssize;
2524
2525 if (WARN(max_buffer_sectors == 0, "VFS: Block I/O scheduled on unopened device\n"))
2526 return 0;
2527
2528 set_fdc((long)current_req->rq_disk->private_data);
2529
2530 raw_cmd = &default_raw_cmd;
2531 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2532 raw_cmd->cmd_count = NR_RW;
2533 if (rq_data_dir(current_req) == READ) {
2534 raw_cmd->flags |= FD_RAW_READ;
2535 COMMAND = FM_MODE(_floppy, FD_READ);
2536 } else if (rq_data_dir(current_req) == WRITE) {
2537 raw_cmd->flags |= FD_RAW_WRITE;
2538 COMMAND = FM_MODE(_floppy, FD_WRITE);
2539 } else {
2540 DPRINT("%s: unknown command\n", __func__);
2541 return 0;
2542 }
2543
2544 max_sector = _floppy->sect * _floppy->head;
2545
2546 TRACK = (int)blk_rq_pos(current_req) / max_sector;
2547 fsector_t = (int)blk_rq_pos(current_req) % max_sector;
2548 if (_floppy->track && TRACK >= _floppy->track) {
2549 if (blk_rq_cur_sectors(current_req) & 1) {
2550 current_count_sectors = 1;
2551 return 1;
2552 } else
2553 return 0;
2554 }
2555 HEAD = fsector_t / _floppy->sect;
2556
2557 if (((_floppy->stretch & (FD_SWAPSIDES | FD_SECTBASEMASK)) ||
2558 test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags)) &&
2559 fsector_t < _floppy->sect)
2560 max_sector = _floppy->sect;
2561
2562 /* 2M disks have phantom sectors on the first track */
2563 if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2564 max_sector = 2 * _floppy->sect / 3;
2565 if (fsector_t >= max_sector) {
2566 current_count_sectors =
2567 min_t(int, _floppy->sect - fsector_t,
2568 blk_rq_sectors(current_req));
2569 return 1;
2570 }
2571 SIZECODE = 2;
2572 } else
2573 SIZECODE = FD_SIZECODE(_floppy);
2574 raw_cmd->rate = _floppy->rate & 0x43;
2575 if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2576 raw_cmd->rate = 1;
2577
2578 if (SIZECODE)
2579 SIZECODE2 = 0xff;
2580 else
2581 SIZECODE2 = 0x80;
2582 raw_cmd->track = TRACK << STRETCH(_floppy);
2583 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2584 GAP = _floppy->gap;
2585 ssize = DIV_ROUND_UP(1 << SIZECODE, 4);
2586 SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2587 SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
2588 FD_SECTBASE(_floppy);
2589
2590 /* tracksize describes the size which can be filled up with sectors
2591 * of size ssize.
2592 */
2593 tracksize = _floppy->sect - _floppy->sect % ssize;
2594 if (tracksize < _floppy->sect) {
2595 SECT_PER_TRACK++;
2596 if (tracksize <= fsector_t % _floppy->sect)
2597 SECTOR--;
2598
2599 /* if we are beyond tracksize, fill up using smaller sectors */
2600 while (tracksize <= fsector_t % _floppy->sect) {
2601 while (tracksize + ssize > _floppy->sect) {
2602 SIZECODE--;
2603 ssize >>= 1;
2604 }
2605 SECTOR++;
2606 SECT_PER_TRACK++;
2607 tracksize += ssize;
2608 }
2609 max_sector = HEAD * _floppy->sect + tracksize;
2610 } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2611 max_sector = _floppy->sect;
2612 } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2613 /* for virtual DMA bug workaround */
2614 max_sector = _floppy->sect;
2615 }
2616
2617 in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2618 aligned_sector_t = fsector_t - in_sector_offset;
2619 max_size = blk_rq_sectors(current_req);
2620 if ((raw_cmd->track == buffer_track) &&
2621 (current_drive == buffer_drive) &&
2622 (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2623 /* data already in track buffer */
2624 if (CT(COMMAND) == FD_READ) {
2625 copy_buffer(1, max_sector, buffer_max);
2626 return 1;
2627 }
2628 } else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {
2629 if (CT(COMMAND) == FD_WRITE) {
2630 unsigned int sectors;
2631
2632 sectors = fsector_t + blk_rq_sectors(current_req);
2633 if (sectors > ssize && sectors < ssize + ssize)
2634 max_size = ssize + ssize;
2635 else
2636 max_size = ssize;
2637 }
2638 raw_cmd->flags &= ~FD_RAW_WRITE;
2639 raw_cmd->flags |= FD_RAW_READ;
2640 COMMAND = FM_MODE(_floppy, FD_READ);
2641 } else if ((unsigned long)bio_data(current_req->bio) < MAX_DMA_ADDRESS) {
2642 unsigned long dma_limit;
2643 int direct, indirect;
2644
2645 indirect =
2646 transfer_size(ssize, max_sector,
2647 max_buffer_sectors * 2) - fsector_t;
2648
2649 /*
2650 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2651 * on a 64 bit machine!
2652 */
2653 max_size = buffer_chain_size();
2654 dma_limit = (MAX_DMA_ADDRESS -
2655 ((unsigned long)bio_data(current_req->bio))) >> 9;
2656 if ((unsigned long)max_size > dma_limit)
2657 max_size = dma_limit;
2658 /* 64 kb boundaries */
2659 if (CROSS_64KB(bio_data(current_req->bio), max_size << 9))
2660 max_size = (K_64 -
2661 ((unsigned long)bio_data(current_req->bio)) %
2662 K_64) >> 9;
2663 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2664 /*
2665 * We try to read tracks, but if we get too many errors, we
2666 * go back to reading just one sector at a time.
2667 *
2668 * This means we should be able to read a sector even if there
2669 * are other bad sectors on this track.
2670 */
2671 if (!direct ||
2672 (indirect * 2 > direct * 3 &&
2673 *errors < DP->max_errors.read_track &&
2674 ((!probing ||
2675 (DP->read_track & (1 << DRS->probed_format)))))) {
2676 max_size = blk_rq_sectors(current_req);
2677 } else {
2678 raw_cmd->kernel_data = bio_data(current_req->bio);
2679 raw_cmd->length = current_count_sectors << 9;
2680 if (raw_cmd->length == 0) {
2681 DPRINT("%s: zero dma transfer attempted\n", __func__);
2682 DPRINT("indirect=%d direct=%d fsector_t=%d\n",
2683 indirect, direct, fsector_t);
2684 return 0;
2685 }
2686 virtualdmabug_workaround();
2687 return 2;
2688 }
2689 }
2690
2691 if (CT(COMMAND) == FD_READ)
2692 max_size = max_sector; /* unbounded */
2693
2694 /* claim buffer track if needed */
2695 if (buffer_track != raw_cmd->track || /* bad track */
2696 buffer_drive != current_drive || /* bad drive */
2697 fsector_t > buffer_max ||
2698 fsector_t < buffer_min ||
2699 ((CT(COMMAND) == FD_READ ||
2700 (!in_sector_offset && blk_rq_sectors(current_req) >= ssize)) &&
2701 max_sector > 2 * max_buffer_sectors + buffer_min &&
2702 max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)) {
2703 /* not enough space */
2704 buffer_track = -1;
2705 buffer_drive = current_drive;
2706 buffer_max = buffer_min = aligned_sector_t;
2707 }
2708 raw_cmd->kernel_data = floppy_track_buffer +
2709 ((aligned_sector_t - buffer_min) << 9);
2710
2711 if (CT(COMMAND) == FD_WRITE) {
2712 /* copy write buffer to track buffer.
2713 * if we get here, we know that the write
2714 * is either aligned or the data already in the buffer
2715 * (buffer will be overwritten) */
2716 if (in_sector_offset && buffer_track == -1)
2717 DPRINT("internal error offset !=0 on write\n");
2718 buffer_track = raw_cmd->track;
2719 buffer_drive = current_drive;
2720 copy_buffer(ssize, max_sector,
2721 2 * max_buffer_sectors + buffer_min);
2722 } else
2723 transfer_size(ssize, max_sector,
2724 2 * max_buffer_sectors + buffer_min -
2725 aligned_sector_t);
2726
2727 /* round up current_count_sectors to get dma xfer size */
2728 raw_cmd->length = in_sector_offset + current_count_sectors;
2729 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2730 raw_cmd->length <<= 9;
2731 if ((raw_cmd->length < current_count_sectors << 9) ||
2732 (raw_cmd->kernel_data != bio_data(current_req->bio) &&
2733 CT(COMMAND) == FD_WRITE &&
2734 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2735 aligned_sector_t < buffer_min)) ||
2736 raw_cmd->length % (128 << SIZECODE) ||
2737 raw_cmd->length <= 0 || current_count_sectors <= 0) {
2738 DPRINT("fractionary current count b=%lx s=%lx\n",
2739 raw_cmd->length, current_count_sectors);
2740 if (raw_cmd->kernel_data != bio_data(current_req->bio))
2741 pr_info("addr=%d, length=%ld\n",
2742 (int)((raw_cmd->kernel_data -
2743 floppy_track_buffer) >> 9),
2744 current_count_sectors);
2745 pr_info("st=%d ast=%d mse=%d msi=%d\n",
2746 fsector_t, aligned_sector_t, max_sector, max_size);
2747 pr_info("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2748 pr_info("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2749 COMMAND, SECTOR, HEAD, TRACK);
2750 pr_info("buffer drive=%d\n", buffer_drive);
2751 pr_info("buffer track=%d\n", buffer_track);
2752 pr_info("buffer_min=%d\n", buffer_min);
2753 pr_info("buffer_max=%d\n", buffer_max);
2754 return 0;
2755 }
2756
2757 if (raw_cmd->kernel_data != bio_data(current_req->bio)) {
2758 if (raw_cmd->kernel_data < floppy_track_buffer ||
2759 current_count_sectors < 0 ||
2760 raw_cmd->length < 0 ||
2761 raw_cmd->kernel_data + raw_cmd->length >
2762 floppy_track_buffer + (max_buffer_sectors << 10)) {
2763 DPRINT("buffer overrun in schedule dma\n");
2764 pr_info("fsector_t=%d buffer_min=%d current_count=%ld\n",
2765 fsector_t, buffer_min, raw_cmd->length >> 9);
2766 pr_info("current_count_sectors=%ld\n",
2767 current_count_sectors);
2768 if (CT(COMMAND) == FD_READ)
2769 pr_info("read\n");
2770 if (CT(COMMAND) == FD_WRITE)
2771 pr_info("write\n");
2772 return 0;
2773 }
2774 } else if (raw_cmd->length > blk_rq_bytes(current_req) ||
2775 current_count_sectors > blk_rq_sectors(current_req)) {
2776 DPRINT("buffer overrun in direct transfer\n");
2777 return 0;
2778 } else if (raw_cmd->length < current_count_sectors << 9) {
2779 DPRINT("more sectors than bytes\n");
2780 pr_info("bytes=%ld\n", raw_cmd->length >> 9);
2781 pr_info("sectors=%ld\n", current_count_sectors);
2782 }
2783 if (raw_cmd->length == 0) {
2784 DPRINT("zero dma transfer attempted from make_raw_request\n");
2785 return 0;
2786 }
2787
2788 virtualdmabug_workaround();
2789 return 2;
2790}
2791
2792static int set_next_request(void)
2793{
2794 current_req = list_first_entry_or_null(&floppy_reqs, struct request,
2795 queuelist);
2796 if (current_req) {
2797 current_req->error_count = 0;
2798 list_del_init(&current_req->queuelist);
2799 }
2800 return current_req != NULL;
2801}
2802
2803static void redo_fd_request(void)
2804{
2805 int drive;
2806 int tmp;
2807
2808 lastredo = jiffies;
2809 if (current_drive < N_DRIVE)
2810 floppy_off(current_drive);
2811
2812do_request:
2813 if (!current_req) {
2814 int pending;
2815
2816 spin_lock_irq(&floppy_lock);
2817 pending = set_next_request();
2818 spin_unlock_irq(&floppy_lock);
2819 if (!pending) {
2820 do_floppy = NULL;
2821 unlock_fdc();
2822 return;
2823 }
2824 }
2825 drive = (long)current_req->rq_disk->private_data;
2826 set_fdc(drive);
2827 reschedule_timeout(current_reqD, "redo fd request");
2828
2829 set_floppy(drive);
2830 raw_cmd = &default_raw_cmd;
2831 raw_cmd->flags = 0;
2832 if (start_motor(redo_fd_request))
2833 return;
2834
2835 disk_change(current_drive);
2836 if (test_bit(current_drive, &fake_change) ||
2837 test_bit(FD_DISK_CHANGED_BIT, &DRS->flags)) {
2838 DPRINT("disk absent or changed during operation\n");
2839 request_done(0);
2840 goto do_request;
2841 }
2842 if (!_floppy) { /* Autodetection */
2843 if (!probing) {
2844 DRS->probed_format = 0;
2845 if (next_valid_format()) {
2846 DPRINT("no autodetectable formats\n");
2847 _floppy = NULL;
2848 request_done(0);
2849 goto do_request;
2850 }
2851 }
2852 probing = 1;
2853 _floppy = floppy_type + DP->autodetect[DRS->probed_format];
2854 } else
2855 probing = 0;
2856 errors = &(current_req->error_count);
2857 tmp = make_raw_rw_request();
2858 if (tmp < 2) {
2859 request_done(tmp);
2860 goto do_request;
2861 }
2862
2863 if (test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags))
2864 twaddle();
2865 schedule_bh(floppy_start);
2866 debugt(__func__, "queue fd request");
2867 return;
2868}
2869
2870static const struct cont_t rw_cont = {
2871 .interrupt = rw_interrupt,
2872 .redo = redo_fd_request,
2873 .error = bad_flp_intr,
2874 .done = request_done
2875};
2876
2877static void process_fd_request(void)
2878{
2879 cont = &rw_cont;
2880 schedule_bh(redo_fd_request);
2881}
2882
2883static blk_status_t floppy_queue_rq(struct blk_mq_hw_ctx *hctx,
2884 const struct blk_mq_queue_data *bd)
2885{
2886 blk_mq_start_request(bd->rq);
2887
2888 if (WARN(max_buffer_sectors == 0,
2889 "VFS: %s called on non-open device\n", __func__))
2890 return BLK_STS_IOERR;
2891
2892 if (WARN(atomic_read(&usage_count) == 0,
2893 "warning: usage count=0, current_req=%p sect=%ld flags=%llx\n",
2894 current_req, (long)blk_rq_pos(current_req),
2895 (unsigned long long) current_req->cmd_flags))
2896 return BLK_STS_IOERR;
2897
2898 spin_lock_irq(&floppy_lock);
2899 list_add_tail(&bd->rq->queuelist, &floppy_reqs);
2900 spin_unlock_irq(&floppy_lock);
2901
2902 if (test_and_set_bit(0, &fdc_busy)) {
2903 /* fdc busy, this new request will be treated when the
2904 current one is done */
2905 is_alive(__func__, "old request running");
2906 return BLK_STS_OK;
2907 }
2908
2909 command_status = FD_COMMAND_NONE;
2910 __reschedule_timeout(MAXTIMEOUT, "fd_request");
2911 set_fdc(0);
2912 process_fd_request();
2913 is_alive(__func__, "");
2914 return BLK_STS_OK;
2915}
2916
2917static const struct cont_t poll_cont = {
2918 .interrupt = success_and_wakeup,
2919 .redo = floppy_ready,
2920 .error = generic_failure,
2921 .done = generic_done
2922};
2923
2924static int poll_drive(bool interruptible, int flag)
2925{
2926 /* no auto-sense, just clear dcl */
2927 raw_cmd = &default_raw_cmd;
2928 raw_cmd->flags = flag;
2929 raw_cmd->track = 0;
2930 raw_cmd->cmd_count = 0;
2931 cont = &poll_cont;
2932 debug_dcl(DP->flags, "setting NEWCHANGE in poll_drive\n");
2933 set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
2934
2935 return wait_til_done(floppy_ready, interruptible);
2936}
2937
2938/*
2939 * User triggered reset
2940 * ====================
2941 */
2942
2943static void reset_intr(void)
2944{
2945 pr_info("weird, reset interrupt called\n");
2946}
2947
2948static const struct cont_t reset_cont = {
2949 .interrupt = reset_intr,
2950 .redo = success_and_wakeup,
2951 .error = generic_failure,
2952 .done = generic_done
2953};
2954
2955static int user_reset_fdc(int drive, int arg, bool interruptible)
2956{
2957 int ret;
2958
2959 if (lock_fdc(drive))
2960 return -EINTR;
2961
2962 if (arg == FD_RESET_ALWAYS)
2963 FDCS->reset = 1;
2964 if (FDCS->reset) {
2965 cont = &reset_cont;
2966 ret = wait_til_done(reset_fdc, interruptible);
2967 if (ret == -EINTR)
2968 return -EINTR;
2969 }
2970 process_fd_request();
2971 return 0;
2972}
2973
2974/*
2975 * Misc Ioctl's and support
2976 * ========================
2977 */
2978static inline int fd_copyout(void __user *param, const void *address,
2979 unsigned long size)
2980{
2981 return copy_to_user(param, address, size) ? -EFAULT : 0;
2982}
2983
2984static inline int fd_copyin(void __user *param, void *address,
2985 unsigned long size)
2986{
2987 return copy_from_user(address, param, size) ? -EFAULT : 0;
2988}
2989
2990static const char *drive_name(int type, int drive)
2991{
2992 struct floppy_struct *floppy;
2993
2994 if (type)
2995 floppy = floppy_type + type;
2996 else {
2997 if (UDP->native_format)
2998 floppy = floppy_type + UDP->native_format;
2999 else
3000 return "(null)";
3001 }
3002 if (floppy->name)
3003 return floppy->name;
3004 else
3005 return "(null)";
3006}
3007
3008/* raw commands */
3009static void raw_cmd_done(int flag)
3010{
3011 int i;
3012
3013 if (!flag) {
3014 raw_cmd->flags |= FD_RAW_FAILURE;
3015 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3016 } else {
3017 raw_cmd->reply_count = inr;
3018 if (raw_cmd->reply_count > MAX_REPLIES)
3019 raw_cmd->reply_count = 0;
3020 for (i = 0; i < raw_cmd->reply_count; i++)
3021 raw_cmd->reply[i] = reply_buffer[i];
3022
3023 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3024 unsigned long flags;
3025 flags = claim_dma_lock();
3026 raw_cmd->length = fd_get_dma_residue();
3027 release_dma_lock(flags);
3028 }
3029
3030 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3031 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3032 raw_cmd->flags |= FD_RAW_FAILURE;
3033
3034 if (disk_change(current_drive))
3035 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3036 else
3037 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3038 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3039 motor_off_callback(&motor_off_timer[current_drive]);
3040
3041 if (raw_cmd->next &&
3042 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3043 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3044 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3045 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3046 raw_cmd = raw_cmd->next;
3047 return;
3048 }
3049 }
3050 generic_done(flag);
3051}
3052
3053static const struct cont_t raw_cmd_cont = {
3054 .interrupt = success_and_wakeup,
3055 .redo = floppy_start,
3056 .error = generic_failure,
3057 .done = raw_cmd_done
3058};
3059
3060static int raw_cmd_copyout(int cmd, void __user *param,
3061 struct floppy_raw_cmd *ptr)
3062{
3063 int ret;
3064
3065 while (ptr) {
3066 struct floppy_raw_cmd cmd = *ptr;
3067 cmd.next = NULL;
3068 cmd.kernel_data = NULL;
3069 ret = copy_to_user(param, &cmd, sizeof(cmd));
3070 if (ret)
3071 return -EFAULT;
3072 param += sizeof(struct floppy_raw_cmd);
3073 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3074 if (ptr->length >= 0 &&
3075 ptr->length <= ptr->buffer_length) {
3076 long length = ptr->buffer_length - ptr->length;
3077 ret = fd_copyout(ptr->data, ptr->kernel_data,
3078 length);
3079 if (ret)
3080 return ret;
3081 }
3082 }
3083 ptr = ptr->next;
3084 }
3085
3086 return 0;
3087}
3088
3089static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3090{
3091 struct floppy_raw_cmd *next;
3092 struct floppy_raw_cmd *this;
3093
3094 this = *ptr;
3095 *ptr = NULL;
3096 while (this) {
3097 if (this->buffer_length) {
3098 fd_dma_mem_free((unsigned long)this->kernel_data,
3099 this->buffer_length);
3100 this->buffer_length = 0;
3101 }
3102 next = this->next;
3103 kfree(this);
3104 this = next;
3105 }
3106}
3107
3108static int raw_cmd_copyin(int cmd, void __user *param,
3109 struct floppy_raw_cmd **rcmd)
3110{
3111 struct floppy_raw_cmd *ptr;
3112 int ret;
3113 int i;
3114
3115 *rcmd = NULL;
3116
3117loop:
3118 ptr = kmalloc(sizeof(struct floppy_raw_cmd), GFP_KERNEL);
3119 if (!ptr)
3120 return -ENOMEM;
3121 *rcmd = ptr;
3122 ret = copy_from_user(ptr, param, sizeof(*ptr));
3123 ptr->next = NULL;
3124 ptr->buffer_length = 0;
3125 ptr->kernel_data = NULL;
3126 if (ret)
3127 return -EFAULT;
3128 param += sizeof(struct floppy_raw_cmd);
3129 if (ptr->cmd_count > 33)
3130 /* the command may now also take up the space
3131 * initially intended for the reply & the
3132 * reply count. Needed for long 82078 commands
3133 * such as RESTORE, which takes ... 17 command
3134 * bytes. Murphy's law #137: When you reserve
3135 * 16 bytes for a structure, you'll one day
3136 * discover that you really need 17...
3137 */
3138 return -EINVAL;
3139
3140 for (i = 0; i < 16; i++)
3141 ptr->reply[i] = 0;
3142 ptr->resultcode = 0;
3143
3144 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3145 if (ptr->length <= 0)
3146 return -EINVAL;
3147 ptr->kernel_data = (char *)fd_dma_mem_alloc(ptr->length);
3148 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3149 if (!ptr->kernel_data)
3150 return -ENOMEM;
3151 ptr->buffer_length = ptr->length;
3152 }
3153 if (ptr->flags & FD_RAW_WRITE) {
3154 ret = fd_copyin(ptr->data, ptr->kernel_data, ptr->length);
3155 if (ret)
3156 return ret;
3157 }
3158
3159 if (ptr->flags & FD_RAW_MORE) {
3160 rcmd = &(ptr->next);
3161 ptr->rate &= 0x43;
3162 goto loop;
3163 }
3164
3165 return 0;
3166}
3167
3168static int raw_cmd_ioctl(int cmd, void __user *param)
3169{
3170 struct floppy_raw_cmd *my_raw_cmd;
3171 int drive;
3172 int ret2;
3173 int ret;
3174
3175 if (FDCS->rawcmd <= 1)
3176 FDCS->rawcmd = 1;
3177 for (drive = 0; drive < N_DRIVE; drive++) {
3178 if (FDC(drive) != fdc)
3179 continue;
3180 if (drive == current_drive) {
3181 if (UDRS->fd_ref > 1) {
3182 FDCS->rawcmd = 2;
3183 break;
3184 }
3185 } else if (UDRS->fd_ref) {
3186 FDCS->rawcmd = 2;
3187 break;
3188 }
3189 }
3190
3191 if (FDCS->reset)
3192 return -EIO;
3193
3194 ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3195 if (ret) {
3196 raw_cmd_free(&my_raw_cmd);
3197 return ret;
3198 }
3199
3200 raw_cmd = my_raw_cmd;
3201 cont = &raw_cmd_cont;
3202 ret = wait_til_done(floppy_start, true);
3203 debug_dcl(DP->flags, "calling disk change from raw_cmd ioctl\n");
3204
3205 if (ret != -EINTR && FDCS->reset)
3206 ret = -EIO;
3207
3208 DRS->track = NO_TRACK;
3209
3210 ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3211 if (!ret)
3212 ret = ret2;
3213 raw_cmd_free(&my_raw_cmd);
3214 return ret;
3215}
3216
3217static int invalidate_drive(struct block_device *bdev)
3218{
3219 /* invalidate the buffer track to force a reread */
3220 set_bit((long)bdev->bd_disk->private_data, &fake_change);
3221 process_fd_request();
3222 check_disk_change(bdev);
3223 return 0;
3224}
3225
3226static int set_geometry(unsigned int cmd, struct floppy_struct *g,
3227 int drive, int type, struct block_device *bdev)
3228{
3229 int cnt;
3230
3231 /* sanity checking for parameters. */
3232 if (g->sect <= 0 ||
3233 g->head <= 0 ||
3234 g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3235 /* check if reserved bits are set */
3236 (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0)
3237 return -EINVAL;
3238 if (type) {
3239 if (!capable(CAP_SYS_ADMIN))
3240 return -EPERM;
3241 mutex_lock(&open_lock);
3242 if (lock_fdc(drive)) {
3243 mutex_unlock(&open_lock);
3244 return -EINTR;
3245 }
3246 floppy_type[type] = *g;
3247 floppy_type[type].name = "user format";
3248 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3249 floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3250 floppy_type[type].size + 1;
3251 process_fd_request();
3252 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3253 struct block_device *bdev = opened_bdev[cnt];
3254 if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3255 continue;
3256 __invalidate_device(bdev, true);
3257 }
3258 mutex_unlock(&open_lock);
3259 } else {
3260 int oldStretch;
3261
3262 if (lock_fdc(drive))
3263 return -EINTR;
3264 if (cmd != FDDEFPRM) {
3265 /* notice a disk change immediately, else
3266 * we lose our settings immediately*/
3267 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
3268 return -EINTR;
3269 }
3270 oldStretch = g->stretch;
3271 user_params[drive] = *g;
3272 if (buffer_drive == drive)
3273 SUPBOUND(buffer_max, user_params[drive].sect);
3274 current_type[drive] = &user_params[drive];
3275 floppy_sizes[drive] = user_params[drive].size;
3276 if (cmd == FDDEFPRM)
3277 DRS->keep_data = -1;
3278 else
3279 DRS->keep_data = 1;
3280 /* invalidation. Invalidate only when needed, i.e.
3281 * when there are already sectors in the buffer cache
3282 * whose number will change. This is useful, because
3283 * mtools often changes the geometry of the disk after
3284 * looking at the boot block */
3285 if (DRS->maxblock > user_params[drive].sect ||
3286 DRS->maxtrack ||
3287 ((user_params[drive].sect ^ oldStretch) &
3288 (FD_SWAPSIDES | FD_SECTBASEMASK)))
3289 invalidate_drive(bdev);
3290 else
3291 process_fd_request();
3292 }
3293 return 0;
3294}
3295
3296/* handle obsolete ioctl's */
3297static unsigned int ioctl_table[] = {
3298 FDCLRPRM,
3299 FDSETPRM,
3300 FDDEFPRM,
3301 FDGETPRM,
3302 FDMSGON,
3303 FDMSGOFF,
3304 FDFMTBEG,
3305 FDFMTTRK,
3306 FDFMTEND,
3307 FDSETEMSGTRESH,
3308 FDFLUSH,
3309 FDSETMAXERRS,
3310 FDGETMAXERRS,
3311 FDGETDRVTYP,
3312 FDSETDRVPRM,
3313 FDGETDRVPRM,
3314 FDGETDRVSTAT,
3315 FDPOLLDRVSTAT,
3316 FDRESET,
3317 FDGETFDCSTAT,
3318 FDWERRORCLR,
3319 FDWERRORGET,
3320 FDRAWCMD,
3321 FDEJECT,
3322 FDTWADDLE
3323};
3324
3325static int normalize_ioctl(unsigned int *cmd, int *size)
3326{
3327 int i;
3328
3329 for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3330 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3331 *size = _IOC_SIZE(*cmd);
3332 *cmd = ioctl_table[i];
3333 if (*size > _IOC_SIZE(*cmd)) {
3334 pr_info("ioctl not yet supported\n");
3335 return -EFAULT;
3336 }
3337 return 0;
3338 }
3339 }
3340 return -EINVAL;
3341}
3342
3343static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3344{
3345 if (type)
3346 *g = &floppy_type[type];
3347 else {
3348 if (lock_fdc(drive))
3349 return -EINTR;
3350 if (poll_drive(false, 0) == -EINTR)
3351 return -EINTR;
3352 process_fd_request();
3353 *g = current_type[drive];
3354 }
3355 if (!*g)
3356 return -ENODEV;
3357 return 0;
3358}
3359
3360static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3361{
3362 int drive = (long)bdev->bd_disk->private_data;
3363 int type = ITYPE(drive_state[drive].fd_device);
3364 struct floppy_struct *g;
3365 int ret;
3366
3367 ret = get_floppy_geometry(drive, type, &g);
3368 if (ret)
3369 return ret;
3370
3371 geo->heads = g->head;
3372 geo->sectors = g->sect;
3373 geo->cylinders = g->track;
3374 return 0;
3375}
3376
3377static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
3378 unsigned long param)
3379{
3380 int drive = (long)bdev->bd_disk->private_data;
3381 int type = ITYPE(UDRS->fd_device);
3382 int i;
3383 int ret;
3384 int size;
3385 union inparam {
3386 struct floppy_struct g; /* geometry */
3387 struct format_descr f;
3388 struct floppy_max_errors max_errors;
3389 struct floppy_drive_params dp;
3390 } inparam; /* parameters coming from user space */
3391 const void *outparam; /* parameters passed back to user space */
3392
3393 /* convert compatibility eject ioctls into floppy eject ioctl.
3394 * We do this in order to provide a means to eject floppy disks before
3395 * installing the new fdutils package */
3396 if (cmd == CDROMEJECT || /* CD-ROM eject */
3397 cmd == 0x6470) { /* SunOS floppy eject */
3398 DPRINT("obsolete eject ioctl\n");
3399 DPRINT("please use floppycontrol --eject\n");
3400 cmd = FDEJECT;
3401 }
3402
3403 if (!((cmd & 0xff00) == 0x0200))
3404 return -EINVAL;
3405
3406 /* convert the old style command into a new style command */
3407 ret = normalize_ioctl(&cmd, &size);
3408 if (ret)
3409 return ret;
3410
3411 /* permission checks */
3412 if (((cmd & 0x40) && !(mode & (FMODE_WRITE | FMODE_WRITE_IOCTL))) ||
3413 ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3414 return -EPERM;
3415
3416 if (WARN_ON(size < 0 || size > sizeof(inparam)))
3417 return -EINVAL;
3418
3419 /* copyin */
3420 memset(&inparam, 0, sizeof(inparam));
3421 if (_IOC_DIR(cmd) & _IOC_WRITE) {
3422 ret = fd_copyin((void __user *)param, &inparam, size);
3423 if (ret)
3424 return ret;
3425 }
3426
3427 switch (cmd) {
3428 case FDEJECT:
3429 if (UDRS->fd_ref != 1)
3430 /* somebody else has this drive open */
3431 return -EBUSY;
3432 if (lock_fdc(drive))
3433 return -EINTR;
3434
3435 /* do the actual eject. Fails on
3436 * non-Sparc architectures */
3437 ret = fd_eject(UNIT(drive));
3438
3439 set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
3440 set_bit(FD_VERIFY_BIT, &UDRS->flags);
3441 process_fd_request();
3442 return ret;
3443 case FDCLRPRM:
3444 if (lock_fdc(drive))
3445 return -EINTR;
3446 current_type[drive] = NULL;
3447 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3448 UDRS->keep_data = 0;
3449 return invalidate_drive(bdev);
3450 case FDSETPRM:
3451 case FDDEFPRM:
3452 return set_geometry(cmd, &inparam.g, drive, type, bdev);
3453 case FDGETPRM:
3454 ret = get_floppy_geometry(drive, type,
3455 (struct floppy_struct **)&outparam);
3456 if (ret)
3457 return ret;
3458 memcpy(&inparam.g, outparam,
3459 offsetof(struct floppy_struct, name));
3460 outparam = &inparam.g;
3461 break;
3462 case FDMSGON:
3463 UDP->flags |= FTD_MSG;
3464 return 0;
3465 case FDMSGOFF:
3466 UDP->flags &= ~FTD_MSG;
3467 return 0;
3468 case FDFMTBEG:
3469 if (lock_fdc(drive))
3470 return -EINTR;
3471 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
3472 return -EINTR;
3473 ret = UDRS->flags;
3474 process_fd_request();
3475 if (ret & FD_VERIFY)
3476 return -ENODEV;
3477 if (!(ret & FD_DISK_WRITABLE))
3478 return -EROFS;
3479 return 0;
3480 case FDFMTTRK:
3481 if (UDRS->fd_ref != 1)
3482 return -EBUSY;
3483 return do_format(drive, &inparam.f);
3484 case FDFMTEND:
3485 case FDFLUSH:
3486 if (lock_fdc(drive))
3487 return -EINTR;
3488 return invalidate_drive(bdev);
3489 case FDSETEMSGTRESH:
3490 UDP->max_errors.reporting = (unsigned short)(param & 0x0f);
3491 return 0;
3492 case FDGETMAXERRS:
3493 outparam = &UDP->max_errors;
3494 break;
3495 case FDSETMAXERRS:
3496 UDP->max_errors = inparam.max_errors;
3497 break;
3498 case FDGETDRVTYP:
3499 outparam = drive_name(type, drive);
3500 SUPBOUND(size, strlen((const char *)outparam) + 1);
3501 break;
3502 case FDSETDRVPRM:
3503 *UDP = inparam.dp;
3504 break;
3505 case FDGETDRVPRM:
3506 outparam = UDP;
3507 break;
3508 case FDPOLLDRVSTAT:
3509 if (lock_fdc(drive))
3510 return -EINTR;
3511 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
3512 return -EINTR;
3513 process_fd_request();
3514 /* fall through */
3515 case FDGETDRVSTAT:
3516 outparam = UDRS;
3517 break;
3518 case FDRESET:
3519 return user_reset_fdc(drive, (int)param, true);
3520 case FDGETFDCSTAT:
3521 outparam = UFDCS;
3522 break;
3523 case FDWERRORCLR:
3524 memset(UDRWE, 0, sizeof(*UDRWE));
3525 return 0;
3526 case FDWERRORGET:
3527 outparam = UDRWE;
3528 break;
3529 case FDRAWCMD:
3530 if (type)
3531 return -EINVAL;
3532 if (lock_fdc(drive))
3533 return -EINTR;
3534 set_floppy(drive);
3535 i = raw_cmd_ioctl(cmd, (void __user *)param);
3536 if (i == -EINTR)
3537 return -EINTR;
3538 process_fd_request();
3539 return i;
3540 case FDTWADDLE:
3541 if (lock_fdc(drive))
3542 return -EINTR;
3543 twaddle();
3544 process_fd_request();
3545 return 0;
3546 default:
3547 return -EINVAL;
3548 }
3549
3550 if (_IOC_DIR(cmd) & _IOC_READ)
3551 return fd_copyout((void __user *)param, outparam, size);
3552
3553 return 0;
3554}
3555
3556static int fd_ioctl(struct block_device *bdev, fmode_t mode,
3557 unsigned int cmd, unsigned long param)
3558{
3559 int ret;
3560
3561 mutex_lock(&floppy_mutex);
3562 ret = fd_locked_ioctl(bdev, mode, cmd, param);
3563 mutex_unlock(&floppy_mutex);
3564
3565 return ret;
3566}
3567
3568#ifdef CONFIG_COMPAT
3569
3570struct compat_floppy_drive_params {
3571 char cmos;
3572 compat_ulong_t max_dtr;
3573 compat_ulong_t hlt;
3574 compat_ulong_t hut;
3575 compat_ulong_t srt;
3576 compat_ulong_t spinup;
3577 compat_ulong_t spindown;
3578 unsigned char spindown_offset;
3579 unsigned char select_delay;
3580 unsigned char rps;
3581 unsigned char tracks;
3582 compat_ulong_t timeout;
3583 unsigned char interleave_sect;
3584 struct floppy_max_errors max_errors;
3585 char flags;
3586 char read_track;
3587 short autodetect[8];
3588 compat_int_t checkfreq;
3589 compat_int_t native_format;
3590};
3591
3592struct compat_floppy_drive_struct {
3593 signed char flags;
3594 compat_ulong_t spinup_date;
3595 compat_ulong_t select_date;
3596 compat_ulong_t first_read_date;
3597 short probed_format;
3598 short track;
3599 short maxblock;
3600 short maxtrack;
3601 compat_int_t generation;
3602 compat_int_t keep_data;
3603 compat_int_t fd_ref;
3604 compat_int_t fd_device;
3605 compat_int_t last_checked;
3606 compat_caddr_t dmabuf;
3607 compat_int_t bufblocks;
3608};
3609
3610struct compat_floppy_fdc_state {
3611 compat_int_t spec1;
3612 compat_int_t spec2;
3613 compat_int_t dtr;
3614 unsigned char version;
3615 unsigned char dor;
3616 compat_ulong_t address;
3617 unsigned int rawcmd:2;
3618 unsigned int reset:1;
3619 unsigned int need_configure:1;
3620 unsigned int perp_mode:2;
3621 unsigned int has_fifo:1;
3622 unsigned int driver_version;
3623 unsigned char track[4];
3624};
3625
3626struct compat_floppy_write_errors {
3627 unsigned int write_errors;
3628 compat_ulong_t first_error_sector;
3629 compat_int_t first_error_generation;
3630 compat_ulong_t last_error_sector;
3631 compat_int_t last_error_generation;
3632 compat_uint_t badness;
3633};
3634
3635#define FDSETPRM32 _IOW(2, 0x42, struct compat_floppy_struct)
3636#define FDDEFPRM32 _IOW(2, 0x43, struct compat_floppy_struct)
3637#define FDSETDRVPRM32 _IOW(2, 0x90, struct compat_floppy_drive_params)
3638#define FDGETDRVPRM32 _IOR(2, 0x11, struct compat_floppy_drive_params)
3639#define FDGETDRVSTAT32 _IOR(2, 0x12, struct compat_floppy_drive_struct)
3640#define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct compat_floppy_drive_struct)
3641#define FDGETFDCSTAT32 _IOR(2, 0x15, struct compat_floppy_fdc_state)
3642#define FDWERRORGET32 _IOR(2, 0x17, struct compat_floppy_write_errors)
3643
3644static int compat_set_geometry(struct block_device *bdev, fmode_t mode, unsigned int cmd,
3645 struct compat_floppy_struct __user *arg)
3646{
3647 struct floppy_struct v;
3648 int drive, type;
3649 int err;
3650
3651 BUILD_BUG_ON(offsetof(struct floppy_struct, name) !=
3652 offsetof(struct compat_floppy_struct, name));
3653
3654 if (!(mode & (FMODE_WRITE | FMODE_WRITE_IOCTL)))
3655 return -EPERM;
3656
3657 memset(&v, 0, sizeof(struct floppy_struct));
3658 if (copy_from_user(&v, arg, offsetof(struct floppy_struct, name)))
3659 return -EFAULT;
3660
3661 mutex_lock(&floppy_mutex);
3662 drive = (long)bdev->bd_disk->private_data;
3663 type = ITYPE(UDRS->fd_device);
3664 err = set_geometry(cmd == FDSETPRM32 ? FDSETPRM : FDDEFPRM,
3665 &v, drive, type, bdev);
3666 mutex_unlock(&floppy_mutex);
3667 return err;
3668}
3669
3670static int compat_get_prm(int drive,
3671 struct compat_floppy_struct __user *arg)
3672{
3673 struct compat_floppy_struct v;
3674 struct floppy_struct *p;
3675 int err;
3676
3677 memset(&v, 0, sizeof(v));
3678 mutex_lock(&floppy_mutex);
3679 err = get_floppy_geometry(drive, ITYPE(UDRS->fd_device), &p);
3680 if (err) {
3681 mutex_unlock(&floppy_mutex);
3682 return err;
3683 }
3684 memcpy(&v, p, offsetof(struct floppy_struct, name));
3685 mutex_unlock(&floppy_mutex);
3686 if (copy_to_user(arg, &v, sizeof(struct compat_floppy_struct)))
3687 return -EFAULT;
3688 return 0;
3689}
3690
3691static int compat_setdrvprm(int drive,
3692 struct compat_floppy_drive_params __user *arg)
3693{
3694 struct compat_floppy_drive_params v;
3695
3696 if (!capable(CAP_SYS_ADMIN))
3697 return -EPERM;
3698 if (copy_from_user(&v, arg, sizeof(struct compat_floppy_drive_params)))
3699 return -EFAULT;
3700 mutex_lock(&floppy_mutex);
3701 UDP->cmos = v.cmos;
3702 UDP->max_dtr = v.max_dtr;
3703 UDP->hlt = v.hlt;
3704 UDP->hut = v.hut;
3705 UDP->srt = v.srt;
3706 UDP->spinup = v.spinup;
3707 UDP->spindown = v.spindown;
3708 UDP->spindown_offset = v.spindown_offset;
3709 UDP->select_delay = v.select_delay;
3710 UDP->rps = v.rps;
3711 UDP->tracks = v.tracks;
3712 UDP->timeout = v.timeout;
3713 UDP->interleave_sect = v.interleave_sect;
3714 UDP->max_errors = v.max_errors;
3715 UDP->flags = v.flags;
3716 UDP->read_track = v.read_track;
3717 memcpy(UDP->autodetect, v.autodetect, sizeof(v.autodetect));
3718 UDP->checkfreq = v.checkfreq;
3719 UDP->native_format = v.native_format;
3720 mutex_unlock(&floppy_mutex);
3721 return 0;
3722}
3723
3724static int compat_getdrvprm(int drive,
3725 struct compat_floppy_drive_params __user *arg)
3726{
3727 struct compat_floppy_drive_params v;
3728
3729 memset(&v, 0, sizeof(struct compat_floppy_drive_params));
3730 mutex_lock(&floppy_mutex);
3731 v.cmos = UDP->cmos;
3732 v.max_dtr = UDP->max_dtr;
3733 v.hlt = UDP->hlt;
3734 v.hut = UDP->hut;
3735 v.srt = UDP->srt;
3736 v.spinup = UDP->spinup;
3737 v.spindown = UDP->spindown;
3738 v.spindown_offset = UDP->spindown_offset;
3739 v.select_delay = UDP->select_delay;
3740 v.rps = UDP->rps;
3741 v.tracks = UDP->tracks;
3742 v.timeout = UDP->timeout;
3743 v.interleave_sect = UDP->interleave_sect;
3744 v.max_errors = UDP->max_errors;
3745 v.flags = UDP->flags;
3746 v.read_track = UDP->read_track;
3747 memcpy(v.autodetect, UDP->autodetect, sizeof(v.autodetect));
3748 v.checkfreq = UDP->checkfreq;
3749 v.native_format = UDP->native_format;
3750 mutex_unlock(&floppy_mutex);
3751
3752 if (copy_from_user(arg, &v, sizeof(struct compat_floppy_drive_params)))
3753 return -EFAULT;
3754 return 0;
3755}
3756
3757static int compat_getdrvstat(int drive, bool poll,
3758 struct compat_floppy_drive_struct __user *arg)
3759{
3760 struct compat_floppy_drive_struct v;
3761
3762 memset(&v, 0, sizeof(struct compat_floppy_drive_struct));
3763 mutex_lock(&floppy_mutex);
3764
3765 if (poll) {
3766 if (lock_fdc(drive))
3767 goto Eintr;
3768 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
3769 goto Eintr;
3770 process_fd_request();
3771 }
3772 v.spinup_date = UDRS->spinup_date;
3773 v.select_date = UDRS->select_date;
3774 v.first_read_date = UDRS->first_read_date;
3775 v.probed_format = UDRS->probed_format;
3776 v.track = UDRS->track;
3777 v.maxblock = UDRS->maxblock;
3778 v.maxtrack = UDRS->maxtrack;
3779 v.generation = UDRS->generation;
3780 v.keep_data = UDRS->keep_data;
3781 v.fd_ref = UDRS->fd_ref;
3782 v.fd_device = UDRS->fd_device;
3783 v.last_checked = UDRS->last_checked;
3784 v.dmabuf = (uintptr_t)UDRS->dmabuf;
3785 v.bufblocks = UDRS->bufblocks;
3786 mutex_unlock(&floppy_mutex);
3787
3788 if (copy_from_user(arg, &v, sizeof(struct compat_floppy_drive_struct)))
3789 return -EFAULT;
3790 return 0;
3791Eintr:
3792 mutex_unlock(&floppy_mutex);
3793 return -EINTR;
3794}
3795
3796static int compat_getfdcstat(int drive,
3797 struct compat_floppy_fdc_state __user *arg)
3798{
3799 struct compat_floppy_fdc_state v32;
3800 struct floppy_fdc_state v;
3801
3802 mutex_lock(&floppy_mutex);
3803 v = *UFDCS;
3804 mutex_unlock(&floppy_mutex);
3805
3806 memset(&v32, 0, sizeof(struct compat_floppy_fdc_state));
3807 v32.spec1 = v.spec1;
3808