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