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