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