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