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