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