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