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