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