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