?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libertas: rename and clean up DownloadcommandToStation
[linux-2.6/openmoko-kernel/knife-kernel.git] / drivers / block / floppy.c
blob32c79a55511bd174f3effd63af4e5bd7bc594b68
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 error)
2291 {
2292 unsigned int nr_sectors = current_count_sectors;
2293 unsigned int drive = (unsigned long)req->rq_disk->private_data;
2294
2295 /* current_count_sectors can be zero if transfer failed */
2296 if (error)
2297 nr_sectors = req->current_nr_sectors;
2298 if (__blk_end_request(req, error, nr_sectors << 9))
2299 return;
2300
2301 /* We're done with the request */
2302 floppy_off(drive);
2303 current_req = NULL;
2304 }
2305
2306 /* new request_done. Can handle physical sectors which are smaller than a
2307 * logical buffer */
2308 static void request_done(int uptodate)
2309 {
2310 struct request_queue *q = floppy_queue;
2311 struct request *req = current_req;
2312 unsigned long flags;
2313 int block;
2314
2315 probing = 0;
2316 reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
2317
2318 if (!req) {
2319 printk("floppy.c: no request in request_done\n");
2320 return;
2321 }
2322
2323 if (uptodate) {
2324 /* maintain values for invalidation on geometry
2325 * change */
2326 block = current_count_sectors + req->sector;
2327 INFBOUND(DRS->maxblock, block);
2328 if (block > _floppy->sect)
2329 DRS->maxtrack = 1;
2330
2331 /* unlock chained buffers */
2332 spin_lock_irqsave(q->queue_lock, flags);
2333 floppy_end_request(req, 0);
2334 spin_unlock_irqrestore(q->queue_lock, flags);
2335 } else {
2336 if (rq_data_dir(req) == WRITE) {
2337 /* record write error information */
2338 DRWE->write_errors++;
2339 if (DRWE->write_errors == 1) {
2340 DRWE->first_error_sector = req->sector;
2341 DRWE->first_error_generation = DRS->generation;
2342 }
2343 DRWE->last_error_sector = req->sector;
2344 DRWE->last_error_generation = DRS->generation;
2345 }
2346 spin_lock_irqsave(q->queue_lock, flags);
2347 floppy_end_request(req, -EIO);
2348 spin_unlock_irqrestore(q->queue_lock, flags);
2349 }
2350 }
2351
2352 /* Interrupt handler evaluating the result of the r/w operation */
2353 static void rw_interrupt(void)
2354 {
2355 int eoc;
2356 int ssize;
2357 int heads;
2358 int nr_sectors;
2359
2360 if (R_HEAD >= 2) {
2361 /* some Toshiba floppy controllers occasionnally seem to
2362 * return bogus interrupts after read/write operations, which
2363 * can be recognized by a bad head number (>= 2) */
2364 return;
2365 }
2366
2367 if (!DRS->first_read_date)
2368 DRS->first_read_date = jiffies;
2369
2370 nr_sectors = 0;
2371 CODE2SIZE;
2372
2373 if (ST1 & ST1_EOC)
2374 eoc = 1;
2375 else
2376 eoc = 0;
2377
2378 if (COMMAND & 0x80)
2379 heads = 2;
2380 else
2381 heads = 1;
2382
2383 nr_sectors = (((R_TRACK - TRACK) * heads +
2384 R_HEAD - HEAD) * SECT_PER_TRACK +
2385 R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2386
2387 #ifdef FLOPPY_SANITY_CHECK
2388 if (nr_sectors / ssize >
2389 (in_sector_offset + current_count_sectors + ssize - 1) / ssize) {
2390 DPRINT("long rw: %x instead of %lx\n",
2391 nr_sectors, current_count_sectors);
2392 printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
2393 printk("rh=%d h=%d\n", R_HEAD, HEAD);
2394 printk("rt=%d t=%d\n", R_TRACK, TRACK);
2395 printk("heads=%d eoc=%d\n", heads, eoc);
2396 printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
2397 fsector_t, ssize);
2398 printk("in_sector_offset=%d\n", in_sector_offset);
2399 }
2400 #endif
2401
2402 nr_sectors -= in_sector_offset;
2403 INFBOUND(nr_sectors, 0);
2404 SUPBOUND(current_count_sectors, nr_sectors);
2405
2406 switch (interpret_errors()) {
2407 case 2:
2408 cont->redo();
2409 return;
2410 case 1:
2411 if (!current_count_sectors) {
2412 cont->error();
2413 cont->redo();
2414 return;
2415 }
2416 break;
2417 case 0:
2418 if (!current_count_sectors) {
2419 cont->redo();
2420 return;
2421 }
2422 current_type[current_drive] = _floppy;
2423 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2424 break;
2425 }
2426
2427 if (probing) {
2428 if (DP->flags & FTD_MSG)
2429 DPRINT("Auto-detected floppy type %s in fd%d\n",
2430 _floppy->name, current_drive);
2431 current_type[current_drive] = _floppy;
2432 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2433 probing = 0;
2434 }
2435
2436 if (CT(COMMAND) != FD_READ ||
2437 raw_cmd->kernel_data == current_req->buffer) {
2438 /* transfer directly from buffer */
2439 cont->done(1);
2440 } else if (CT(COMMAND) == FD_READ) {
2441 buffer_track = raw_cmd->track;
2442 buffer_drive = current_drive;
2443 INFBOUND(buffer_max, nr_sectors + fsector_t);
2444 }
2445 cont->redo();
2446 }
2447
2448 /* Compute maximal contiguous buffer size. */
2449 static int buffer_chain_size(void)
2450 {
2451 struct bio_vec *bv;
2452 int size;
2453 struct req_iterator iter;
2454 char *base;
2455
2456 base = bio_data(current_req->bio);
2457 size = 0;
2458
2459 rq_for_each_segment(bv, current_req, iter) {
2460 if (page_address(bv->bv_page) + bv->bv_offset != base + size)
2461 break;
2462
2463 size += bv->bv_len;
2464 }
2465
2466 return size >> 9;
2467 }
2468
2469 /* Compute the maximal transfer size */
2470 static int transfer_size(int ssize, int max_sector, int max_size)
2471 {
2472 SUPBOUND(max_sector, fsector_t + max_size);
2473
2474 /* alignment */
2475 max_sector -= (max_sector % _floppy->sect) % ssize;
2476
2477 /* transfer size, beginning not aligned */
2478 current_count_sectors = max_sector - fsector_t;
2479
2480 return max_sector;
2481 }
2482
2483 /*
2484 * Move data from/to the track buffer to/from the buffer cache.
2485 */
2486 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2487 {
2488 int remaining; /* number of transferred 512-byte sectors */
2489 struct bio_vec *bv;
2490 char *buffer;
2491 char *dma_buffer;
2492 int size;
2493 struct req_iterator iter;
2494
2495 max_sector = transfer_size(ssize,
2496 min(max_sector, max_sector_2),
2497 current_req->nr_sectors);
2498
2499 if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2500 buffer_max > fsector_t + current_req->nr_sectors)
2501 current_count_sectors = min_t(int, buffer_max - fsector_t,
2502 current_req->nr_sectors);
2503
2504 remaining = current_count_sectors << 9;
2505 #ifdef FLOPPY_SANITY_CHECK
2506 if ((remaining >> 9) > current_req->nr_sectors &&
2507 CT(COMMAND) == FD_WRITE) {
2508 DPRINT("in copy buffer\n");
2509 printk("current_count_sectors=%ld\n", current_count_sectors);
2510 printk("remaining=%d\n", remaining >> 9);
2511 printk("current_req->nr_sectors=%ld\n",
2512 current_req->nr_sectors);
2513 printk("current_req->current_nr_sectors=%u\n",
2514 current_req->current_nr_sectors);
2515 printk("max_sector=%d\n", max_sector);
2516 printk("ssize=%d\n", ssize);
2517 }
2518 #endif
2519
2520 buffer_max = max(max_sector, buffer_max);
2521
2522 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2523
2524 size = current_req->current_nr_sectors << 9;
2525
2526 rq_for_each_segment(bv, current_req, iter) {
2527 if (!remaining)
2528 break;
2529
2530 size = bv->bv_len;
2531 SUPBOUND(size, remaining);
2532
2533 buffer = page_address(bv->bv_page) + bv->bv_offset;
2534 #ifdef FLOPPY_SANITY_CHECK
2535 if (dma_buffer + size >
2536 floppy_track_buffer + (max_buffer_sectors << 10) ||
2537 dma_buffer < floppy_track_buffer) {
2538 DPRINT("buffer overrun in copy buffer %d\n",
2539 (int)((floppy_track_buffer -
2540 dma_buffer) >> 9));
2541 printk("fsector_t=%d buffer_min=%d\n",
2542 fsector_t, buffer_min);
2543 printk("current_count_sectors=%ld\n",
2544 current_count_sectors);
2545 if (CT(COMMAND) == FD_READ)
2546 printk("read\n");
2547 if (CT(COMMAND) == FD_WRITE)
2548 printk("write\n");
2549 break;
2550 }
2551 if (((unsigned long)buffer) % 512)
2552 DPRINT("%p buffer not aligned\n", buffer);
2553 #endif
2554 if (CT(COMMAND) == FD_READ)
2555 memcpy(buffer, dma_buffer, size);
2556 else
2557 memcpy(dma_buffer, buffer, size);
2558
2559 remaining -= size;
2560 dma_buffer += size;
2561 }
2562 #ifdef FLOPPY_SANITY_CHECK
2563 if (remaining) {
2564 if (remaining > 0)
2565 max_sector -= remaining >> 9;
2566 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2567 }
2568 #endif
2569 }
2570
2571 /* work around a bug in pseudo DMA
2572 * (on some FDCs) pseudo DMA does not stop when the CPU stops
2573 * sending data. Hence we need a different way to signal the
2574 * transfer length: We use SECT_PER_TRACK. Unfortunately, this
2575 * does not work with MT, hence we can only transfer one head at
2576 * a time
2577 */
2578 static void virtualdmabug_workaround(void)
2579 {
2580 int hard_sectors;
2581 int end_sector;
2582
2583 if (CT(COMMAND) == FD_WRITE) {
2584 COMMAND &= ~0x80; /* switch off multiple track mode */
2585
2586 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2587 end_sector = SECTOR + hard_sectors - 1;
2588 #ifdef FLOPPY_SANITY_CHECK
2589 if (end_sector > SECT_PER_TRACK) {
2590 printk("too many sectors %d > %d\n",
2591 end_sector, SECT_PER_TRACK);
2592 return;
2593 }
2594 #endif
2595 SECT_PER_TRACK = end_sector; /* make sure SECT_PER_TRACK points
2596 * to end of transfer */
2597 }
2598 }
2599
2600 /*
2601 * Formulate a read/write request.
2602 * this routine decides where to load the data (directly to buffer, or to
2603 * tmp floppy area), how much data to load (the size of the buffer, the whole
2604 * track, or a single sector)
2605 * All floppy_track_buffer handling goes in here. If we ever add track buffer
2606 * allocation on the fly, it should be done here. No other part should need
2607 * modification.
2608 */
2609
2610 static int make_raw_rw_request(void)
2611 {
2612 int aligned_sector_t;
2613 int max_sector;
2614 int max_size;
2615 int tracksize;
2616 int ssize;
2617
2618 if (max_buffer_sectors == 0) {
2619 printk("VFS: Block I/O scheduled on unopened device\n");
2620 return 0;
2621 }
2622
2623 set_fdc((long)current_req->rq_disk->private_data);
2624
2625 raw_cmd = &default_raw_cmd;
2626 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2627 FD_RAW_NEED_SEEK;
2628 raw_cmd->cmd_count = NR_RW;
2629 if (rq_data_dir(current_req) == READ) {
2630 raw_cmd->flags |= FD_RAW_READ;
2631 COMMAND = FM_MODE(_floppy, FD_READ);
2632 } else if (rq_data_dir(current_req) == WRITE) {
2633 raw_cmd->flags |= FD_RAW_WRITE;
2634 COMMAND = FM_MODE(_floppy, FD_WRITE);
2635 } else {
2636 DPRINT("make_raw_rw_request: unknown command\n");
2637 return 0;
2638 }
2639
2640 max_sector = _floppy->sect * _floppy->head;
2641
2642 TRACK = (int)current_req->sector / max_sector;
2643 fsector_t = (int)current_req->sector % max_sector;
2644 if (_floppy->track && TRACK >= _floppy->track) {
2645 if (current_req->current_nr_sectors & 1) {
2646 current_count_sectors = 1;
2647 return 1;
2648 } else
2649 return 0;
2650 }
2651 HEAD = fsector_t / _floppy->sect;
2652
2653 if (((_floppy->stretch & (FD_SWAPSIDES | FD_ZEROBASED)) ||
2654 TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
2655 max_sector = _floppy->sect;
2656
2657 /* 2M disks have phantom sectors on the first track */
2658 if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2659 max_sector = 2 * _floppy->sect / 3;
2660 if (fsector_t >= max_sector) {
2661 current_count_sectors =
2662 min_t(int, _floppy->sect - fsector_t,
2663 current_req->nr_sectors);
2664 return 1;
2665 }
2666 SIZECODE = 2;
2667 } else
2668 SIZECODE = FD_SIZECODE(_floppy);
2669 raw_cmd->rate = _floppy->rate & 0x43;
2670 if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2671 raw_cmd->rate = 1;
2672
2673 if (SIZECODE)
2674 SIZECODE2 = 0xff;
2675 else
2676 SIZECODE2 = 0x80;
2677 raw_cmd->track = TRACK << STRETCH(_floppy);
2678 DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2679 GAP = _floppy->gap;
2680 CODE2SIZE;
2681 SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2682 SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
2683 ((_floppy->stretch & FD_ZEROBASED) ? 0 : 1);
2684
2685 /* tracksize describes the size which can be filled up with sectors
2686 * of size ssize.
2687 */
2688 tracksize = _floppy->sect - _floppy->sect % ssize;
2689 if (tracksize < _floppy->sect) {
2690 SECT_PER_TRACK++;
2691 if (tracksize <= fsector_t % _floppy->sect)
2692 SECTOR--;
2693
2694 /* if we are beyond tracksize, fill up using smaller sectors */
2695 while (tracksize <= fsector_t % _floppy->sect) {
2696 while (tracksize + ssize > _floppy->sect) {
2697 SIZECODE--;
2698 ssize >>= 1;
2699 }
2700 SECTOR++;
2701 SECT_PER_TRACK++;
2702 tracksize += ssize;
2703 }
2704 max_sector = HEAD * _floppy->sect + tracksize;
2705 } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2706 max_sector = _floppy->sect;
2707 } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2708 /* for virtual DMA bug workaround */
2709 max_sector = _floppy->sect;
2710 }
2711
2712 in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2713 aligned_sector_t = fsector_t - in_sector_offset;
2714 max_size = current_req->nr_sectors;
2715 if ((raw_cmd->track == buffer_track) &&
2716 (current_drive == buffer_drive) &&
2717 (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2718 /* data already in track buffer */
2719 if (CT(COMMAND) == FD_READ) {
2720 copy_buffer(1, max_sector, buffer_max);
2721 return 1;
2722 }
2723 } else if (in_sector_offset || current_req->nr_sectors < ssize) {
2724 if (CT(COMMAND) == FD_WRITE) {
2725 if (fsector_t + current_req->nr_sectors > ssize &&
2726 fsector_t + current_req->nr_sectors < ssize + ssize)
2727 max_size = ssize + ssize;
2728 else
2729 max_size = ssize;
2730 }
2731 raw_cmd->flags &= ~FD_RAW_WRITE;
2732 raw_cmd->flags |= FD_RAW_READ;
2733 COMMAND = FM_MODE(_floppy, FD_READ);
2734 } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2735 unsigned long dma_limit;
2736 int direct, indirect;
2737
2738 indirect =
2739 transfer_size(ssize, max_sector,
2740 max_buffer_sectors * 2) - fsector_t;
2741
2742 /*
2743 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2744 * on a 64 bit machine!
2745 */
2746 max_size = buffer_chain_size();
2747 dma_limit =
2748 (MAX_DMA_ADDRESS -
2749 ((unsigned long)current_req->buffer)) >> 9;
2750 if ((unsigned long)max_size > dma_limit) {
2751 max_size = dma_limit;
2752 }
2753 /* 64 kb boundaries */
2754 if (CROSS_64KB(current_req->buffer, max_size << 9))
2755 max_size = (K_64 -
2756 ((unsigned long)current_req->buffer) %
2757 K_64) >> 9;
2758 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2759 /*
2760 * We try to read tracks, but if we get too many errors, we
2761 * go back to reading just one sector at a time.
2762 *
2763 * This means we should be able to read a sector even if there
2764 * are other bad sectors on this track.
2765 */
2766 if (!direct ||
2767 (indirect * 2 > direct * 3 &&
2768 *errors < DP->max_errors.read_track && ((!probing
2769 || (DP->read_track & (1 << DRS->probed_format)))))) {
2770 max_size = current_req->nr_sectors;
2771 } else {
2772 raw_cmd->kernel_data = current_req->buffer;
2773 raw_cmd->length = current_count_sectors << 9;
2774 if (raw_cmd->length == 0) {
2775 DPRINT
2776 ("zero dma transfer attempted from make_raw_request\n");
2777 DPRINT("indirect=%d direct=%d fsector_t=%d",
2778 indirect, direct, fsector_t);
2779 return 0;
2780 }
2781 virtualdmabug_workaround();
2782 return 2;
2783 }
2784 }
2785
2786 if (CT(COMMAND) == FD_READ)
2787 max_size = max_sector; /* unbounded */
2788
2789 /* claim buffer track if needed */
2790 if (buffer_track != raw_cmd->track || /* bad track */
2791 buffer_drive != current_drive || /* bad drive */
2792 fsector_t > buffer_max ||
2793 fsector_t < buffer_min ||
2794 ((CT(COMMAND) == FD_READ ||
2795 (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
2796 max_sector > 2 * max_buffer_sectors + buffer_min &&
2797 max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
2798 /* not enough space */
2799 ) {
2800 buffer_track = -1;
2801 buffer_drive = current_drive;
2802 buffer_max = buffer_min = aligned_sector_t;
2803 }
2804 raw_cmd->kernel_data = floppy_track_buffer +
2805 ((aligned_sector_t - buffer_min) << 9);
2806
2807 if (CT(COMMAND) == FD_WRITE) {
2808 /* copy write buffer to track buffer.
2809 * if we get here, we know that the write
2810 * is either aligned or the data already in the buffer
2811 * (buffer will be overwritten) */
2812 #ifdef FLOPPY_SANITY_CHECK
2813 if (in_sector_offset && buffer_track == -1)
2814 DPRINT("internal error offset !=0 on write\n");
2815 #endif
2816 buffer_track = raw_cmd->track;
2817 buffer_drive = current_drive;
2818 copy_buffer(ssize, max_sector,
2819 2 * max_buffer_sectors + buffer_min);
2820 } else
2821 transfer_size(ssize, max_sector,
2822 2 * max_buffer_sectors + buffer_min -
2823 aligned_sector_t);
2824
2825 /* round up current_count_sectors to get dma xfer size */
2826 raw_cmd->length = in_sector_offset + current_count_sectors;
2827 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2828 raw_cmd->length <<= 9;
2829 #ifdef FLOPPY_SANITY_CHECK
2830 if ((raw_cmd->length < current_count_sectors << 9) ||
2831 (raw_cmd->kernel_data != current_req->buffer &&
2832 CT(COMMAND) == FD_WRITE &&
2833 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2834 aligned_sector_t < buffer_min)) ||
2835 raw_cmd->length % (128 << SIZECODE) ||
2836 raw_cmd->length <= 0 || current_count_sectors <= 0) {
2837 DPRINT("fractionary current count b=%lx s=%lx\n",
2838 raw_cmd->length, current_count_sectors);
2839 if (raw_cmd->kernel_data != current_req->buffer)
2840 printk("addr=%d, length=%ld\n",
2841 (int)((raw_cmd->kernel_data -
2842 floppy_track_buffer) >> 9),
2843 current_count_sectors);
2844 printk("st=%d ast=%d mse=%d msi=%d\n",
2845 fsector_t, aligned_sector_t, max_sector, max_size);
2846 printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2847 printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2848 COMMAND, SECTOR, HEAD, TRACK);
2849 printk("buffer drive=%d\n", buffer_drive);
2850 printk("buffer track=%d\n", buffer_track);
2851 printk("buffer_min=%d\n", buffer_min);
2852 printk("buffer_max=%d\n", buffer_max);
2853 return 0;
2854 }
2855
2856 if (raw_cmd->kernel_data != current_req->buffer) {
2857 if (raw_cmd->kernel_data < floppy_track_buffer ||
2858 current_count_sectors < 0 ||
2859 raw_cmd->length < 0 ||
2860 raw_cmd->kernel_data + raw_cmd->length >
2861 floppy_track_buffer + (max_buffer_sectors << 10)) {
2862 DPRINT("buffer overrun in schedule dma\n");
2863 printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
2864 fsector_t, buffer_min, raw_cmd->length >> 9);
2865 printk("current_count_sectors=%ld\n",
2866 current_count_sectors);
2867 if (CT(COMMAND) == FD_READ)
2868 printk("read\n");
2869 if (CT(COMMAND) == FD_WRITE)
2870 printk("write\n");
2871 return 0;
2872 }
2873 } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
2874 current_count_sectors > current_req->nr_sectors) {
2875 DPRINT("buffer overrun in direct transfer\n");
2876 return 0;
2877 } else if (raw_cmd->length < current_count_sectors << 9) {
2878 DPRINT("more sectors than bytes\n");
2879 printk("bytes=%ld\n", raw_cmd->length >> 9);
2880 printk("sectors=%ld\n", current_count_sectors);
2881 }
2882 if (raw_cmd->length == 0) {
2883 DPRINT("zero dma transfer attempted from make_raw_request\n");
2884 return 0;
2885 }
2886 #endif
2887
2888 virtualdmabug_workaround();
2889 return 2;
2890 }
2891
2892 static void redo_fd_request(void)
2893 {
2894 #define REPEAT {request_done(0); continue; }
2895 int drive;
2896 int tmp;
2897
2898 lastredo = jiffies;
2899 if (current_drive < N_DRIVE)
2900 floppy_off(current_drive);
2901
2902 for (;;) {
2903 if (!current_req) {
2904 struct request *req;
2905
2906 spin_lock_irq(floppy_queue->queue_lock);
2907 req = elv_next_request(floppy_queue);
2908 spin_unlock_irq(floppy_queue->queue_lock);
2909 if (!req) {
2910 do_floppy = NULL;
2911 unlock_fdc();
2912 return;
2913 }
2914 current_req = req;
2915 }
2916 drive = (long)current_req->rq_disk->private_data;
2917 set_fdc(drive);
2918 reschedule_timeout(current_reqD, "redo fd request", 0);
2919
2920 set_floppy(drive);
2921 raw_cmd = &default_raw_cmd;
2922 raw_cmd->flags = 0;
2923 if (start_motor(redo_fd_request))
2924 return;
2925 disk_change(current_drive);
2926 if (test_bit(current_drive, &fake_change) ||
2927 TESTF(FD_DISK_CHANGED)) {
2928 DPRINT("disk absent or changed during operation\n");
2929 REPEAT;
2930 }
2931 if (!_floppy) { /* Autodetection */
2932 if (!probing) {
2933 DRS->probed_format = 0;
2934 if (next_valid_format()) {
2935 DPRINT("no autodetectable formats\n");
2936 _floppy = NULL;
2937 REPEAT;
2938 }
2939 }
2940 probing = 1;
2941 _floppy =
2942 floppy_type + DP->autodetect[DRS->probed_format];
2943 } else
2944 probing = 0;
2945 errors = &(current_req->errors);
2946 tmp = make_raw_rw_request();
2947 if (tmp < 2) {
2948 request_done(tmp);
2949 continue;
2950 }
2951
2952 if (TESTF(FD_NEED_TWADDLE))
2953 twaddle();
2954 schedule_bh(floppy_start);
2955 debugt("queue fd request");
2956 return;
2957 }
2958 #undef REPEAT
2959 }
2960
2961 static struct cont_t rw_cont = {
2962 .interrupt = rw_interrupt,
2963 .redo = redo_fd_request,
2964 .error = bad_flp_intr,
2965 .done = request_done
2966 };
2967
2968 static void process_fd_request(void)
2969 {
2970 cont = &rw_cont;
2971 schedule_bh(redo_fd_request);
2972 }
2973
2974 static void do_fd_request(struct request_queue * q)
2975 {
2976 if (max_buffer_sectors == 0) {
2977 printk("VFS: do_fd_request called on non-open device\n");
2978 return;
2979 }
2980
2981 if (usage_count == 0) {
2982 printk("warning: usage count=0, current_req=%p exiting\n",
2983 current_req);
2984 printk("sect=%ld type=%x flags=%x\n", (long)current_req->sector,
2985 current_req->cmd_type, current_req->cmd_flags);
2986 return;
2987 }
2988 if (test_bit(0, &fdc_busy)) {
2989 /* fdc busy, this new request will be treated when the
2990 current one is done */
2991 is_alive("do fd request, old request running");
2992 return;
2993 }
2994 lock_fdc(MAXTIMEOUT, 0);
2995 process_fd_request();
2996 is_alive("do fd request");
2997 }
2998
2999 static struct cont_t poll_cont = {
3000 .interrupt = success_and_wakeup,
3001 .redo = floppy_ready,
3002 .error = generic_failure,
3003 .done = generic_done
3004 };
3005
3006 static int poll_drive(int interruptible, int flag)
3007 {
3008 int ret;
3009
3010 /* no auto-sense, just clear dcl */
3011 raw_cmd = &default_raw_cmd;
3012 raw_cmd->flags = flag;
3013 raw_cmd->track = 0;
3014 raw_cmd->cmd_count = 0;
3015 cont = &poll_cont;
3016 #ifdef DCL_DEBUG
3017 if (DP->flags & FD_DEBUG) {
3018 DPRINT("setting NEWCHANGE in poll_drive\n");
3019 }
3020 #endif
3021 SETF(FD_DISK_NEWCHANGE);
3022 WAIT(floppy_ready);
3023 return ret;
3024 }
3025
3026 /*
3027 * User triggered reset
3028 * ====================
3029 */
3030
3031 static void reset_intr(void)
3032 {
3033 printk("weird, reset interrupt called\n");
3034 }
3035
3036 static struct cont_t reset_cont = {
3037 .interrupt = reset_intr,
3038 .redo = success_and_wakeup,
3039 .error = generic_failure,
3040 .done = generic_done
3041 };
3042
3043 static int user_reset_fdc(int drive, int arg, int interruptible)
3044 {
3045 int ret;
3046
3047 ret = 0;
3048 LOCK_FDC(drive, interruptible);
3049 if (arg == FD_RESET_ALWAYS)
3050 FDCS->reset = 1;
3051 if (FDCS->reset) {
3052 cont = &reset_cont;
3053 WAIT(reset_fdc);
3054 }
3055 process_fd_request();
3056 return ret;
3057 }
3058
3059 /*
3060 * Misc Ioctl's and support
3061 * ========================
3062 */
3063 static inline int fd_copyout(void __user *param, const void *address,
3064 unsigned long size)
3065 {
3066 return copy_to_user(param, address, size) ? -EFAULT : 0;
3067 }
3068
3069 static inline int fd_copyin(void __user *param, void *address, unsigned long size)
3070 {
3071 return copy_from_user(address, param, size) ? -EFAULT : 0;
3072 }
3073
3074 #define _COPYOUT(x) (copy_to_user((void __user *)param, &(x), sizeof(x)) ? -EFAULT : 0)
3075 #define _COPYIN(x) (copy_from_user(&(x), (void __user *)param, sizeof(x)) ? -EFAULT : 0)
3076
3077 #define COPYOUT(x) ECALL(_COPYOUT(x))
3078 #define COPYIN(x) ECALL(_COPYIN(x))
3079
3080 static inline const char *drive_name(int type, int drive)
3081 {
3082 struct floppy_struct *floppy;
3083
3084 if (type)
3085 floppy = floppy_type + type;
3086 else {
3087 if (UDP->native_format)
3088 floppy = floppy_type + UDP->native_format;
3089 else
3090 return "(null)";
3091 }
3092 if (floppy->name)
3093 return floppy->name;
3094 else
3095 return "(null)";
3096 }
3097
3098 /* raw commands */
3099 static void raw_cmd_done(int flag)
3100 {
3101 int i;
3102
3103 if (!flag) {
3104 raw_cmd->flags |= FD_RAW_FAILURE;
3105 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3106 } else {
3107 raw_cmd->reply_count = inr;
3108 if (raw_cmd->reply_count > MAX_REPLIES)
3109 raw_cmd->reply_count = 0;
3110 for (i = 0; i < raw_cmd->reply_count; i++)
3111 raw_cmd->reply[i] = reply_buffer[i];
3112
3113 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3114 unsigned long flags;
3115 flags = claim_dma_lock();
3116 raw_cmd->length = fd_get_dma_residue();
3117 release_dma_lock(flags);
3118 }
3119
3120 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3121 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3122 raw_cmd->flags |= FD_RAW_FAILURE;
3123
3124 if (disk_change(current_drive))
3125 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3126 else
3127 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3128 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3129 motor_off_callback(current_drive);
3130
3131 if (raw_cmd->next &&
3132 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3133 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3134 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3135 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3136 raw_cmd = raw_cmd->next;
3137 return;
3138 }
3139 }
3140 generic_done(flag);
3141 }
3142
3143 static struct cont_t raw_cmd_cont = {
3144 .interrupt = success_and_wakeup,
3145 .redo = floppy_start,
3146 .error = generic_failure,
3147 .done = raw_cmd_done
3148 };
3149
3150 static inline int raw_cmd_copyout(int cmd, char __user *param,
3151 struct floppy_raw_cmd *ptr)
3152 {
3153 int ret;
3154
3155 while (ptr) {
3156 COPYOUT(*ptr);
3157 param += sizeof(struct floppy_raw_cmd);
3158 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3159 if (ptr->length >= 0
3160 && ptr->length <= ptr->buffer_length)
3161 ECALL(fd_copyout
3162 (ptr->data, ptr->kernel_data,
3163 ptr->buffer_length - ptr->length));
3164 }
3165 ptr = ptr->next;
3166 }
3167 return 0;
3168 }
3169
3170 static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3171 {
3172 struct floppy_raw_cmd *next;
3173 struct floppy_raw_cmd *this;
3174
3175 this = *ptr;
3176 *ptr = NULL;
3177 while (this) {
3178 if (this->buffer_length) {
3179 fd_dma_mem_free((unsigned long)this->kernel_data,
3180 this->buffer_length);
3181 this->buffer_length = 0;
3182 }
3183 next = this->next;
3184 kfree(this);
3185 this = next;
3186 }
3187 }
3188
3189 static inline int raw_cmd_copyin(int cmd, char __user *param,
3190 struct floppy_raw_cmd **rcmd)
3191 {
3192 struct floppy_raw_cmd *ptr;
3193 int ret;
3194 int i;
3195
3196 *rcmd = NULL;
3197 while (1) {
3198 ptr = (struct floppy_raw_cmd *)
3199 kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3200 if (!ptr)
3201 return -ENOMEM;
3202 *rcmd = ptr;
3203 COPYIN(*ptr);
3204 ptr->next = NULL;
3205 ptr->buffer_length = 0;
3206 param += sizeof(struct floppy_raw_cmd);
3207 if (ptr->cmd_count > 33)
3208 /* the command may now also take up the space
3209 * initially intended for the reply & the
3210 * reply count. Needed for long 82078 commands
3211 * such as RESTORE, which takes ... 17 command
3212 * bytes. Murphy's law #137: When you reserve
3213 * 16 bytes for a structure, you'll one day
3214 * discover that you really need 17...
3215 */
3216 return -EINVAL;
3217
3218 for (i = 0; i < 16; i++)
3219 ptr->reply[i] = 0;
3220 ptr->resultcode = 0;
3221 ptr->kernel_data = NULL;
3222
3223 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3224 if (ptr->length <= 0)
3225 return -EINVAL;
3226 ptr->kernel_data =
3227 (char *)fd_dma_mem_alloc(ptr->length);
3228 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3229 if (!ptr->kernel_data)
3230 return -ENOMEM;
3231 ptr->buffer_length = ptr->length;
3232 }
3233 if (ptr->flags & FD_RAW_WRITE)
3234 ECALL(fd_copyin(ptr->data, ptr->kernel_data,
3235 ptr->length));
3236 rcmd = &(ptr->next);
3237 if (!(ptr->flags & FD_RAW_MORE))
3238 return 0;
3239 ptr->rate &= 0x43;
3240 }
3241 }
3242
3243 static int raw_cmd_ioctl(int cmd, void __user *param)
3244 {
3245 struct floppy_raw_cmd *my_raw_cmd;
3246 int drive;
3247 int ret2;
3248 int ret;
3249
3250 if (FDCS->rawcmd <= 1)
3251 FDCS->rawcmd = 1;
3252 for (drive = 0; drive < N_DRIVE; drive++) {
3253 if (FDC(drive) != fdc)
3254 continue;
3255 if (drive == current_drive) {
3256 if (UDRS->fd_ref > 1) {
3257 FDCS->rawcmd = 2;
3258 break;
3259 }
3260 } else if (UDRS->fd_ref) {
3261 FDCS->rawcmd = 2;
3262 break;
3263 }
3264 }
3265
3266 if (FDCS->reset)
3267 return -EIO;
3268
3269 ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3270 if (ret) {
3271 raw_cmd_free(&my_raw_cmd);
3272 return ret;
3273 }
3274
3275 raw_cmd = my_raw_cmd;
3276 cont = &raw_cmd_cont;
3277 ret = wait_til_done(floppy_start, 1);
3278 #ifdef DCL_DEBUG
3279 if (DP->flags & FD_DEBUG) {
3280 DPRINT("calling disk change from raw_cmd ioctl\n");
3281 }
3282 #endif
3283
3284 if (ret != -EINTR && FDCS->reset)
3285 ret = -EIO;
3286
3287 DRS->track = NO_TRACK;
3288
3289 ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3290 if (!ret)
3291 ret = ret2;
3292 raw_cmd_free(&my_raw_cmd);
3293 return ret;
3294 }
3295
3296 static int invalidate_drive(struct block_device *bdev)
3297 {
3298 /* invalidate the buffer track to force a reread */
3299 set_bit((long)bdev->bd_disk->private_data, &fake_change);
3300 process_fd_request();
3301 check_disk_change(bdev);
3302 return 0;
3303 }
3304
3305 static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
3306 int drive, int type, struct block_device *bdev)
3307 {
3308 int cnt;
3309
3310 /* sanity checking for parameters. */
3311 if (g->sect <= 0 ||
3312 g->head <= 0 ||
3313 g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3314 /* check if reserved bits are set */
3315 (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_ZEROBASED)) != 0)
3316 return -EINVAL;
3317 if (type) {
3318 if (!capable(CAP_SYS_ADMIN))
3319 return -EPERM;
3320 mutex_lock(&open_lock);
3321 LOCK_FDC(drive, 1);
3322 floppy_type[type] = *g;
3323 floppy_type[type].name = "user format";
3324 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3325 floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3326 floppy_type[type].size + 1;
3327 process_fd_request();
3328 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3329 struct block_device *bdev = opened_bdev[cnt];
3330 if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3331 continue;
3332 __invalidate_device(bdev);
3333 }
3334 mutex_unlock(&open_lock);
3335 } else {
3336 int oldStretch;
3337 LOCK_FDC(drive, 1);
3338 if (cmd != FDDEFPRM)
3339 /* notice a disk change immediately, else
3340 * we lose our settings immediately*/
3341 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3342 oldStretch = g->stretch;
3343 user_params[drive] = *g;
3344 if (buffer_drive == drive)
3345 SUPBOUND(buffer_max, user_params[drive].sect);
3346 current_type[drive] = &user_params[drive];
3347 floppy_sizes[drive] = user_params[drive].size;
3348 if (cmd == FDDEFPRM)
3349 DRS->keep_data = -1;
3350 else
3351 DRS->keep_data = 1;
3352 /* invalidation. Invalidate only when needed, i.e.
3353 * when there are already sectors in the buffer cache
3354 * whose number will change. This is useful, because
3355 * mtools often changes the geometry of the disk after
3356 * looking at the boot block */
3357 if (DRS->maxblock > user_params[drive].sect ||
3358 DRS->maxtrack ||
3359 ((user_params[drive].sect ^ oldStretch) &
3360 (FD_SWAPSIDES | FD_ZEROBASED)))
3361 invalidate_drive(bdev);
3362 else
3363 process_fd_request();
3364 }
3365 return 0;
3366 }
3367
3368 /* handle obsolete ioctl's */
3369 static int ioctl_table[] = {
3370 FDCLRPRM,
3371 FDSETPRM,
3372 FDDEFPRM,
3373 FDGETPRM,
3374 FDMSGON,
3375 FDMSGOFF,
3376 FDFMTBEG,
3377 FDFMTTRK,
3378 FDFMTEND,
3379 FDSETEMSGTRESH,
3380 FDFLUSH,
3381 FDSETMAXERRS,
3382 FDGETMAXERRS,
3383 FDGETDRVTYP,
3384 FDSETDRVPRM,
3385 FDGETDRVPRM,
3386 FDGETDRVSTAT,
3387 FDPOLLDRVSTAT,
3388 FDRESET,
3389 FDGETFDCSTAT,
3390 FDWERRORCLR,
3391 FDWERRORGET,
3392 FDRAWCMD,
3393 FDEJECT,
3394 FDTWADDLE
3395 };
3396
3397 static inline int normalize_ioctl(int *cmd, int *size)
3398 {
3399 int i;
3400
3401 for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3402 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3403 *size = _IOC_SIZE(*cmd);
3404 *cmd = ioctl_table[i];
3405 if (*size > _IOC_SIZE(*cmd)) {
3406 printk("ioctl not yet supported\n");
3407 return -EFAULT;
3408 }
3409 return 0;
3410 }
3411 }
3412 return -EINVAL;
3413 }
3414
3415 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3416 {
3417 if (type)
3418 *g = &floppy_type[type];
3419 else {
3420 LOCK_FDC(drive, 0);
3421 CALL(poll_drive(0, 0));
3422 process_fd_request();
3423 *g = current_type[drive];
3424 }
3425 if (!*g)
3426 return -ENODEV;
3427 return 0;
3428 }
3429
3430 static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3431 {
3432 int drive = (long)bdev->bd_disk->private_data;
3433 int type = ITYPE(drive_state[drive].fd_device);
3434 struct floppy_struct *g;
3435 int ret;
3436
3437 ret = get_floppy_geometry(drive, type, &g);
3438 if (ret)
3439 return ret;
3440
3441 geo->heads = g->head;
3442 geo->sectors = g->sect;
3443 geo->cylinders = g->track;
3444 return 0;
3445 }
3446
3447 static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
3448 unsigned long param)
3449 {
3450 #define FD_IOCTL_ALLOWED ((filp) && (filp)->private_data)
3451 #define OUT(c,x) case c: outparam = (const char *) (x); break
3452 #define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
3453
3454 int drive = (long)inode->i_bdev->bd_disk->private_data;
3455 int type = ITYPE(UDRS->fd_device);
3456 int i;
3457 int ret;
3458 int size;
3459 union inparam {
3460 struct floppy_struct g; /* geometry */
3461 struct format_descr f;
3462 struct floppy_max_errors max_errors;
3463 struct floppy_drive_params dp;
3464 } inparam; /* parameters coming from user space */
3465 const char *outparam; /* parameters passed back to user space */
3466
3467 /* convert compatibility eject ioctls into floppy eject ioctl.
3468 * We do this in order to provide a means to eject floppy disks before
3469 * installing the new fdutils package */
3470 if (cmd == CDROMEJECT || /* CD-ROM eject */
3471 cmd == 0x6470 /* SunOS floppy eject */ ) {
3472 DPRINT("obsolete eject ioctl\n");
3473 DPRINT("please use floppycontrol --eject\n");
3474 cmd = FDEJECT;
3475 }
3476
3477 /* convert the old style command into a new style command */
3478 if ((cmd & 0xff00) == 0x0200) {
3479 ECALL(normalize_ioctl(&cmd, &size));
3480 } else
3481 return -EINVAL;
3482
3483 /* permission checks */
3484 if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
3485 ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3486 return -EPERM;
3487
3488 /* copyin */
3489 CLEARSTRUCT(&inparam);
3490 if (_IOC_DIR(cmd) & _IOC_WRITE)
3491 ECALL(fd_copyin((void __user *)param, &inparam, size))
3492
3493 switch (cmd) {
3494 case FDEJECT:
3495 if (UDRS->fd_ref != 1)
3496 /* somebody else has this drive open */
3497 return -EBUSY;
3498 LOCK_FDC(drive, 1);
3499
3500 /* do the actual eject. Fails on
3501 * non-Sparc architectures */
3502 ret = fd_eject(UNIT(drive));
3503
3504 USETF(FD_DISK_CHANGED);
3505 USETF(FD_VERIFY);
3506 process_fd_request();
3507 return ret;
3508 case FDCLRPRM:
3509 LOCK_FDC(drive, 1);
3510 current_type[drive] = NULL;
3511 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3512 UDRS->keep_data = 0;
3513 return invalidate_drive(inode->i_bdev);
3514 case FDSETPRM:
3515 case FDDEFPRM:
3516 return set_geometry(cmd, &inparam.g,
3517 drive, type, inode->i_bdev);
3518 case FDGETPRM:
3519 ECALL(get_floppy_geometry(drive, type,
3520 (struct floppy_struct **)
3521 &outparam));
3522 break;
3523
3524 case FDMSGON:
3525 UDP->flags |= FTD_MSG;
3526 return 0;
3527 case FDMSGOFF:
3528 UDP->flags &= ~FTD_MSG;
3529 return 0;
3530
3531 case FDFMTBEG:
3532 LOCK_FDC(drive, 1);
3533 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3534 ret = UDRS->flags;
3535 process_fd_request();
3536 if (ret & FD_VERIFY)
3537 return -ENODEV;
3538 if (!(ret & FD_DISK_WRITABLE))
3539 return -EROFS;
3540 return 0;
3541 case FDFMTTRK:
3542 if (UDRS->fd_ref != 1)
3543 return -EBUSY;
3544 return do_format(drive, &inparam.f);
3545 case FDFMTEND:
3546 case FDFLUSH:
3547 LOCK_FDC(drive, 1);
3548 return invalidate_drive(inode->i_bdev);
3549
3550 case FDSETEMSGTRESH:
3551 UDP->max_errors.reporting =
3552 (unsigned short)(param & 0x0f);
3553 return 0;
3554 OUT(FDGETMAXERRS, &UDP->max_errors);
3555 IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
3556
3557 case FDGETDRVTYP:
3558 outparam = drive_name(type, drive);
3559 SUPBOUND(size, strlen(outparam) + 1);
3560 break;
3561
3562 IN(FDSETDRVPRM, UDP, dp);
3563 OUT(FDGETDRVPRM, UDP);
3564
3565 case FDPOLLDRVSTAT:
3566 LOCK_FDC(drive, 1);
3567 CALL(poll_drive(1, FD_RAW_NEED_DISK));
3568 process_fd_request();
3569 /* fall through */
3570 OUT(FDGETDRVSTAT, UDRS);
3571
3572 case FDRESET:
3573 return user_reset_fdc(drive, (int)param, 1);
3574
3575 OUT(FDGETFDCSTAT, UFDCS);
3576
3577 case FDWERRORCLR:
3578 CLEARSTRUCT(UDRWE);
3579 return 0;
3580 OUT(FDWERRORGET, UDRWE);
3581
3582 case FDRAWCMD:
3583 if (type)
3584 return -EINVAL;
3585 LOCK_FDC(drive, 1);
3586 set_floppy(drive);
3587 CALL(i = raw_cmd_ioctl(cmd, (void __user *)param));
3588 process_fd_request();
3589 return i;
3590
3591 case FDTWADDLE:
3592 LOCK_FDC(drive, 1);
3593 twaddle();
3594 process_fd_request();
3595 return 0;
3596
3597 default:
3598 return -EINVAL;
3599 }
3600
3601 if (_IOC_DIR(cmd) & _IOC_READ)
3602 return fd_copyout((void __user *)param, outparam, size);
3603 else
3604 return 0;
3605 #undef OUT
3606 #undef IN
3607 }
3608
3609 static void __init config_types(void)
3610 {
3611 int first = 1;
3612 int drive;
3613
3614 /* read drive info out of physical CMOS */
3615 drive = 0;
3616 if (!UDP->cmos)
3617 UDP->cmos = FLOPPY0_TYPE;
3618 drive = 1;
3619 if (!UDP->cmos && FLOPPY1_TYPE)
3620 UDP->cmos = FLOPPY1_TYPE;
3621
3622 /* FIXME: additional physical CMOS drive detection should go here */
3623
3624 for (drive = 0; drive < N_DRIVE; drive++) {
3625 unsigned int type = UDP->cmos;
3626 struct floppy_drive_params *params;
3627 const char *name = NULL;
3628 static char temparea[32];
3629
3630 if (type < ARRAY_SIZE(default_drive_params)) {
3631 params = &default_drive_params[type].params;
3632 if (type) {
3633 name = default_drive_params[type].name;
3634 allowed_drive_mask |= 1 << drive;
3635 } else
3636 allowed_drive_mask &= ~(1 << drive);
3637 } else {
3638 params = &default_drive_params[0].params;
3639 sprintf(temparea, "unknown type %d (usb?)", type);
3640 name = temparea;
3641 }
3642 if (name) {
3643 const char *prepend = ",";
3644 if (first) {
3645 prepend = KERN_INFO "Floppy drive(s):";
3646 first = 0;
3647 }
3648 printk("%s fd%d is %s", prepend, drive, name);
3649 }
3650 *UDP = *params;
3651 }
3652 if (!first)
3653 printk("\n");
3654 }
3655
3656 static int floppy_release(struct inode *inode, struct file *filp)
3657 {
3658 int drive = (long)inode->i_bdev->bd_disk->private_data;
3659
3660 mutex_lock(&open_lock);
3661 if (UDRS->fd_ref < 0)
3662 UDRS->fd_ref = 0;
3663 else if (!UDRS->fd_ref--) {
3664 DPRINT("floppy_release with fd_ref == 0");
3665 UDRS->fd_ref = 0;
3666 }
3667 if (!UDRS->fd_ref)
3668 opened_bdev[drive] = NULL;
3669 mutex_unlock(&open_lock);
3670
3671 return 0;
3672 }
3673
3674 /*
3675 * floppy_open check for aliasing (/dev/fd0 can be the same as
3676 * /dev/PS0 etc), and disallows simultaneous access to the same
3677 * drive with different device numbers.
3678 */
3679 static int floppy_open(struct inode *inode, struct file *filp)
3680 {
3681 int drive = (long)inode->i_bdev->bd_disk->private_data;
3682 int old_dev;
3683 int try;
3684 int res = -EBUSY;
3685 char *tmp;
3686
3687 filp->private_data = (void *)0;
3688 mutex_lock(&open_lock);
3689 old_dev = UDRS->fd_device;
3690 if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
3691 goto out2;
3692
3693 if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
3694 USETF(FD_DISK_CHANGED);
3695 USETF(FD_VERIFY);
3696 }
3697
3698 if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
3699 goto out2;
3700
3701 if (filp->f_flags & O_EXCL)
3702 UDRS->fd_ref = -1;
3703 else
3704 UDRS->fd_ref++;
3705
3706 opened_bdev[drive] = inode->i_bdev;
3707
3708 res = -ENXIO;
3709
3710 if (!floppy_track_buffer) {
3711 /* if opening an ED drive, reserve a big buffer,
3712 * else reserve a small one */
3713 if ((UDP->cmos == 6) || (UDP->cmos == 5))
3714 try = 64; /* Only 48 actually useful */
3715 else
3716 try = 32; /* Only 24 actually useful */
3717
3718 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3719 if (!tmp && !floppy_track_buffer) {
3720 try >>= 1; /* buffer only one side */
3721 INFBOUND(try, 16);
3722 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3723 }
3724 if (!tmp && !floppy_track_buffer) {
3725 fallback_on_nodma_alloc(&tmp, 2048 * try);
3726 }
3727 if (!tmp && !floppy_track_buffer) {
3728 DPRINT("Unable to allocate DMA memory\n");
3729 goto out;
3730 }
3731 if (floppy_track_buffer) {
3732 if (tmp)
3733 fd_dma_mem_free((unsigned long)tmp, try * 1024);
3734 } else {
3735 buffer_min = buffer_max = -1;
3736 floppy_track_buffer = tmp;
3737 max_buffer_sectors = try;
3738 }
3739 }
3740
3741 UDRS->fd_device = iminor(inode);
3742 set_capacity(disks[drive], floppy_sizes[iminor(inode)]);
3743 if (old_dev != -1 && old_dev != iminor(inode)) {
3744 if (buffer_drive == drive)
3745 buffer_track = -1;
3746 }
3747
3748 /* Allow ioctls if we have write-permissions even if read-only open.
3749 * Needed so that programs such as fdrawcmd still can work on write
3750 * protected disks */
3751 if ((filp->f_mode & FMODE_WRITE) || !file_permission(filp, MAY_WRITE))
3752 filp->private_data = (void *)8;
3753
3754 if (UFDCS->rawcmd == 1)
3755 UFDCS->rawcmd = 2;
3756
3757 if (!(filp->f_flags & O_NDELAY)) {
3758 if (filp->f_mode & 3) {
3759 UDRS->last_checked = 0;
3760 check_disk_change(inode->i_bdev);
3761 if (UTESTF(FD_DISK_CHANGED))
3762 goto out;
3763 }
3764 res = -EROFS;
3765 if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
3766 goto out;
3767 }
3768 mutex_unlock(&open_lock);
3769 return 0;
3770 out:
3771 if (UDRS->fd_ref < 0)
3772 UDRS->fd_ref = 0;
3773 else
3774 UDRS->fd_ref--;
3775 if (!UDRS->fd_ref)
3776 opened_bdev[drive] = NULL;
3777 out2:
3778 mutex_unlock(&open_lock);
3779 return res;
3780 }
3781
3782 /*
3783 * Check if the disk has been changed or if a change has been faked.
3784 */
3785 static int check_floppy_change(struct gendisk *disk)
3786 {
3787 int drive = (long)disk->private_data;
3788
3789 if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
3790 return 1;
3791
3792 if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
3793 lock_fdc(drive, 0);
3794 poll_drive(0, 0);
3795 process_fd_request();
3796 }
3797
3798 if (UTESTF(FD_DISK_CHANGED) ||
3799 UTESTF(FD_VERIFY) ||
3800 test_bit(drive, &fake_change) ||
3801 (!ITYPE(UDRS->fd_device) && !current_type[drive]))
3802 return 1;
3803 return 0;
3804 }
3805
3806 /*
3807 * This implements "read block 0" for floppy_revalidate().
3808 * Needed for format autodetection, checking whether there is
3809 * a disk in the drive, and whether that disk is writable.
3810 */
3811
3812 static void floppy_rb0_complete(struct bio *bio,
3813 int err)
3814 {
3815 complete((struct completion *)bio->bi_private);
3816 }
3817
3818 static int __floppy_read_block_0(struct block_device *bdev)
3819 {
3820 struct bio bio;
3821 struct bio_vec bio_vec;
3822 struct completion complete;
3823 struct page *page;
3824 size_t size;
3825
3826 page = alloc_page(GFP_NOIO);
3827 if (!page) {
3828 process_fd_request();
3829 return -ENOMEM;
3830 }
3831
3832 size = bdev->bd_block_size;
3833 if (!size)
3834 size = 1024;
3835
3836 bio_init(&bio);
3837 bio.bi_io_vec = &bio_vec;
3838 bio_vec.bv_page = page;
3839 bio_vec.bv_len = size;
3840 bio_vec.bv_offset = 0;
3841 bio.bi_vcnt = 1;
3842 bio.bi_idx = 0;
3843 bio.bi_size = size;
3844 bio.bi_bdev = bdev;
3845 bio.bi_sector = 0;
3846 init_completion(&complete);
3847 bio.bi_private = &complete;
3848 bio.bi_end_io = floppy_rb0_complete;
3849
3850 submit_bio(READ, &bio);
3851 generic_unplug_device(bdev_get_queue(bdev));
3852 process_fd_request();
3853 wait_for_completion(&complete);
3854
3855 __free_page(page);
3856
3857 return 0;
3858 }
3859
3860 /* revalidate the floppy disk, i.e. trigger format autodetection by reading
3861 * the bootblock (block 0). "Autodetection" is also needed to check whether
3862 * there is a disk in the drive at all... Thus we also do it for fixed
3863 * geometry formats */
3864 static int floppy_revalidate(struct gendisk *disk)
3865 {
3866 int drive = (long)disk->private_data;
3867 #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
3868 int cf;
3869 int res = 0;
3870
3871 if (UTESTF(FD_DISK_CHANGED) ||
3872 UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
3873 if (usage_count == 0) {
3874 printk("VFS: revalidate called on non-open device.\n");
3875 return -EFAULT;
3876 }
3877 lock_fdc(drive, 0);
3878 cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
3879 if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
3880 process_fd_request(); /*already done by another thread */
3881 return 0;
3882 }
3883 UDRS->maxblock = 0;
3884 UDRS->maxtrack = 0;
3885 if (buffer_drive == drive)
3886 buffer_track = -1;
3887 clear_bit(drive, &fake_change);
3888 UCLEARF(FD_DISK_CHANGED);
3889 if (cf)
3890 UDRS->generation++;
3891 if (NO_GEOM) {
3892 /* auto-sensing */
3893 res = __floppy_read_block_0(opened_bdev[drive]);
3894 } else {
3895 if (cf)
3896 poll_drive(0, FD_RAW_NEED_DISK);
3897 process_fd_request();
3898 }
3899 }
3900 set_capacity(disk, floppy_sizes[UDRS->fd_device]);
3901 return res;
3902 }
3903
3904 static struct block_device_operations floppy_fops = {
3905 .owner = THIS_MODULE,
3906 .open = floppy_open,
3907 .release = floppy_release,
3908 .ioctl = fd_ioctl,
3909 .getgeo = fd_getgeo,
3910 .media_changed = check_floppy_change,
3911 .revalidate_disk = floppy_revalidate,
3912 };
3913
3914 /*
3915 * Floppy Driver initialization
3916 * =============================
3917 */
3918
3919 /* Determine the floppy disk controller type */
3920 /* This routine was written by David C. Niemi */
3921 static char __init get_fdc_version(void)
3922 {
3923 int r;
3924
3925 output_byte(FD_DUMPREGS); /* 82072 and better know DUMPREGS */
3926 if (FDCS->reset)
3927 return FDC_NONE;
3928 if ((r = result()) <= 0x00)
3929 return FDC_NONE; /* No FDC present ??? */
3930 if ((r == 1) && (reply_buffer[0] == 0x80)) {
3931 printk(KERN_INFO "FDC %d is an 8272A\n", fdc);
3932 return FDC_8272A; /* 8272a/765 don't know DUMPREGS */
3933 }
3934 if (r != 10) {
3935 printk
3936 ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
3937 fdc, r);
3938 return FDC_UNKNOWN;
3939 }
3940
3941 if (!fdc_configure()) {
3942 printk(KERN_INFO "FDC %d is an 82072\n", fdc);
3943 return FDC_82072; /* 82072 doesn't know CONFIGURE */
3944 }
3945
3946 output_byte(FD_PERPENDICULAR);
3947 if (need_more_output() == MORE_OUTPUT) {
3948 output_byte(0);
3949 } else {
3950 printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
3951 return FDC_82072A; /* 82072A as found on Sparcs. */
3952 }
3953
3954 output_byte(FD_UNLOCK);
3955 r = result();
3956 if ((r == 1) && (reply_buffer[0] == 0x80)) {
3957 printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
3958 return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know
3959 * LOCK/UNLOCK */
3960 }
3961 if ((r != 1) || (reply_buffer[0] != 0x00)) {
3962 printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
3963 fdc, r);
3964 return FDC_UNKNOWN;
3965 }
3966 output_byte(FD_PARTID);
3967 r = result();
3968 if (r != 1) {
3969 printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
3970 fdc, r);
3971 return FDC_UNKNOWN;
3972 }
3973 if (reply_buffer[0] == 0x80) {
3974 printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);
3975 return FDC_82077; /* Revised 82077AA passes all the tests */
3976 }
3977 switch (reply_buffer[0] >> 5) {
3978 case 0x0:
3979 /* Either a 82078-1 or a 82078SL running at 5Volt */
3980 printk(KERN_INFO "FDC %d is an 82078.\n", fdc);
3981 return FDC_82078;
3982 case 0x1:
3983 printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);
3984 return FDC_82078;
3985 case 0x2:
3986 printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
3987 return FDC_S82078B;
3988 case 0x3:
3989 printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",
3990 fdc);
3991 return FDC_87306;
3992 default:
3993 printk(KERN_INFO
3994 "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
3995 fdc, reply_buffer[0] >> 5);
3996 return FDC_82078_UNKN;
3997 }
3998 } /* get_fdc_version */
3999
4000 /* lilo configuration */
4001
4002 static void __init floppy_set_flags(int *ints, int param, int param2)
4003 {
4004 int i;
4005
4006 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4007 if (param)
4008 default_drive_params[i].params.flags |= param2;
4009 else
4010 default_drive_params[i].params.flags &= ~param2;
4011 }
4012 DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4013 }
4014
4015 static void __init daring(int *ints, int param, int param2)
4016 {
4017 int i;
4018
4019 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4020 if (param) {
4021 default_drive_params[i].params.select_delay = 0;
4022 default_drive_params[i].params.flags |=
4023 FD_SILENT_DCL_CLEAR;
4024 } else {
4025 default_drive_params[i].params.select_delay =
4026 2 * HZ / 100;
4027 default_drive_params[i].params.flags &=
4028 ~FD_SILENT_DCL_CLEAR;
4029 }
4030 }
4031 DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4032 }
4033
4034 static void __init set_cmos(int *ints, int dummy, int dummy2)
4035 {
4036 int current_drive = 0;
4037
4038 if (ints[0] != 2) {
4039 DPRINT("wrong number of parameters for CMOS\n");
4040 return;
4041 }
4042 current_drive = ints[1];
4043 if (current_drive < 0 || current_drive >= 8) {
4044 DPRINT("bad drive for set_cmos\n");
4045 return;
4046 }
4047 #if N_FDC > 1
4048 if (current_drive >= 4 && !FDC2)
4049 FDC2 = 0x370;
4050 #endif
4051 DP->cmos = ints[2];
4052 DPRINT("setting CMOS code to %d\n", ints[2]);
4053 }
4054
4055 static struct param_table {
4056 const char *name;
4057 void (*fn) (int *ints, int param, int param2);
4058 int *var;
4059 int def_param;
4060 int param2;
4061 } config_params[] __initdata = {
4062 {"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4063 {"all_drives", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4064 {"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
4065 {"irq", NULL, &FLOPPY_IRQ, 6, 0},
4066 {"dma", NULL, &FLOPPY_DMA, 2, 0},
4067 {"daring", daring, NULL, 1, 0},
4068 #if N_FDC > 1
4069 {"two_fdc", NULL, &FDC2, 0x370, 0},
4070 {"one_fdc", NULL, &FDC2, 0, 0},
4071 #endif
4072 {"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
4073 {"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
4074 {"messages", floppy_set_flags, NULL, 1, FTD_MSG},
4075 {"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
4076 {"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
4077 {"nodma", NULL, &can_use_virtual_dma, 1, 0},
4078 {"omnibook", NULL, &can_use_virtual_dma, 1, 0},
4079 {"yesdma", NULL, &can_use_virtual_dma, 0, 0},
4080 {"fifo_depth", NULL, &fifo_depth, 0xa, 0},
4081 {"nofifo", NULL, &no_fifo, 0x20, 0},
4082 {"usefifo", NULL, &no_fifo, 0, 0},
4083 {"cmos", set_cmos, NULL, 0, 0},
4084 {"slow", NULL, &slow_floppy, 1, 0},
4085 {"unexpected_interrupts", NULL, &print_unex, 1, 0},
4086 {"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
4087 {"L40SX", NULL, &print_unex, 0, 0}
4088
4089 EXTRA_FLOPPY_PARAMS
4090 };
4091
4092 static int __init floppy_setup(char *str)
4093 {
4094 int i;
4095 int param;
4096 int ints[11];
4097
4098 str = get_options(str, ARRAY_SIZE(ints), ints);
4099 if (str) {
4100 for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4101 if (strcmp(str, config_params[i].name) == 0) {
4102 if (ints[0])
4103 param = ints[1];
4104 else
4105 param = config_params[i].def_param;
4106 if (config_params[i].fn)
4107 config_params[i].
4108 fn(ints, param,
4109 config_params[i].param2);
4110 if (config_params[i].var) {
4111 DPRINT("%s=%d\n", str, param);
4112 *config_params[i].var = param;
4113 }
4114 return 1;
4115 }
4116 }
4117 }
4118 if (str) {
4119 DPRINT("unknown floppy option [%s]\n", str);
4120
4121 DPRINT("allowed options are:");
4122 for (i = 0; i < ARRAY_SIZE(config_params); i++)
4123 printk(" %s", config_params[i].name);
4124 printk("\n");
4125 } else
4126 DPRINT("botched floppy option\n");
4127 DPRINT("Read Documentation/floppy.txt\n");
4128 return 0;
4129 }
4130
4131 static int have_no_fdc = -ENODEV;
4132
4133 static ssize_t floppy_cmos_show(struct device *dev,
4134 struct device_attribute *attr, char *buf)
4135 {
4136 struct platform_device *p;
4137 int drive;
4138
4139 p = container_of(dev, struct platform_device,dev);
4140 drive = p->id;
4141 return sprintf(buf, "%X\n", UDP->cmos);
4142 }
4143 DEVICE_ATTR(cmos,S_IRUGO,floppy_cmos_show,NULL);
4144
4145 static void floppy_device_release(struct device *dev)
4146 {
4147 complete(&device_release);
4148 }
4149
4150 static struct platform_device floppy_device[N_DRIVE];
4151
4152 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4153 {
4154 int drive = (*part & 3) | ((*part & 0x80) >> 5);
4155 if (drive >= N_DRIVE ||
4156 !(allowed_drive_mask & (1 << drive)) ||
4157 fdc_state[FDC(drive)].version == FDC_NONE)
4158 return NULL;
4159 if (((*part >> 2) & 0x1f) >= ARRAY_SIZE(floppy_type))
4160 return NULL;
4161 *part = 0;
4162 return get_disk(disks[drive]);
4163 }
4164
4165 static int __init floppy_init(void)
4166 {
4167 int i, unit, drive;
4168 int err, dr;
4169
4170 #if defined(CONFIG_PPC_MERGE)
4171 if (check_legacy_ioport(FDC1))
4172 return -ENODEV;
4173 #endif
4174
4175 raw_cmd = NULL;
4176
4177 for (dr = 0; dr < N_DRIVE; dr++) {
4178 disks[dr] = alloc_disk(1);
4179 if (!disks[dr]) {
4180 err = -ENOMEM;
4181 goto out_put_disk;
4182 }
4183
4184 disks[dr]->major = FLOPPY_MAJOR;
4185 disks[dr]->first_minor = TOMINOR(dr);
4186 disks[dr]->fops = &floppy_fops;
4187 sprintf(disks[dr]->disk_name, "fd%d", dr);
4188
4189 init_timer(&motor_off_timer[dr]);
4190 motor_off_timer[dr].data = dr;
4191 motor_off_timer[dr].function = motor_off_callback;
4192 }
4193
4194 err = register_blkdev(FLOPPY_MAJOR, "fd");
4195 if (err)
4196 goto out_put_disk;
4197
4198 floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
4199 if (!floppy_queue) {
4200 err = -ENOMEM;
4201 goto out_unreg_blkdev;
4202 }
4203 blk_queue_max_sectors(floppy_queue, 64);
4204
4205 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4206 floppy_find, NULL, NULL);
4207
4208 for (i = 0; i < 256; i++)
4209 if (ITYPE(i))
4210 floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4211 else
4212 floppy_sizes[i] = MAX_DISK_SIZE << 1;
4213
4214 reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
4215 config_types();
4216
4217 for (i = 0; i < N_FDC; i++) {
4218 fdc = i;
4219 CLEARSTRUCT(FDCS);
4220 FDCS->dtr = -1;
4221 FDCS->dor = 0x4;
4222 #if defined(__sparc__) || defined(__mc68000__)
4223 /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
4224 #ifdef __mc68000__
4225 if (MACH_IS_SUN3X)
4226 #endif
4227 FDCS->version = FDC_82072A;
4228 #endif
4229 }
4230
4231 use_virtual_dma = can_use_virtual_dma & 1;
4232 fdc_state[0].address = FDC1;
4233 if (fdc_state[0].address == -1) {
4234 del_timer(&fd_timeout);
4235 err = -ENODEV;
4236 goto out_unreg_region;
4237 }
4238 #if N_FDC > 1
4239 fdc_state[1].address = FDC2;
4240 #endif
4241
4242 fdc = 0; /* reset fdc in case of unexpected interrupt */
4243 err = floppy_grab_irq_and_dma();
4244 if (err) {
4245 del_timer(&fd_timeout);
4246 err = -EBUSY;
4247 goto out_unreg_region;
4248 }
4249
4250 /* initialise drive state */
4251 for (drive = 0; drive < N_DRIVE; drive++) {
4252 CLEARSTRUCT(UDRS);
4253 CLEARSTRUCT(UDRWE);
4254 USETF(FD_DISK_NEWCHANGE);
4255 USETF(FD_DISK_CHANGED);
4256 USETF(FD_VERIFY);
4257 UDRS->fd_device = -1;
4258 floppy_track_buffer = NULL;
4259 max_buffer_sectors = 0;
4260 }
4261 /*
4262 * Small 10 msec delay to let through any interrupt that
4263 * initialization might have triggered, to not
4264 * confuse detection:
4265 */
4266 msleep(10);
4267
4268 for (i = 0; i < N_FDC; i++) {
4269 fdc = i;
4270 FDCS->driver_version = FD_DRIVER_VERSION;
4271 for (unit = 0; unit < 4; unit++)
4272 FDCS->track[unit] = 0;
4273 if (FDCS->address == -1)
4274 continue;
4275 FDCS->rawcmd = 2;
4276 if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
4277 /* free ioports reserved by floppy_grab_irq_and_dma() */
4278 release_region(FDCS->address + 2, 4);
4279 release_region(FDCS->address + 7, 1);
4280 FDCS->address = -1;
4281 FDCS->version = FDC_NONE;
4282 continue;
4283 }
4284 /* Try to determine the floppy controller type */
4285 FDCS->version = get_fdc_version();
4286 if (FDCS->version == FDC_NONE) {
4287 /* free ioports reserved by floppy_grab_irq_and_dma() */
4288 release_region(FDCS->address + 2, 4);
4289 release_region(FDCS->address + 7, 1);
4290 FDCS->address = -1;
4291 continue;
4292 }
4293 if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
4294 can_use_virtual_dma = 0;
4295
4296 have_no_fdc = 0;
4297 /* Not all FDCs seem to be able to handle the version command
4298 * properly, so force a reset for the standard FDC clones,
4299 * to avoid interrupt garbage.
4300 */
4301 user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
4302 }
4303 fdc = 0;
4304 del_timer(&fd_timeout);
4305 current_drive = 0;
4306 initialising = 0;
4307 if (have_no_fdc) {
4308 DPRINT("no floppy controllers found\n");
4309 err = have_no_fdc;
4310 goto out_flush_work;
4311 }
4312
4313 for (drive = 0; drive < N_DRIVE; drive++) {
4314 if (!(allowed_drive_mask & (1 << drive)))
4315 continue;
4316 if (fdc_state[FDC(drive)].version == FDC_NONE)
4317 continue;
4318
4319 floppy_device[drive].name = floppy_device_name;
4320 floppy_device[drive].id = drive;
4321 floppy_device[drive].dev.release = floppy_device_release;
4322
4323 err = platform_device_register(&floppy_device[drive]);
4324 if (err)
4325 goto out_flush_work;
4326
4327 err = device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
4328 if (err)
4329 goto out_unreg_platform_dev;
4330
4331 /* to be cleaned up... */
4332 disks[drive]->private_data = (void *)(long)drive;
4333 disks[drive]->queue = floppy_queue;
4334 disks[drive]->flags |= GENHD_FL_REMOVABLE;
4335 disks[drive]->driverfs_dev = &floppy_device[drive].dev;
4336 add_disk(disks[drive]);
4337 }
4338
4339 return 0;
4340
4341 out_unreg_platform_dev:
4342 platform_device_unregister(&floppy_device[drive]);
4343 out_flush_work:
4344 flush_scheduled_work();
4345 if (usage_count)
4346 floppy_release_irq_and_dma();
4347 out_unreg_region:
4348 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4349 blk_cleanup_queue(floppy_queue);
4350 out_unreg_blkdev:
4351 unregister_blkdev(FLOPPY_MAJOR, "fd");
4352 out_put_disk:
4353 while (dr--) {
4354 del_timer(&motor_off_timer[dr]);
4355 put_disk(disks[dr]);
4356 }
4357 return err;
4358 }
4359
4360 static DEFINE_SPINLOCK(floppy_usage_lock);
4361
4362 static int floppy_grab_irq_and_dma(void)
4363 {
4364 unsigned long flags;
4365
4366 spin_lock_irqsave(&floppy_usage_lock, flags);
4367 if (usage_count++) {
4368 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4369 return 0;
4370 }
4371 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4372
4373 /*
4374 * We might have scheduled a free_irq(), wait it to
4375 * drain first:
4376 */
4377 flush_scheduled_work();
4378
4379 if (fd_request_irq()) {
4380 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4381 FLOPPY_IRQ);
4382 spin_lock_irqsave(&floppy_usage_lock, flags);
4383 usage_count--;
4384 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4385 return -1;
4386 }
4387 if (fd_request_dma()) {
4388 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4389 FLOPPY_DMA);
4390 if (can_use_virtual_dma & 2)
4391 use_virtual_dma = can_use_virtual_dma = 1;
4392 if (!(can_use_virtual_dma & 1)) {
4393 fd_free_irq();
4394 spin_lock_irqsave(&floppy_usage_lock, flags);
4395 usage_count--;
4396 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4397 return -1;
4398 }
4399 }
4400
4401 for (fdc = 0; fdc < N_FDC; fdc++) {
4402 if (FDCS->address != -1) {
4403 if (!request_region(FDCS->address + 2, 4, "floppy")) {
4404 DPRINT("Floppy io-port 0x%04lx in use\n",
4405 FDCS->address + 2);
4406 goto cleanup1;
4407 }
4408 if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
4409 DPRINT("Floppy io-port 0x%04lx in use\n",
4410 FDCS->address + 7);
4411 goto cleanup2;
4412 }
4413 /* address + 6 is reserved, and may be taken by IDE.
4414 * Unfortunately, Adaptec doesn't know this :-(, */
4415 }
4416 }
4417 for (fdc = 0; fdc < N_FDC; fdc++) {
4418 if (FDCS->address != -1) {
4419 reset_fdc_info(1);
4420 fd_outb(FDCS->dor, FD_DOR);
4421 }
4422 }
4423 fdc = 0;
4424 set_dor(0, ~0, 8); /* avoid immediate interrupt */
4425
4426 for (fdc = 0; fdc < N_FDC; fdc++)
4427 if (FDCS->address != -1)
4428 fd_outb(FDCS->dor, FD_DOR);
4429 /*
4430 * The driver will try and free resources and relies on us
4431 * to know if they were allocated or not.
4432 */
4433 fdc = 0;
4434 irqdma_allocated = 1;
4435 return 0;
4436 cleanup2:
4437 release_region(FDCS->address + 2, 4);
4438 cleanup1:
4439 fd_free_irq();
4440 fd_free_dma();
4441 while (--fdc >= 0) {
4442 release_region(FDCS->address + 2, 4);
4443 release_region(FDCS->address + 7, 1);
4444 }
4445 spin_lock_irqsave(&floppy_usage_lock, flags);
4446 usage_count--;
4447 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4448 return -1;
4449 }
4450
4451 static void floppy_release_irq_and_dma(void)
4452 {
4453 int old_fdc;
4454 #ifdef FLOPPY_SANITY_CHECK
4455 #ifndef __sparc__
4456 int drive;
4457 #endif
4458 #endif
4459 long tmpsize;
4460 unsigned long tmpaddr;
4461 unsigned long flags;
4462
4463 spin_lock_irqsave(&floppy_usage_lock, flags);
4464 if (--usage_count) {
4465 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4466 return;
4467 }
4468 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4469 if (irqdma_allocated) {
4470 fd_disable_dma();
4471 fd_free_dma();
4472 fd_free_irq();
4473 irqdma_allocated = 0;
4474 }
4475 set_dor(0, ~0, 8);
4476 #if N_FDC > 1
4477 set_dor(1, ~8, 0);
4478 #endif
4479 floppy_enable_hlt();
4480
4481 if (floppy_track_buffer && max_buffer_sectors) {
4482 tmpsize = max_buffer_sectors * 1024;
4483 tmpaddr = (unsigned long)floppy_track_buffer;
4484 floppy_track_buffer = NULL;
4485 max_buffer_sectors = 0;
4486 buffer_min = buffer_max = -1;
4487 fd_dma_mem_free(tmpaddr, tmpsize);
4488 }
4489 #ifdef FLOPPY_SANITY_CHECK
4490 #ifndef __sparc__
4491 for (drive = 0; drive < N_FDC * 4; drive++)
4492 if (timer_pending(motor_off_timer + drive))
4493 printk("motor off timer %d still active\n", drive);
4494 #endif
4495
4496 if (timer_pending(&fd_timeout))
4497 printk("floppy timer still active:%s\n", timeout_message);
4498 if (timer_pending(&fd_timer))
4499 printk("auxiliary floppy timer still active\n");
4500 if (work_pending(&floppy_work))
4501 printk("work still pending\n");
4502 #endif
4503 old_fdc = fdc;
4504 for (fdc = 0; fdc < N_FDC; fdc++)
4505 if (FDCS->address != -1) {
4506 release_region(FDCS->address + 2, 4);
4507 release_region(FDCS->address + 7, 1);
4508 }
4509 fdc = old_fdc;
4510 }
4511
4512 #ifdef MODULE
4513
4514 static char *floppy;
4515
4516 static void __init parse_floppy_cfg_string(char *cfg)
4517 {
4518 char *ptr;
4519
4520 while (*cfg) {
4521 for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != '\t'; cfg++) ;
4522 if (*cfg) {
4523 *cfg = '\0';
4524 cfg++;
4525 }
4526 if (*ptr)
4527 floppy_setup(ptr);
4528 }
4529 }
4530
4531 int __init init_module(void)
4532 {
4533 if (floppy)
4534 parse_floppy_cfg_string(floppy);
4535 return floppy_init();
4536 }
4537
4538 void cleanup_module(void)
4539 {
4540 int drive;
4541
4542 init_completion(&device_release);
4543 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4544 unregister_blkdev(FLOPPY_MAJOR, "fd");
4545
4546 for (drive = 0; drive < N_DRIVE; drive++) {
4547 del_timer_sync(&motor_off_timer[drive]);
4548
4549 if ((allowed_drive_mask & (1 << drive)) &&
4550 fdc_state[FDC(drive)].version != FDC_NONE) {
4551 del_gendisk(disks[drive]);
4552 device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
4553 platform_device_unregister(&floppy_device[drive]);
4554 }
4555 put_disk(disks[drive]);
4556 }
4557
4558 del_timer_sync(&fd_timeout);
4559 del_timer_sync(&fd_timer);
4560 blk_cleanup_queue(floppy_queue);
4561
4562 if (usage_count)
4563 floppy_release_irq_and_dma();
4564
4565 /* eject disk, if any */
4566 fd_eject(0);
4567
4568 wait_for_completion(&device_release);
4569 }
4570
4571 module_param(floppy, charp, 0);
4572 module_param(FLOPPY_IRQ, int, 0);
4573 module_param(FLOPPY_DMA, int, 0);
4574 MODULE_AUTHOR("Alain L. Knaff");
4575 MODULE_SUPPORTED_DEVICE("fd");
4576 MODULE_LICENSE("GPL");
4577
4578 #else
4579
4580 __setup("floppy=", floppy_setup);
4581 module_init(floppy_init)
4582 #endif
4583
4584 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);
Community contributions to the Openmoko Kernel