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