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