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