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