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