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