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