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