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