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