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