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