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