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