git.oblomov.eu Git - linux-2.6/blob - drivers/block/floppy.c

   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 */
 155 static 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  */
 189 static 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
 197 static int FLOPPY_IRQ = 6;
 198 static int FLOPPY_DMA = 2;
 199 static 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
 208 static 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
 220 static DEFINE_SPINLOCK(floppy_lock);
 221 static struct completion device_release;
 222
 223 static unsigned short virtual_dma_port = 0x3f0;
 224 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 225 static 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
 239 static int allowed_drive_mask = 0x33;
 240
 241 #include <asm/floppy.h>
 242
 243 static 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
 252 static struct request *current_req;
 253 static struct request_queue *floppy_queue;
 254 static 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
 270 static 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
 287 static unsigned long fake_change;
 288 static 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
 349 static unsigned char reply_buffer[MAX_REPLIES];
 350 static 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  */
 365 static 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
 410 static struct floppy_drive_params drive_params[N_DRIVE];
 411 static struct floppy_drive_struct drive_state[N_DRIVE];
 412 static struct floppy_write_errors write_errors[N_DRIVE];
 413 static struct timer_list motor_off_timer[N_DRIVE];
 414 static struct gendisk *disks[N_DRIVE];
 415 static struct block_device *opened_bdev[N_DRIVE];
 416 static DEFINE_MUTEX(open_lock);
 417 static 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) */
 443 static 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. */
 484 static 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  */
 490 static struct floppy_struct user_params[N_DRIVE];
 491
 492 static sector_t floppy_sizes[256];
 493
 494 static 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  */
 501 static 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
 508 static volatile int command_status = FD_COMMAND_NONE;
 509 static unsigned long fdc_busy;
 510 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
 511 static 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. */
 521 static int format_errors;
 522
 523 /* Format request descriptor. */
 524 static 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  */
 538 static char *floppy_track_buffer;
 539 static int max_buffer_sectors;
 540
 541 static int *errors;
 542 typedef void (*done_f) (int);
 543 static 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
 552 static void floppy_ready(void);
 553 static void floppy_start(void);
 554 static void process_fd_request(void);
 555 static void recalibrate_floppy(void);
 556 static void floppy_shutdown(unsigned long);
 557
 558 static int floppy_grab_irq_and_dma(void);
 559 static void floppy_release_irq_and_dma(void);
 560
 561 /*
 562  * The "reset" variable should be tested whenever an interrupt is scheduled,
 563  * after the commands have been sent. This is to ensure that the driver doesn't
 564  * get wedged when the interrupt doesn't come because of a failed command.
 565  * reset doesn't need to be tested before sending commands, because
 566  * output_byte is automatically disabled when reset is set.
 567  */
 568 #define CHECK_RESET { if (FDCS->reset){ reset_fdc(); return; } }
 569 static 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
 580 static int usage_count;
 581
 582 /* buffer related variables */
 583 static int buffer_track = -1;
 584 static int buffer_drive = -1;
 585 static int buffer_min = -1;
 586 static int buffer_max = -1;
 587
 588 /* fdc related variables, should end up in a struct */
 589 static struct floppy_fdc_state fdc_state[N_FDC];
 590 static int fdc;                 /* current fdc */
 591
 592 static struct floppy_struct *_floppy = floppy_type;
 593 static unsigned char current_drive;
 594 static long current_count_sectors;
 595 static unsigned char fsector_t; /* sector in track */
 596 static unsigned char in_sector_offset;  /* offset within physical sector,
 597                                          * expressed in units of 512 bytes */
 598
 599 #ifndef fd_eject
 600 static inline int fd_eject(int drive)
 601 {
 602         return -EINVAL;
 603 }
 604 #endif
 605
 606 /*
 607  * Debugging
 608  * =========
 609  */
 610 #ifdef DEBUGT
 611 static long unsigned debugtimer;
 612
 613 static inline void set_debugt(void)
 614 {
 615         debugtimer = jiffies;
 616 }
 617
 618 static inline void debugt(const char *message)
 619 {
 620         if (DP->flags & DEBUGT)
 621                 printk("%s dtime=%lu\n", message, jiffies - debugtimer);
 622 }
 623 #else
 624 static inline void set_debugt(void) { }
 625 static inline void debugt(const char *message) { }
 626 #endif /* DEBUGT */
 627
 628 typedef void (*timeout_fn) (unsigned long);
 629 static DEFINE_TIMER(fd_timeout, floppy_shutdown, 0, 0);
 630
 631 static const char *timeout_message;
 632
 633 #ifdef FLOPPY_SANITY_CHECK
 634 static 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
 644 static void (*do_floppy) (void) = NULL;
 645
 646 #ifdef FLOPPY_SANITY_CHECK
 647
 648 #define OLOGSIZE 20
 649
 650 static void (*lasthandler) (void);
 651 static unsigned long interruptjiffies;
 652 static unsigned long resultjiffies;
 653 static int resultsize;
 654 static unsigned long lastredo;
 655
 656 static struct output_log {
 657         unsigned char data;
 658         unsigned char status;
 659         unsigned long jiffies;
 660 } output_log[OLOGSIZE];
 661
 662 static int output_log_pos;
 663 #endif
 664
 665 #define current_reqD -1
 666 #define MAXTIMEOUT -2
 667
 668 static 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
 687 static 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
 733 static 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
 783 static inline int is_selected(int dor, int unit)
 784 {
 785         return ((dor & (0x10 << unit)) && (dor & 3) == unit);
 786 }
 787
 788 static 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
 820 static void twaddle(void)
 821 {
 822         if (DP->select_delay)
 823                 return;
 824         fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
 825         fd_outb(FDCS->dor, FD_DOR);
 826         DRS->select_date = jiffies;
 827 }
 828
 829 /* reset all driver information about the current fdc. This is needed after
 830  * a reset, and after a raw command. */
 831 static 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. */
 845 static 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 */
 866 static 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) \
 908 if (lock_fdc(drive,interruptible)) return -EINTR;
 909
 910 /* unlocks the driver */
 911 static 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 */
 934 static 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 */
 942 static 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  */
 969 static 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
 991 static void empty(void)
 992 {
 993 }
 994
 995 static DECLARE_WORK(floppy_work, NULL, NULL);
 996
 997 static void schedule_bh(void (*handler) (void))
 998 {
 999         PREPARE_WORK(&floppy_work, (void (*)(void *))handler, NULL);
1000         schedule_work(&floppy_work);
1001 }
1002
1003 static DEFINE_TIMER(fd_timer, NULL, 0, 0);
1004
1005 static 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, (void *)empty, NULL);
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 */
1018 static 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
1039 static 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 */
1046 static 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
1065 static DEFINE_SPINLOCK(floppy_hlt_lock);
1066 static int hlt_disabled;
1067 static 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
1081 static 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
1095 static 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
1144 static void show_floppy(void);
1145
1146 /* waits until the fdc becomes ready */
1147 static 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 */
1166 static 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 */
1194 static 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? */
1226 static 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  */
1239 static 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
1273 static int fifo_depth = 0xa;
1274 static int no_fifo;
1275
1276 static 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  */
1310 static 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  */
1388 static 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
1407 static 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  */
1420 static 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  */
1499 static 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
1552 static int blind_seek;
1553
1554 /*
1555  * This is the routine called after every seek (or recalibrate) interrupt
1556  * from the floppy controller.
1557  */
1558 static 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
1583 static 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
1608 static 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
1667 static 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
1717 static 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 */
1729 irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
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         /* FIXME! Was it really for us? */
1787         return IRQ_HANDLED;
1788 }
1789
1790 static void recalibrate_floppy(void)
1791 {
1792         debugt("recalibrate floppy:");
1793         do_floppy = recal_interrupt;
1794         output_byte(FD_RECALIBRATE);
1795         LAST_OUT(UNIT(current_drive));
1796 }
1797
1798 /*
1799  * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1800  */
1801 static void reset_interrupt(void)
1802 {
1803         debugt("reset interrupt:");
1804         result();               /* get the status ready for set_fdc */
1805         if (FDCS->reset) {
1806                 printk("reset set in interrupt, calling %p\n", cont->error);
1807                 cont->error();  /* a reset just after a reset. BAD! */
1808         }
1809         cont->redo();
1810 }
1811
1812 /*
1813  * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1814  * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1815  */
1816 static void reset_fdc(void)
1817 {
1818         unsigned long flags;
1819
1820         do_floppy = reset_interrupt;
1821         FDCS->reset = 0;
1822         reset_fdc_info(0);
1823
1824         /* Pseudo-DMA may intercept 'reset finished' interrupt.  */
1825         /* Irrelevant for systems with true DMA (i386).          */
1826
1827         flags = claim_dma_lock();
1828         fd_disable_dma();
1829         release_dma_lock(flags);
1830
1831         if (FDCS->version >= FDC_82072A)
1832                 fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
1833         else {
1834                 fd_outb(FDCS->dor & ~0x04, FD_DOR);
1835                 udelay(FD_RESET_DELAY);
1836                 fd_outb(FDCS->dor, FD_DOR);
1837         }
1838 }
1839
1840 static void show_floppy(void)
1841 {
1842         int i;
1843
1844         printk("\n");
1845         printk("floppy driver state\n");
1846         printk("-------------------\n");
1847         printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",
1848                jiffies, interruptjiffies, jiffies - interruptjiffies,
1849                lasthandler);
1850
1851 #ifdef FLOPPY_SANITY_CHECK
1852         printk("timeout_message=%s\n", timeout_message);
1853         printk("last output bytes:\n");
1854         for (i = 0; i < OLOGSIZE; i++)
1855                 printk("%2x %2x %lu\n",
1856                        output_log[(i + output_log_pos) % OLOGSIZE].data,
1857                        output_log[(i + output_log_pos) % OLOGSIZE].status,
1858                        output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1859         printk("last result at %lu\n", resultjiffies);
1860         printk("last redo_fd_request at %lu\n", lastredo);
1861         for (i = 0; i < resultsize; i++) {
1862                 printk("%2x ", reply_buffer[i]);
1863         }
1864         printk("\n");
1865 #endif
1866
1867         printk("status=%x\n", fd_inb(FD_STATUS));
1868         printk("fdc_busy=%lu\n", fdc_busy);
1869         if (do_floppy)
1870                 printk("do_floppy=%p\n", do_floppy);
1871         if (floppy_work.pending)
1872                 printk("floppy_work.func=%p\n", floppy_work.func);
1873         if (timer_pending(&fd_timer))
1874                 printk("fd_timer.function=%p\n", fd_timer.function);
1875         if (timer_pending(&fd_timeout)) {
1876                 printk("timer_function=%p\n", fd_timeout.function);
1877                 printk("expires=%lu\n", fd_timeout.expires - jiffies);
1878                 printk("now=%lu\n", jiffies);
1879         }
1880         printk("cont=%p\n", cont);
1881         printk("current_req=%p\n", current_req);
1882         printk("command_status=%d\n", command_status);
1883         printk("\n");
1884 }
1885
1886 static void floppy_shutdown(unsigned long data)
1887 {
1888         unsigned long flags;
1889
1890         if (!initialising)
1891                 show_floppy();
1892         cancel_activity();
1893
1894         floppy_enable_hlt();
1895
1896         flags = claim_dma_lock();
1897         fd_disable_dma();
1898         release_dma_lock(flags);
1899
1900         /* avoid dma going to a random drive after shutdown */
1901
1902         if (!initialising)
1903                 DPRINT("floppy timeout called\n");
1904         FDCS->reset = 1;
1905         if (cont) {
1906                 cont->done(0);
1907                 cont->redo();   /* this will recall reset when needed */
1908         } else {
1909                 printk("no cont in shutdown!\n");
1910                 process_fd_request();
1911         }
1912         is_alive("floppy shutdown");
1913 }
1914
1915 /*typedef void (*timeout_fn)(unsigned long);*/
1916
1917 /* start motor, check media-changed condition and write protection */
1918 static int start_motor(void (*function) (void))
1919 {
1920         int mask, data;
1921
1922         mask = 0xfc;
1923         data = UNIT(current_drive);
1924         if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1925                 if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
1926                         set_debugt();
1927                         /* no read since this drive is running */
1928                         DRS->first_read_date = 0;
1929                         /* note motor start time if motor is not yet running */
1930                         DRS->spinup_date = jiffies;
1931                         data |= (0x10 << UNIT(current_drive));
1932                 }
1933         } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
1934                 mask &= ~(0x10 << UNIT(current_drive));
1935
1936         /* starts motor and selects floppy */
1937         del_timer(motor_off_timer + current_drive);
1938         set_dor(fdc, mask, data);
1939
1940         /* wait_for_completion also schedules reset if needed. */
1941         return (fd_wait_for_completion(DRS->select_date + DP->select_delay,
1942                                        (timeout_fn) function));
1943 }
1944
1945 static void floppy_ready(void)
1946 {
1947         CHECK_RESET;
1948         if (start_motor(floppy_ready))
1949                 return;
1950         if (fdc_dtr())
1951                 return;
1952
1953 #ifdef DCL_DEBUG
1954         if (DP->flags & FD_DEBUG) {
1955                 DPRINT("calling disk change from floppy_ready\n");
1956         }
1957 #endif
1958         if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1959             disk_change(current_drive) && !DP->select_delay)
1960                 twaddle();      /* this clears the dcl on certain drive/controller
1961                                  * combinations */
1962
1963 #ifdef fd_chose_dma_mode
1964         if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1965                 unsigned long flags = claim_dma_lock();
1966                 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1967                 release_dma_lock(flags);
1968         }
1969 #endif
1970
1971         if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1972                 perpendicular_mode();
1973                 fdc_specify();  /* must be done here because of hut, hlt ... */
1974                 seek_floppy();
1975         } else {
1976                 if ((raw_cmd->flags & FD_RAW_READ) ||
1977                     (raw_cmd->flags & FD_RAW_WRITE))
1978                         fdc_specify();
1979                 setup_rw_floppy();
1980         }
1981 }
1982
1983 static void floppy_start(void)
1984 {
1985         reschedule_timeout(current_reqD, "floppy start", 0);
1986
1987         scandrives();
1988 #ifdef DCL_DEBUG
1989         if (DP->flags & FD_DEBUG) {
1990                 DPRINT("setting NEWCHANGE in floppy_start\n");
1991         }
1992 #endif
1993         SETF(FD_DISK_NEWCHANGE);
1994         floppy_ready();
1995 }
1996
1997 /*
1998  * ========================================================================
1999  * here ends the bottom half. Exported routines are:
2000  * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
2001  * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
2002  * Initialization also uses output_byte, result, set_dor, floppy_interrupt
2003  * and set_dor.
2004  * ========================================================================
2005  */
2006 /*
2007  * General purpose continuations.
2008  * ==============================
2009  */
2010
2011 static void do_wakeup(void)
2012 {
2013         reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
2014         cont = NULL;
2015         command_status += 2;
2016         wake_up(&command_done);
2017 }
2018
2019 static struct cont_t wakeup_cont = {
2020         .interrupt      = empty,
2021         .redo           = do_wakeup,
2022         .error          = empty,
2023         .done           = (done_f) empty
2024 };
2025
2026 static struct cont_t intr_cont = {
2027         .interrupt      = empty,
2028         .redo           = process_fd_request,
2029         .error          = empty,
2030         .done           = (done_f) empty
2031 };
2032
2033 static int wait_til_done(void (*handler) (void), int interruptible)
2034 {
2035         int ret;
2036
2037         schedule_bh(handler);
2038
2039         if (command_status < 2 && NO_SIGNAL) {
2040                 DECLARE_WAITQUEUE(wait, current);
2041
2042                 add_wait_queue(&command_done, &wait);
2043                 for (;;) {
2044                         set_current_state(interruptible ?
2045                                           TASK_INTERRUPTIBLE :
2046                                           TASK_UNINTERRUPTIBLE);
2047
2048                         if (command_status >= 2 || !NO_SIGNAL)
2049                                 break;
2050
2051                         is_alive("wait_til_done");
2052
2053                         schedule();
2054                 }
2055
2056                 set_current_state(TASK_RUNNING);
2057                 remove_wait_queue(&command_done, &wait);
2058         }
2059
2060         if (command_status < 2) {
2061                 cancel_activity();
2062                 cont = &intr_cont;
2063                 reset_fdc();
2064                 return -EINTR;
2065         }
2066
2067         if (FDCS->reset)
2068                 command_status = FD_COMMAND_ERROR;
2069         if (command_status == FD_COMMAND_OKAY)
2070                 ret = 0;
2071         else
2072                 ret = -EIO;
2073         command_status = FD_COMMAND_NONE;
2074         return ret;
2075 }
2076
2077 static void generic_done(int result)
2078 {
2079         command_status = result;
2080         cont = &wakeup_cont;
2081 }
2082
2083 static void generic_success(void)
2084 {
2085         cont->done(1);
2086 }
2087
2088 static void generic_failure(void)
2089 {
2090         cont->done(0);
2091 }
2092
2093 static void success_and_wakeup(void)
2094 {
2095         generic_success();
2096         cont->redo();
2097 }
2098
2099 /*
2100  * formatting and rw support.
2101  * ==========================
2102  */
2103
2104 static int next_valid_format(void)
2105 {
2106         int probed_format;
2107
2108         probed_format = DRS->probed_format;
2109         while (1) {
2110                 if (probed_format >= 8 || !DP->autodetect[probed_format]) {
2111                         DRS->probed_format = 0;
2112                         return 1;
2113                 }
2114                 if (floppy_type[DP->autodetect[probed_format]].sect) {
2115                         DRS->probed_format = probed_format;
2116                         return 0;
2117                 }
2118                 probed_format++;
2119         }
2120 }
2121
2122 static void bad_flp_intr(void)
2123 {
2124         int err_count;
2125
2126         if (probing) {
2127                 DRS->probed_format++;
2128                 if (!next_valid_format())
2129                         return;
2130         }
2131         err_count = ++(*errors);
2132         INFBOUND(DRWE->badness, err_count);
2133         if (err_count > DP->max_errors.abort)
2134                 cont->done(0);
2135         if (err_count > DP->max_errors.reset)
2136                 FDCS->reset = 1;
2137         else if (err_count > DP->max_errors.recal)
2138                 DRS->track = NEED_2_RECAL;
2139 }
2140
2141 static void set_floppy(int drive)
2142 {
2143         int type = ITYPE(UDRS->fd_device);
2144         if (type)
2145                 _floppy = floppy_type + type;
2146         else
2147                 _floppy = current_type[drive];
2148 }
2149
2150 /*
2151  * formatting support.
2152  * ===================
2153  */
2154 static void format_interrupt(void)
2155 {
2156         switch (interpret_errors()) {
2157         case 1:
2158                 cont->error();
2159         case 2:
2160                 break;
2161         case 0:
2162                 cont->done(1);
2163         }
2164         cont->redo();
2165 }
2166
2167 #define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
2168 #define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80) >>1))
2169 #define CT(x) ((x) | 0xc0)
2170 static void setup_format_params(int track)
2171 {
2172         struct fparm {
2173                 unsigned char track, head, sect, size;
2174         } *here = (struct fparm *)floppy_track_buffer;
2175         int il, n;
2176         int count, head_shift, track_shift;
2177
2178         raw_cmd = &default_raw_cmd;
2179         raw_cmd->track = track;
2180
2181         raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2182             FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2183         raw_cmd->rate = _floppy->rate & 0x43;
2184         raw_cmd->cmd_count = NR_F;
2185         COMMAND = FM_MODE(_floppy, FD_FORMAT);
2186         DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2187         F_SIZECODE = FD_SIZECODE(_floppy);
2188         F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2189         F_GAP = _floppy->fmt_gap;
2190         F_FILL = FD_FILL_BYTE;
2191
2192         raw_cmd->kernel_data = floppy_track_buffer;
2193         raw_cmd->length = 4 * F_SECT_PER_TRACK;
2194
2195         /* allow for about 30ms for data transport per track */
2196         head_shift = (F_SECT_PER_TRACK + 5) / 6;
2197
2198         /* a ``cylinder'' is two tracks plus a little stepping time */
2199         track_shift = 2 * head_shift + 3;
2200
2201         /* position of logical sector 1 on this track */
2202         n = (track_shift * format_req.track + head_shift * format_req.head)
2203             % F_SECT_PER_TRACK;
2204
2205         /* determine interleave */
2206         il = 1;
2207         if (_floppy->fmt_gap < 0x22)
2208                 il++;
2209
2210         /* initialize field */
2211         for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2212                 here[count].track = format_req.track;
2213                 here[count].head = format_req.head;
2214                 here[count].sect = 0;
2215                 here[count].size = F_SIZECODE;
2216         }
2217         /* place logical sectors */
2218         for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2219                 here[n].sect = count;
2220                 n = (n + il) % F_SECT_PER_TRACK;
2221                 if (here[n].sect) {     /* sector busy, find next free sector */
2222                         ++n;
2223                         if (n >= F_SECT_PER_TRACK) {
2224                                 n -= F_SECT_PER_TRACK;
2225                                 while (here[n].sect)
2226                                         ++n;
2227                         }
2228                 }
2229         }
2230         if (_floppy->stretch & FD_ZEROBASED) {
2231                 for (count = 0; count < F_SECT_PER_TRACK; count++)
2232                         here[count].sect--;
2233         }
2234 }
2235
2236 static void redo_format(void)
2237 {
2238         buffer_track = -1;
2239         setup_format_params(format_req.track << STRETCH(_floppy));
2240         floppy_start();
2241         debugt("queue format request");
2242 }
2243
2244 static struct cont_t format_cont = {
2245         .interrupt      = format_interrupt,
2246         .redo           = redo_format,
2247         .error          = bad_flp_intr,
2248         .done           = generic_done
2249 };
2250
2251 static int do_format(int drive, struct format_descr *tmp_format_req)
2252 {
2253         int ret;
2254
2255         LOCK_FDC(drive, 1);
2256         set_floppy(drive);
2257         if (!_floppy ||
2258             _floppy->track > DP->tracks ||
2259             tmp_format_req->track >= _floppy->track ||
2260             tmp_format_req->head >= _floppy->head ||
2261             (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2262             !_floppy->fmt_gap) {
2263                 process_fd_request();
2264                 return -EINVAL;
2265         }
2266         format_req = *tmp_format_req;
2267         format_errors = 0;
2268         cont = &format_cont;
2269         errors = &format_errors;
2270         IWAIT(redo_format);
2271         process_fd_request();
2272         return ret;
2273 }
2274
2275 /*
2276  * Buffer read/write and support
2277  * =============================
2278  */
2279
2280 static void floppy_end_request(struct request *req, int uptodate)
2281 {
2282         unsigned int nr_sectors = current_count_sectors;
2283
2284         /* current_count_sectors can be zero if transfer failed */
2285         if (!uptodate)
2286                 nr_sectors = req->current_nr_sectors;
2287         if (end_that_request_first(req, uptodate, nr_sectors))
2288                 return;
2289         add_disk_randomness(req->rq_disk);
2290         floppy_off((long)req->rq_disk->private_data);
2291         blkdev_dequeue_request(req);
2292         end_that_request_last(req, uptodate);
2293
2294         /* We're done with the request */
2295         current_req = NULL;
2296 }
2297
2298 /* new request_done. Can handle physical sectors which are smaller than a
2299  * logical buffer */
2300 static void request_done(int uptodate)
2301 {
2302         struct request_queue *q = floppy_queue;
2303         struct request *req = current_req;
2304         unsigned long flags;
2305         int block;
2306
2307         probing = 0;
2308         reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
2309
2310         if (!req) {
2311                 printk("floppy.c: no request in request_done\n");
2312                 return;
2313         }
2314
2315         if (uptodate) {
2316                 /* maintain values for invalidation on geometry
2317                  * change */
2318                 block = current_count_sectors + req->sector;
2319                 INFBOUND(DRS->maxblock, block);
2320                 if (block > _floppy->sect)
2321                         DRS->maxtrack = 1;
2322
2323                 /* unlock chained buffers */
2324                 spin_lock_irqsave(q->queue_lock, flags);
2325                 floppy_end_request(req, 1);
2326                 spin_unlock_irqrestore(q->queue_lock, flags);
2327         } else {
2328                 if (rq_data_dir(req) == WRITE) {
2329                         /* record write error information */
2330                         DRWE->write_errors++;
2331                         if (DRWE->write_errors == 1) {
2332                                 DRWE->first_error_sector = req->sector;
2333                                 DRWE->first_error_generation = DRS->generation;
2334                         }
2335                         DRWE->last_error_sector = req->sector;
2336                         DRWE->last_error_generation = DRS->generation;
2337                 }
2338                 spin_lock_irqsave(q->queue_lock, flags);
2339                 floppy_end_request(req, 0);
2340                 spin_unlock_irqrestore(q->queue_lock, flags);
2341         }
2342 }
2343
2344 /* Interrupt handler evaluating the result of the r/w operation */
2345 static void rw_interrupt(void)
2346 {
2347         int nr_sectors, ssize, eoc, heads;
2348
2349         if (R_HEAD >= 2) {
2350                 /* some Toshiba floppy controllers occasionnally seem to
2351                  * return bogus interrupts after read/write operations, which
2352                  * can be recognized by a bad head number (>= 2) */
2353                 return;
2354         }
2355
2356         if (!DRS->first_read_date)
2357                 DRS->first_read_date = jiffies;
2358
2359         nr_sectors = 0;
2360         CODE2SIZE;
2361
2362         if (ST1 & ST1_EOC)
2363                 eoc = 1;
2364         else
2365                 eoc = 0;
2366
2367         if (COMMAND & 0x80)
2368                 heads = 2;
2369         else
2370                 heads = 1;
2371
2372         nr_sectors = (((R_TRACK - TRACK) * heads +
2373                        R_HEAD - HEAD) * SECT_PER_TRACK +
2374                       R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2375
2376 #ifdef FLOPPY_SANITY_CHECK
2377         if (nr_sectors / ssize >
2378             (in_sector_offset + current_count_sectors + ssize - 1) / ssize) {
2379                 DPRINT("long rw: %x instead of %lx\n",
2380                        nr_sectors, current_count_sectors);
2381                 printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
2382                 printk("rh=%d h=%d\n", R_HEAD, HEAD);
2383                 printk("rt=%d t=%d\n", R_TRACK, TRACK);
2384                 printk("heads=%d eoc=%d\n", heads, eoc);
2385                 printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
2386                        fsector_t, ssize);
2387                 printk("in_sector_offset=%d\n", in_sector_offset);
2388         }
2389 #endif
2390
2391         nr_sectors -= in_sector_offset;
2392         INFBOUND(nr_sectors, 0);
2393         SUPBOUND(current_count_sectors, nr_sectors);
2394
2395         switch (interpret_errors()) {
2396         case 2:
2397                 cont->redo();
2398                 return;
2399         case 1:
2400                 if (!current_count_sectors) {
2401                         cont->error();
2402                         cont->redo();
2403                         return;
2404                 }
2405                 break;
2406         case 0:
2407                 if (!current_count_sectors) {
2408                         cont->redo();
2409                         return;
2410                 }
2411                 current_type[current_drive] = _floppy;
2412                 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2413                 break;
2414         }
2415
2416         if (probing) {
2417                 if (DP->flags & FTD_MSG)
2418                         DPRINT("Auto-detected floppy type %s in fd%d\n",
2419                                _floppy->name, current_drive);
2420                 current_type[current_drive] = _floppy;
2421                 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2422                 probing = 0;
2423         }
2424
2425         if (CT(COMMAND) != FD_READ ||
2426             raw_cmd->kernel_data == current_req->buffer) {
2427                 /* transfer directly from buffer */
2428                 cont->done(1);
2429         } else if (CT(COMMAND) == FD_READ) {
2430                 buffer_track = raw_cmd->track;
2431                 buffer_drive = current_drive;
2432                 INFBOUND(buffer_max, nr_sectors + fsector_t);
2433         }
2434         cont->redo();
2435 }
2436
2437 /* Compute maximal contiguous buffer size. */
2438 static int buffer_chain_size(void)
2439 {
2440         struct bio *bio;
2441         struct bio_vec *bv;
2442         int size, i;
2443         char *base;
2444
2445         base = bio_data(current_req->bio);
2446         size = 0;
2447
2448         rq_for_each_bio(bio, current_req) {
2449                 bio_for_each_segment(bv, bio, i) {
2450                         if (page_address(bv->bv_page) + bv->bv_offset !=
2451                             base + size)
2452                                 break;
2453
2454                         size += bv->bv_len;
2455                 }
2456         }
2457
2458         return size >> 9;
2459 }
2460
2461 /* Compute the maximal transfer size */
2462 static int transfer_size(int ssize, int max_sector, int max_size)
2463 {
2464         SUPBOUND(max_sector, fsector_t + max_size);
2465
2466         /* alignment */
2467         max_sector -= (max_sector % _floppy->sect) % ssize;
2468
2469         /* transfer size, beginning not aligned */
2470         current_count_sectors = max_sector - fsector_t;
2471
2472         return max_sector;
2473 }
2474
2475 /*
2476  * Move data from/to the track buffer to/from the buffer cache.
2477  */
2478 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2479 {
2480         int remaining;          /* number of transferred 512-byte sectors */
2481         struct bio_vec *bv;
2482         struct bio *bio;
2483         char *buffer, *dma_buffer;
2484         int size, i;
2485
2486         max_sector = transfer_size(ssize,
2487                                    min(max_sector, max_sector_2),
2488                                    current_req->nr_sectors);
2489
2490         if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2491             buffer_max > fsector_t + current_req->nr_sectors)
2492                 current_count_sectors = min_t(int, buffer_max - fsector_t,
2493                                               current_req->nr_sectors);
2494
2495         remaining = current_count_sectors << 9;
2496 #ifdef FLOPPY_SANITY_CHECK
2497         if ((remaining >> 9) > current_req->nr_sectors &&
2498             CT(COMMAND) == FD_WRITE) {
2499                 DPRINT("in copy buffer\n");
2500                 printk("current_count_sectors=%ld\n", current_count_sectors);
2501                 printk("remaining=%d\n", remaining >> 9);
2502                 printk("current_req->nr_sectors=%ld\n",
2503                        current_req->nr_sectors);
2504                 printk("current_req->current_nr_sectors=%u\n",
2505                        current_req->current_nr_sectors);
2506                 printk("max_sector=%d\n", max_sector);
2507                 printk("ssize=%d\n", ssize);
2508         }
2509 #endif
2510
2511         buffer_max = max(max_sector, buffer_max);
2512
2513         dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2514
2515         size = current_req->current_nr_sectors << 9;
2516
2517         rq_for_each_bio(bio, current_req) {
2518                 bio_for_each_segment(bv, bio, i) {
2519                         if (!remaining)
2520                                 break;
2521
2522                         size = bv->bv_len;
2523                         SUPBOUND(size, remaining);
2524
2525                         buffer = page_address(bv->bv_page) + bv->bv_offset;
2526 #ifdef FLOPPY_SANITY_CHECK
2527                         if (dma_buffer + size >
2528                             floppy_track_buffer + (max_buffer_sectors << 10) ||
2529                             dma_buffer < floppy_track_buffer) {
2530                                 DPRINT("buffer overrun in copy buffer %d\n",
2531                                        (int)((floppy_track_buffer -
2532                                               dma_buffer) >> 9));
2533                                 printk("fsector_t=%d buffer_min=%d\n",
2534                                        fsector_t, buffer_min);
2535                                 printk("current_count_sectors=%ld\n",
2536                                        current_count_sectors);
2537                                 if (CT(COMMAND) == FD_READ)
2538                                         printk("read\n");
2539                                 if (CT(COMMAND) == FD_WRITE)
2540                                         printk("write\n");
2541                                 break;
2542                         }
2543                         if (((unsigned long)buffer) % 512)
2544                                 DPRINT("%p buffer not aligned\n", buffer);
2545 #endif
2546                         if (CT(COMMAND) == FD_READ)
2547                                 memcpy(buffer, dma_buffer, size);
2548                         else
2549                                 memcpy(dma_buffer, buffer, size);
2550
2551                         remaining -= size;
2552                         dma_buffer += size;
2553                 }
2554         }
2555 #ifdef FLOPPY_SANITY_CHECK
2556         if (remaining) {
2557                 if (remaining > 0)
2558                         max_sector -= remaining >> 9;
2559                 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2560         }
2561 #endif
2562 }
2563
2564 #if 0
2565 static inline int check_dma_crossing(char *start,
2566                                      unsigned long length, char *message)
2567 {
2568         if (CROSS_64KB(start, length)) {
2569                 printk("DMA xfer crosses 64KB boundary in %s %p-%p\n",
2570                        message, start, start + length);
2571                 return 1;
2572         } else
2573                 return 0;
2574 }
2575 #endif
2576
2577 /* work around a bug in pseudo DMA
2578  * (on some FDCs) pseudo DMA does not stop when the CPU stops
2579  * sending data.  Hence we need a different way to signal the
2580  * transfer length:  We use SECT_PER_TRACK.  Unfortunately, this
2581  * does not work with MT, hence we can only transfer one head at
2582  * a time
2583  */
2584 static void virtualdmabug_workaround(void)
2585 {
2586         int hard_sectors, end_sector;
2587
2588         if (CT(COMMAND) == FD_WRITE) {
2589                 COMMAND &= ~0x80;       /* switch off multiple track mode */
2590
2591                 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2592                 end_sector = SECTOR + hard_sectors - 1;
2593 #ifdef FLOPPY_SANITY_CHECK
2594                 if (end_sector > SECT_PER_TRACK) {
2595                         printk("too many sectors %d > %d\n",
2596                                end_sector, SECT_PER_TRACK);
2597                         return;
2598                 }
2599 #endif
2600                 SECT_PER_TRACK = end_sector;    /* make sure SECT_PER_TRACK points
2601                                                  * to end of transfer */
2602         }
2603 }
2604
2605 /*
2606  * Formulate a read/write request.
2607  * this routine decides where to load the data (directly to buffer, or to
2608  * tmp floppy area), how much data to load (the size of the buffer, the whole
2609  * track, or a single sector)
2610  * All floppy_track_buffer handling goes in here. If we ever add track buffer
2611  * allocation on the fly, it should be done here. No other part should need
2612  * modification.
2613  */
2614
2615 static int make_raw_rw_request(void)
2616 {
2617         int aligned_sector_t;
2618         int max_sector, max_size, tracksize, ssize;
2619
2620         if (max_buffer_sectors == 0) {
2621                 printk("VFS: Block I/O scheduled on unopened device\n");
2622                 return 0;
2623         }
2624
2625         set_fdc((long)current_req->rq_disk->private_data);
2626
2627         raw_cmd = &default_raw_cmd;
2628         raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2629             FD_RAW_NEED_SEEK;
2630         raw_cmd->cmd_count = NR_RW;
2631         if (rq_data_dir(current_req) == READ) {
2632                 raw_cmd->flags |= FD_RAW_READ;
2633                 COMMAND = FM_MODE(_floppy, FD_READ);
2634         } else if (rq_data_dir(current_req) == WRITE) {
2635                 raw_cmd->flags |= FD_RAW_WRITE;
2636                 COMMAND = FM_MODE(_floppy, FD_WRITE);
2637         } else {
2638                 DPRINT("make_raw_rw_request: unknown command\n");
2639                 return 0;
2640         }
2641
2642         max_sector = _floppy->sect * _floppy->head;
2643
2644         TRACK = (int)current_req->sector / max_sector;
2645         fsector_t = (int)current_req->sector % max_sector;
2646         if (_floppy->track && TRACK >= _floppy->track) {
2647                 if (current_req->current_nr_sectors & 1) {
2648                         current_count_sectors = 1;
2649                         return 1;
2650                 } else
2651                         return 0;
2652         }
2653         HEAD = fsector_t / _floppy->sect;
2654
2655         if (((_floppy->stretch & (FD_SWAPSIDES | FD_ZEROBASED)) ||
2656              TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
2657                 max_sector = _floppy->sect;
2658
2659         /* 2M disks have phantom sectors on the first track */
2660         if ((_floppy->rate & FD_2M) && (!TRACK) && (!HEAD)) {
2661                 max_sector = 2 * _floppy->sect / 3;
2662                 if (fsector_t >= max_sector) {
2663                         current_count_sectors =
2664                             min_t(int, _floppy->sect - fsector_t,
2665                                   current_req->nr_sectors);
2666                         return 1;
2667                 }
2668                 SIZECODE = 2;
2669         } else
2670                 SIZECODE = FD_SIZECODE(_floppy);
2671         raw_cmd->rate = _floppy->rate & 0x43;
2672         if ((_floppy->rate & FD_2M) && (TRACK || HEAD) && raw_cmd->rate == 2)
2673                 raw_cmd->rate = 1;
2674
2675         if (SIZECODE)
2676                 SIZECODE2 = 0xff;
2677         else
2678                 SIZECODE2 = 0x80;
2679         raw_cmd->track = TRACK << STRETCH(_floppy);
2680         DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
2681         GAP = _floppy->gap;
2682         CODE2SIZE;
2683         SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
2684         SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
2685             ((_floppy->stretch & FD_ZEROBASED) ? 0 : 1);
2686
2687         /* tracksize describes the size which can be filled up with sectors
2688          * of size ssize.
2689          */
2690         tracksize = _floppy->sect - _floppy->sect % ssize;
2691         if (tracksize < _floppy->sect) {
2692                 SECT_PER_TRACK++;
2693                 if (tracksize <= fsector_t % _floppy->sect)
2694                         SECTOR--;
2695
2696                 /* if we are beyond tracksize, fill up using smaller sectors */
2697                 while (tracksize <= fsector_t % _floppy->sect) {
2698                         while (tracksize + ssize > _floppy->sect) {
2699                                 SIZECODE--;
2700                                 ssize >>= 1;
2701                         }
2702                         SECTOR++;
2703                         SECT_PER_TRACK++;
2704                         tracksize += ssize;
2705                 }
2706                 max_sector = HEAD * _floppy->sect + tracksize;
2707         } else if (!TRACK && !HEAD && !(_floppy->rate & FD_2M) && probing) {
2708                 max_sector = _floppy->sect;
2709         } else if (!HEAD && CT(COMMAND) == FD_WRITE) {
2710                 /* for virtual DMA bug workaround */
2711                 max_sector = _floppy->sect;
2712         }
2713
2714         in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2715         aligned_sector_t = fsector_t - in_sector_offset;
2716         max_size = current_req->nr_sectors;
2717         if ((raw_cmd->track == buffer_track) &&
2718             (current_drive == buffer_drive) &&
2719             (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2720                 /* data already in track buffer */
2721                 if (CT(COMMAND) == FD_READ) {
2722                         copy_buffer(1, max_sector, buffer_max);
2723                         return 1;
2724                 }
2725         } else if (in_sector_offset || current_req->nr_sectors < ssize) {
2726                 if (CT(COMMAND) == FD_WRITE) {
2727                         if (fsector_t + current_req->nr_sectors > ssize &&
2728                             fsector_t + current_req->nr_sectors < ssize + ssize)
2729                                 max_size = ssize + ssize;
2730                         else
2731                                 max_size = ssize;
2732                 }
2733                 raw_cmd->flags &= ~FD_RAW_WRITE;
2734                 raw_cmd->flags |= FD_RAW_READ;
2735                 COMMAND = FM_MODE(_floppy, FD_READ);
2736         } else if ((unsigned long)current_req->buffer < MAX_DMA_ADDRESS) {
2737                 unsigned long dma_limit;
2738                 int direct, indirect;
2739
2740                 indirect =
2741                     transfer_size(ssize, max_sector,
2742                                   max_buffer_sectors * 2) - fsector_t;
2743
2744                 /*
2745                  * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide
2746                  * on a 64 bit machine!
2747                  */
2748                 max_size = buffer_chain_size();
2749                 dma_limit =
2750                     (MAX_DMA_ADDRESS -
2751                      ((unsigned long)current_req->buffer)) >> 9;
2752                 if ((unsigned long)max_size > dma_limit) {
2753                         max_size = dma_limit;
2754                 }
2755                 /* 64 kb boundaries */
2756                 if (CROSS_64KB(current_req->buffer, max_size << 9))
2757                         max_size = (K_64 -
2758                                     ((unsigned long)current_req->buffer) %
2759                                     K_64) >> 9;
2760                 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2761                 /*
2762                  * We try to read tracks, but if we get too many errors, we
2763                  * go back to reading just one sector at a time.
2764                  *
2765                  * This means we should be able to read a sector even if there
2766                  * are other bad sectors on this track.
2767                  */
2768                 if (!direct ||
2769                     (indirect * 2 > direct * 3 &&
2770                      *errors < DP->max_errors.read_track &&
2771                      /*!TESTF(FD_NEED_TWADDLE) && */
2772                      ((!probing
2773                        || (DP->read_track & (1 << DRS->probed_format)))))) {
2774                         max_size = current_req->nr_sectors;
2775                 } else {
2776                         raw_cmd->kernel_data = current_req->buffer;
2777                         raw_cmd->length = current_count_sectors << 9;
2778                         if (raw_cmd->length == 0) {
2779                                 DPRINT
2780                                     ("zero dma transfer attempted from make_raw_request\n");
2781                                 DPRINT("indirect=%d direct=%d fsector_t=%d",
2782                                        indirect, direct, fsector_t);
2783                                 return 0;
2784                         }
2785 /*                      check_dma_crossing(raw_cmd->kernel_data,
2786                                            raw_cmd->length,
2787                                            "end of make_raw_request [1]");*/
2788
2789                         virtualdmabug_workaround();
2790                         return 2;
2791                 }
2792         }
2793
2794         if (CT(COMMAND) == FD_READ)
2795                 max_size = max_sector;  /* unbounded */
2796
2797         /* claim buffer track if needed */
2798         if (buffer_track != raw_cmd->track ||   /* bad track */
2799             buffer_drive != current_drive ||    /* bad drive */
2800             fsector_t > buffer_max ||
2801             fsector_t < buffer_min ||
2802             ((CT(COMMAND) == FD_READ ||
2803               (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
2804              max_sector > 2 * max_buffer_sectors + buffer_min &&
2805              max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
2806             /* not enough space */
2807             ) {
2808                 buffer_track = -1;
2809                 buffer_drive = current_drive;
2810                 buffer_max = buffer_min = aligned_sector_t;
2811         }
2812         raw_cmd->kernel_data = floppy_track_buffer +
2813             ((aligned_sector_t - buffer_min) << 9);
2814
2815         if (CT(COMMAND) == FD_WRITE) {
2816                 /* copy write buffer to track buffer.
2817                  * if we get here, we know that the write
2818                  * is either aligned or the data already in the buffer
2819                  * (buffer will be overwritten) */
2820 #ifdef FLOPPY_SANITY_CHECK
2821                 if (in_sector_offset && buffer_track == -1)
2822                         DPRINT("internal error offset !=0 on write\n");
2823 #endif
2824                 buffer_track = raw_cmd->track;
2825                 buffer_drive = current_drive;
2826                 copy_buffer(ssize, max_sector,
2827                             2 * max_buffer_sectors + buffer_min);
2828         } else
2829                 transfer_size(ssize, max_sector,
2830                               2 * max_buffer_sectors + buffer_min -
2831                               aligned_sector_t);
2832
2833         /* round up current_count_sectors to get dma xfer size */
2834         raw_cmd->length = in_sector_offset + current_count_sectors;
2835         raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2836         raw_cmd->length <<= 9;
2837 #ifdef FLOPPY_SANITY_CHECK
2838         /*check_dma_crossing(raw_cmd->kernel_data, raw_cmd->length,
2839            "end of make_raw_request"); */
2840         if ((raw_cmd->length < current_count_sectors << 9) ||
2841             (raw_cmd->kernel_data != current_req->buffer &&
2842              CT(COMMAND) == FD_WRITE &&
2843              (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2844               aligned_sector_t < buffer_min)) ||
2845             raw_cmd->length % (128 << SIZECODE) ||
2846             raw_cmd->length <= 0 || current_count_sectors <= 0) {
2847                 DPRINT("fractionary current count b=%lx s=%lx\n",
2848                        raw_cmd->length, current_count_sectors);
2849                 if (raw_cmd->kernel_data != current_req->buffer)
2850                         printk("addr=%d, length=%ld\n",
2851                                (int)((raw_cmd->kernel_data -
2852                                       floppy_track_buffer) >> 9),
2853                                current_count_sectors);
2854                 printk("st=%d ast=%d mse=%d msi=%d\n",
2855                        fsector_t, aligned_sector_t, max_sector, max_size);
2856                 printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
2857                 printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2858                        COMMAND, SECTOR, HEAD, TRACK);
2859                 printk("buffer drive=%d\n", buffer_drive);
2860                 printk("buffer track=%d\n", buffer_track);
2861                 printk("buffer_min=%d\n", buffer_min);
2862                 printk("buffer_max=%d\n", buffer_max);
2863                 return 0;
2864         }
2865
2866         if (raw_cmd->kernel_data != current_req->buffer) {
2867                 if (raw_cmd->kernel_data < floppy_track_buffer ||
2868                     current_count_sectors < 0 ||
2869                     raw_cmd->length < 0 ||
2870                     raw_cmd->kernel_data + raw_cmd->length >
2871                     floppy_track_buffer + (max_buffer_sectors << 10)) {
2872                         DPRINT("buffer overrun in schedule dma\n");
2873                         printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
2874                                fsector_t, buffer_min, raw_cmd->length >> 9);
2875                         printk("current_count_sectors=%ld\n",
2876                                current_count_sectors);
2877                         if (CT(COMMAND) == FD_READ)
2878                                 printk("read\n");
2879                         if (CT(COMMAND) == FD_WRITE)
2880                                 printk("write\n");
2881                         return 0;
2882                 }
2883         } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
2884                    current_count_sectors > current_req->nr_sectors) {
2885                 DPRINT("buffer overrun in direct transfer\n");
2886                 return 0;
2887         } else if (raw_cmd->length < current_count_sectors << 9) {
2888                 DPRINT("more sectors than bytes\n");
2889                 printk("bytes=%ld\n", raw_cmd->length >> 9);
2890                 printk("sectors=%ld\n", current_count_sectors);
2891         }
2892         if (raw_cmd->length == 0) {
2893                 DPRINT("zero dma transfer attempted from make_raw_request\n");
2894                 return 0;
2895         }
2896 #endif
2897
2898         virtualdmabug_workaround();
2899         return 2;
2900 }
2901
2902 static void redo_fd_request(void)
2903 {
2904 #define REPEAT {request_done(0); continue; }
2905         int drive;
2906         int tmp;
2907
2908         lastredo = jiffies;
2909         if (current_drive < N_DRIVE)
2910                 floppy_off(current_drive);
2911
2912         for (;;) {
2913                 if (!current_req) {
2914                         struct request *req;
2915
2916                         spin_lock_irq(floppy_queue->queue_lock);
2917                         req = elv_next_request(floppy_queue);
2918                         spin_unlock_irq(floppy_queue->queue_lock);
2919                         if (!req) {
2920                                 do_floppy = NULL;
2921                                 unlock_fdc();
2922                                 return;
2923                         }
2924                         current_req = req;
2925                 }
2926                 drive = (long)current_req->rq_disk->private_data;
2927                 set_fdc(drive);
2928                 reschedule_timeout(current_reqD, "redo fd request", 0);
2929
2930                 set_floppy(drive);
2931                 raw_cmd = &default_raw_cmd;
2932                 raw_cmd->flags = 0;
2933                 if (start_motor(redo_fd_request))
2934                         return;
2935                 disk_change(current_drive);
2936                 if (test_bit(current_drive, &fake_change) ||
2937                     TESTF(FD_DISK_CHANGED)) {
2938                         DPRINT("disk absent or changed during operation\n");
2939                         REPEAT;
2940                 }
2941                 if (!_floppy) { /* Autodetection */
2942                         if (!probing) {
2943                                 DRS->probed_format = 0;
2944                                 if (next_valid_format()) {
2945                                         DPRINT("no autodetectable formats\n");
2946                                         _floppy = NULL;
2947                                         REPEAT;
2948                                 }
2949                         }
2950                         probing = 1;
2951                         _floppy =
2952                             floppy_type + DP->autodetect[DRS->probed_format];
2953                 } else
2954                         probing = 0;
2955                 errors = &(current_req->errors);
2956                 tmp = make_raw_rw_request();
2957                 if (tmp < 2) {
2958                         request_done(tmp);
2959                         continue;
2960                 }
2961
2962                 if (TESTF(FD_NEED_TWADDLE))
2963                         twaddle();
2964                 schedule_bh(floppy_start);
2965                 debugt("queue fd request");
2966                 return;
2967         }
2968 #undef REPEAT
2969 }
2970
2971 static struct cont_t rw_cont = {
2972         .interrupt      = rw_interrupt,
2973         .redo           = redo_fd_request,
2974         .error          = bad_flp_intr,
2975         .done           = request_done
2976 };
2977
2978 static void process_fd_request(void)
2979 {
2980         cont = &rw_cont;
2981         schedule_bh(redo_fd_request);
2982 }
2983
2984 static void do_fd_request(request_queue_t * q)
2985 {
2986         if (max_buffer_sectors == 0) {
2987                 printk("VFS: do_fd_request called on non-open device\n");
2988                 return;
2989         }
2990
2991         if (usage_count == 0) {
2992                 printk("warning: usage count=0, current_req=%p exiting\n",
2993                        current_req);
2994                 printk("sect=%ld flags=%lx\n", (long)current_req->sector,
2995                        current_req->flags);
2996                 return;
2997         }
2998         if (test_bit(0, &fdc_busy)) {
2999                 /* fdc busy, this new request will be treated when the
3000                    current one is done */
3001                 is_alive("do fd request, old request running");
3002                 return;
3003         }
3004         lock_fdc(MAXTIMEOUT, 0);
3005         process_fd_request();
3006         is_alive("do fd request");
3007 }
3008
3009 static struct cont_t poll_cont = {
3010         .interrupt      = success_and_wakeup,
3011         .redo           = floppy_ready,
3012         .error          = generic_failure,
3013         .done           = generic_done
3014 };
3015
3016 static int poll_drive(int interruptible, int flag)
3017 {
3018         int ret;
3019         /* no auto-sense, just clear dcl */
3020         raw_cmd = &default_raw_cmd;
3021         raw_cmd->flags = flag;
3022         raw_cmd->track = 0;
3023         raw_cmd->cmd_count = 0;
3024         cont = &poll_cont;
3025 #ifdef DCL_DEBUG
3026         if (DP->flags & FD_DEBUG) {
3027                 DPRINT("setting NEWCHANGE in poll_drive\n");
3028         }
3029 #endif
3030         SETF(FD_DISK_NEWCHANGE);
3031         WAIT(floppy_ready);
3032         return ret;
3033 }
3034
3035 /*
3036  * User triggered reset
3037  * ====================
3038  */
3039
3040 static void reset_intr(void)
3041 {
3042         printk("weird, reset interrupt called\n");
3043 }
3044
3045 static struct cont_t reset_cont = {
3046         .interrupt      = reset_intr,
3047         .redo           = success_and_wakeup,
3048         .error          = generic_failure,
3049         .done           = generic_done
3050 };
3051
3052 static int user_reset_fdc(int drive, int arg, int interruptible)
3053 {
3054         int ret;
3055
3056         ret = 0;
3057         LOCK_FDC(drive, interruptible);
3058         if (arg == FD_RESET_ALWAYS)
3059                 FDCS->reset = 1;
3060         if (FDCS->reset) {
3061                 cont = &reset_cont;
3062                 WAIT(reset_fdc);
3063         }
3064         process_fd_request();
3065         return ret;
3066 }
3067
3068 /*
3069  * Misc Ioctl's and support
3070  * ========================
3071  */
3072 static inline int fd_copyout(void __user *param, const void *address,
3073                              unsigned long size)
3074 {
3075         return copy_to_user(param, address, size) ? -EFAULT : 0;
3076 }
3077
3078 static inline int fd_copyin(void __user *param, void *address, unsigned long size)
3079 {
3080         return copy_from_user(address, param, size) ? -EFAULT : 0;
3081 }
3082
3083 #define _COPYOUT(x) (copy_to_user((void __user *)param, &(x), sizeof(x)) ? -EFAULT : 0)
3084 #define _COPYIN(x) (copy_from_user(&(x), (void __user *)param, sizeof(x)) ? -EFAULT : 0)
3085
3086 #define COPYOUT(x) ECALL(_COPYOUT(x))
3087 #define COPYIN(x) ECALL(_COPYIN(x))
3088
3089 static inline const char *drive_name(int type, int drive)
3090 {
3091         struct floppy_struct *floppy;
3092
3093         if (type)
3094                 floppy = floppy_type + type;
3095         else {
3096                 if (UDP->native_format)
3097                         floppy = floppy_type + UDP->native_format;
3098                 else
3099                         return "(null)";
3100         }
3101         if (floppy->name)
3102                 return floppy->name;
3103         else
3104                 return "(null)";
3105 }
3106
3107 /* raw commands */
3108 static void raw_cmd_done(int flag)
3109 {
3110         int i;
3111
3112         if (!flag) {
3113                 raw_cmd->flags |= FD_RAW_FAILURE;
3114                 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3115         } else {
3116                 raw_cmd->reply_count = inr;
3117                 if (raw_cmd->reply_count > MAX_REPLIES)
3118                         raw_cmd->reply_count = 0;
3119                 for (i = 0; i < raw_cmd->reply_count; i++)
3120                         raw_cmd->reply[i] = reply_buffer[i];
3121
3122                 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3123                         unsigned long flags;
3124                         flags = claim_dma_lock();
3125                         raw_cmd->length = fd_get_dma_residue();
3126                         release_dma_lock(flags);
3127                 }
3128
3129                 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3130                     (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3131                         raw_cmd->flags |= FD_RAW_FAILURE;
3132
3133                 if (disk_change(current_drive))
3134                         raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3135                 else
3136                         raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3137                 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3138                         motor_off_callback(current_drive);
3139
3140                 if (raw_cmd->next &&
3141                     (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3142                      !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3143                     ((raw_cmd->flags & FD_RAW_FAILURE) ||
3144                      !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3145                         raw_cmd = raw_cmd->next;
3146                         return;
3147                 }
3148         }
3149         generic_done(flag);
3150 }
3151
3152 static struct cont_t raw_cmd_cont = {
3153         .interrupt      = success_and_wakeup,
3154         .redo           = floppy_start,
3155         .error          = generic_failure,
3156         .done           = raw_cmd_done
3157 };
3158
3159 static inline int raw_cmd_copyout(int cmd, char __user *param,
3160                                   struct floppy_raw_cmd *ptr)
3161 {
3162         int ret;
3163
3164         while (ptr) {
3165                 COPYOUT(*ptr);
3166                 param += sizeof(struct floppy_raw_cmd);
3167                 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3168                         if (ptr->length >= 0
3169                             && ptr->length <= ptr->buffer_length)
3170                                 ECALL(fd_copyout
3171                                       (ptr->data, ptr->kernel_data,
3172                                        ptr->buffer_length - ptr->length));
3173                 }
3174                 ptr = ptr->next;
3175         }
3176         return 0;
3177 }
3178
3179 static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3180 {
3181         struct floppy_raw_cmd *next, *this;
3182
3183         this = *ptr;
3184         *ptr = NULL;
3185         while (this) {
3186                 if (this->buffer_length) {
3187                         fd_dma_mem_free((unsigned long)this->kernel_data,
3188                                         this->buffer_length);
3189                         this->buffer_length = 0;
3190                 }
3191                 next = this->next;
3192                 kfree(this);
3193                 this = next;
3194         }
3195 }
3196
3197 static inline int raw_cmd_copyin(int cmd, char __user *param,
3198                                  struct floppy_raw_cmd **rcmd)
3199 {
3200         struct floppy_raw_cmd *ptr;
3201         int ret;
3202         int i;
3203
3204         *rcmd = NULL;
3205         while (1) {
3206                 ptr = (struct floppy_raw_cmd *)
3207                     kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
3208                 if (!ptr)
3209                         return -ENOMEM;
3210                 *rcmd = ptr;
3211                 COPYIN(*ptr);
3212                 ptr->next = NULL;
3213                 ptr->buffer_length = 0;
3214                 param += sizeof(struct floppy_raw_cmd);
3215                 if (ptr->cmd_count > 33)
3216                         /* the command may now also take up the space
3217                          * initially intended for the reply & the
3218                          * reply count. Needed for long 82078 commands
3219                          * such as RESTORE, which takes ... 17 command
3220                          * bytes. Murphy's law #137: When you reserve
3221                          * 16 bytes for a structure, you'll one day
3222                          * discover that you really need 17...
3223                          */
3224                         return -EINVAL;
3225
3226                 for (i = 0; i < 16; i++)
3227                         ptr->reply[i] = 0;
3228                 ptr->resultcode = 0;
3229                 ptr->kernel_data = NULL;
3230
3231                 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3232                         if (ptr->length <= 0)
3233                                 return -EINVAL;
3234                         ptr->kernel_data =
3235                             (char *)fd_dma_mem_alloc(ptr->length);
3236                         fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3237                         if (!ptr->kernel_data)
3238                                 return -ENOMEM;
3239                         ptr->buffer_length = ptr->length;
3240                 }
3241                 if (ptr->flags & FD_RAW_WRITE)
3242                         ECALL(fd_copyin(ptr->data, ptr->kernel_data,
3243                                         ptr->length));
3244                 rcmd = &(ptr->next);
3245                 if (!(ptr->flags & FD_RAW_MORE))
3246                         return 0;
3247                 ptr->rate &= 0x43;
3248         }
3249 }
3250
3251 static int raw_cmd_ioctl(int cmd, void __user *param)
3252 {
3253         int drive, ret, ret2;
3254         struct floppy_raw_cmd *my_raw_cmd;
3255
3256         if (FDCS->rawcmd <= 1)
3257                 FDCS->rawcmd = 1;
3258         for (drive = 0; drive < N_DRIVE; drive++) {
3259                 if (FDC(drive) != fdc)
3260                         continue;
3261                 if (drive == current_drive) {
3262                         if (UDRS->fd_ref > 1) {
3263                                 FDCS->rawcmd = 2;
3264                                 break;
3265                         }
3266                 } else if (UDRS->fd_ref) {
3267                         FDCS->rawcmd = 2;
3268                         break;
3269                 }
3270         }
3271
3272         if (FDCS->reset)
3273                 return -EIO;
3274
3275         ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3276         if (ret) {
3277                 raw_cmd_free(&my_raw_cmd);
3278                 return ret;
3279         }
3280
3281         raw_cmd = my_raw_cmd;
3282         cont = &raw_cmd_cont;
3283         ret = wait_til_done(floppy_start, 1);
3284 #ifdef DCL_DEBUG
3285         if (DP->flags & FD_DEBUG) {
3286                 DPRINT("calling disk change from raw_cmd ioctl\n");
3287         }
3288 #endif
3289
3290         if (ret != -EINTR && FDCS->reset)
3291                 ret = -EIO;
3292
3293         DRS->track = NO_TRACK;
3294
3295         ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3296         if (!ret)
3297                 ret = ret2;
3298         raw_cmd_free(&my_raw_cmd);
3299         return ret;
3300 }
3301
3302 static int invalidate_drive(struct block_device *bdev)
3303 {
3304         /* invalidate the buffer track to force a reread */
3305         set_bit((long)bdev->bd_disk->private_data, &fake_change);
3306         process_fd_request();
3307         check_disk_change(bdev);
3308         return 0;
3309 }
3310
3311 static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
3312                                int drive, int type, struct block_device *bdev)
3313 {
3314         int cnt;
3315
3316         /* sanity checking for parameters. */
3317         if (g->sect <= 0 ||
3318             g->head <= 0 ||
3319             g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
3320             /* check if reserved bits are set */
3321             (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_ZEROBASED)) != 0)
3322                 return -EINVAL;
3323         if (type) {
3324                 if (!capable(CAP_SYS_ADMIN))
3325                         return -EPERM;
3326                 mutex_lock(&open_lock);
3327                 LOCK_FDC(drive, 1);
3328                 floppy_type[type] = *g;
3329                 floppy_type[type].name = "user format";
3330                 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3331                         floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3332                             floppy_type[type].size + 1;
3333                 process_fd_request();
3334                 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3335                         struct block_device *bdev = opened_bdev[cnt];
3336                         if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3337                                 continue;
3338                         __invalidate_device(bdev);
3339                 }
3340                 mutex_unlock(&open_lock);
3341         } else {
3342                 int oldStretch;
3343                 LOCK_FDC(drive, 1);
3344                 if (cmd != FDDEFPRM)
3345                         /* notice a disk change immediately, else
3346                          * we lose our settings immediately*/
3347                         CALL(poll_drive(1, FD_RAW_NEED_DISK));
3348                 oldStretch = g->stretch;
3349                 user_params[drive] = *g;
3350                 if (buffer_drive == drive)
3351                         SUPBOUND(buffer_max, user_params[drive].sect);
3352                 current_type[drive] = &user_params[drive];
3353                 floppy_sizes[drive] = user_params[drive].size;
3354                 if (cmd == FDDEFPRM)
3355                         DRS->keep_data = -1;
3356                 else
3357                         DRS->keep_data = 1;
3358                 /* invalidation. Invalidate only when needed, i.e.
3359                  * when there are already sectors in the buffer cache
3360                  * whose number will change. This is useful, because
3361                  * mtools often changes the geometry of the disk after
3362                  * looking at the boot block */
3363                 if (DRS->maxblock > user_params[drive].sect ||
3364                     DRS->maxtrack ||
3365                     ((user_params[drive].sect ^ oldStretch) &
3366                      (FD_SWAPSIDES | FD_ZEROBASED)))
3367                         invalidate_drive(bdev);
3368                 else
3369                         process_fd_request();
3370         }
3371         return 0;
3372 }
3373
3374 /* handle obsolete ioctl's */
3375 static int ioctl_table[] = {
3376         FDCLRPRM,
3377         FDSETPRM,
3378         FDDEFPRM,
3379         FDGETPRM,
3380         FDMSGON,
3381         FDMSGOFF,
3382         FDFMTBEG,
3383         FDFMTTRK,
3384         FDFMTEND,
3385         FDSETEMSGTRESH,
3386         FDFLUSH,
3387         FDSETMAXERRS,
3388         FDGETMAXERRS,
3389         FDGETDRVTYP,
3390         FDSETDRVPRM,
3391         FDGETDRVPRM,
3392         FDGETDRVSTAT,
3393         FDPOLLDRVSTAT,
3394         FDRESET,
3395         FDGETFDCSTAT,
3396         FDWERRORCLR,
3397         FDWERRORGET,
3398         FDRAWCMD,
3399         FDEJECT,
3400         FDTWADDLE
3401 };
3402
3403 static inline int normalize_ioctl(int *cmd, int *size)
3404 {
3405         int i;
3406
3407         for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3408                 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3409                         *size = _IOC_SIZE(*cmd);
3410                         *cmd = ioctl_table[i];
3411                         if (*size > _IOC_SIZE(*cmd)) {
3412                                 printk("ioctl not yet supported\n");
3413                                 return -EFAULT;
3414                         }
3415                         return 0;
3416                 }
3417         }
3418         return -EINVAL;
3419 }
3420
3421 static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3422 {
3423         if (type)
3424                 *g = &floppy_type[type];
3425         else {
3426                 LOCK_FDC(drive, 0);
3427                 CALL(poll_drive(0, 0));
3428                 process_fd_request();
3429                 *g = current_type[drive];
3430         }
3431         if (!*g)
3432                 return -ENODEV;
3433         return 0;
3434 }
3435
3436 static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3437 {
3438         int drive = (long)bdev->bd_disk->private_data;
3439         int type = ITYPE(drive_state[drive].fd_device);
3440         struct floppy_struct *g;
3441         int ret;
3442
3443         ret = get_floppy_geometry(drive, type, &g);
3444         if (ret)
3445                 return ret;
3446
3447         geo->heads = g->head;
3448         geo->sectors = g->sect;
3449         geo->cylinders = g->track;
3450         return 0;
3451 }
3452
3453 static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
3454                     unsigned long param)
3455 {
3456 #define FD_IOCTL_ALLOWED ((filp) && (filp)->private_data)
3457 #define OUT(c,x) case c: outparam = (const char *) (x); break
3458 #define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
3459
3460         int drive = (long)inode->i_bdev->bd_disk->private_data;
3461         int i, type = ITYPE(UDRS->fd_device);
3462         int ret;
3463         int size;
3464         union inparam {
3465                 struct floppy_struct g; /* geometry */
3466                 struct format_descr f;
3467                 struct floppy_max_errors max_errors;
3468                 struct floppy_drive_params dp;
3469         } inparam;              /* parameters coming from user space */
3470         const char *outparam;   /* parameters passed back to user space */
3471
3472         /* convert compatibility eject ioctls into floppy eject ioctl.
3473          * We do this in order to provide a means to eject floppy disks before
3474          * installing the new fdutils package */
3475         if (cmd == CDROMEJECT ||        /* CD-ROM eject */
3476             cmd == 0x6470 /* SunOS floppy eject */ ) {
3477                 DPRINT("obsolete eject ioctl\n");
3478                 DPRINT("please use floppycontrol --eject\n");
3479                 cmd = FDEJECT;
3480         }
3481
3482         /* convert the old style command into a new style command */
3483         if ((cmd & 0xff00) == 0x0200) {
3484                 ECALL(normalize_ioctl(&cmd, &size));
3485         } else
3486                 return -EINVAL;
3487
3488         /* permission checks */
3489         if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
3490             ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3491                 return -EPERM;
3492
3493         /* copyin */
3494         CLEARSTRUCT(&inparam);
3495         if (_IOC_DIR(cmd) & _IOC_WRITE)
3496             ECALL(fd_copyin((void __user *)param, &inparam, size))
3497
3498                 switch (cmd) {
3499                 case FDEJECT:
3500                         if (UDRS->fd_ref != 1)
3501                                 /* somebody else has this drive open */
3502                                 return -EBUSY;
3503                         LOCK_FDC(drive, 1);
3504
3505                         /* do the actual eject. Fails on
3506                          * non-Sparc architectures */
3507                         ret = fd_eject(UNIT(drive));
3508
3509                         USETF(FD_DISK_CHANGED);
3510                         USETF(FD_VERIFY);
3511                         process_fd_request();
3512                         return ret;
3513                 case FDCLRPRM:
3514                         LOCK_FDC(drive, 1);
3515                         current_type[drive] = NULL;
3516                         floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3517                         UDRS->keep_data = 0;
3518                         return invalidate_drive(inode->i_bdev);
3519                 case FDSETPRM:
3520                 case FDDEFPRM:
3521                         return set_geometry(cmd, &inparam.g,
3522                                             drive, type, inode->i_bdev);
3523                 case FDGETPRM:
3524                         ECALL(get_floppy_geometry(drive, type,
3525                                                   (struct floppy_struct **)
3526                                                   &outparam));
3527                         break;
3528
3529                 case FDMSGON:
3530                         UDP->flags |= FTD_MSG;
3531                         return 0;
3532                 case FDMSGOFF:
3533                         UDP->flags &= ~FTD_MSG;
3534                         return 0;
3535
3536                 case FDFMTBEG:
3537                         LOCK_FDC(drive, 1);
3538                         CALL(poll_drive(1, FD_RAW_NEED_DISK));
3539                         ret = UDRS->flags;
3540                         process_fd_request();
3541                         if (ret & FD_VERIFY)
3542                                 return -ENODEV;
3543                         if (!(ret & FD_DISK_WRITABLE))
3544                                 return -EROFS;
3545                         return 0;
3546                 case FDFMTTRK:
3547                         if (UDRS->fd_ref != 1)
3548                                 return -EBUSY;
3549                         return do_format(drive, &inparam.f);
3550                 case FDFMTEND:
3551                 case FDFLUSH:
3552                         LOCK_FDC(drive, 1);
3553                         return invalidate_drive(inode->i_bdev);
3554
3555                 case FDSETEMSGTRESH:
3556                         UDP->max_errors.reporting =
3557                             (unsigned short)(param & 0x0f);
3558                         return 0;
3559                         OUT(FDGETMAXERRS, &UDP->max_errors);
3560                         IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
3561
3562                 case FDGETDRVTYP:
3563                         outparam = drive_name(type, drive);
3564                         SUPBOUND(size, strlen(outparam) + 1);
3565                         break;
3566
3567                         IN(FDSETDRVPRM, UDP, dp);
3568                         OUT(FDGETDRVPRM, UDP);
3569
3570                 case FDPOLLDRVSTAT:
3571                         LOCK_FDC(drive, 1);
3572                         CALL(poll_drive(1, FD_RAW_NEED_DISK));
3573                         process_fd_request();
3574                         /* fall through */
3575                         OUT(FDGETDRVSTAT, UDRS);
3576
3577                 case FDRESET:
3578                         return user_reset_fdc(drive, (int)param, 1);
3579
3580                         OUT(FDGETFDCSTAT, UFDCS);
3581
3582                 case FDWERRORCLR:
3583                         CLEARSTRUCT(UDRWE);
3584                         return 0;
3585                         OUT(FDWERRORGET, UDRWE);
3586
3587                 case FDRAWCMD:
3588                         if (type)
3589                                 return -EINVAL;
3590                         LOCK_FDC(drive, 1);
3591                         set_floppy(drive);
3592                         CALL(i = raw_cmd_ioctl(cmd, (void __user *)param));
3593                         process_fd_request();
3594                         return i;
3595
3596                 case FDTWADDLE:
3597                         LOCK_FDC(drive, 1);
3598                         twaddle();
3599                         process_fd_request();
3600                         return 0;
3601
3602                 default:
3603                         return -EINVAL;
3604                 }
3605
3606         if (_IOC_DIR(cmd) & _IOC_READ)
3607                 return fd_copyout((void __user *)param, outparam, size);
3608         else
3609                 return 0;
3610 #undef OUT
3611 #undef IN
3612 }
3613
3614 static void __init config_types(void)
3615 {
3616         int first = 1;
3617         int drive;
3618
3619         /* read drive info out of physical CMOS */
3620         drive = 0;
3621         if (!UDP->cmos)
3622                 UDP->cmos = FLOPPY0_TYPE;
3623         drive = 1;
3624         if (!UDP->cmos && FLOPPY1_TYPE)
3625                 UDP->cmos = FLOPPY1_TYPE;
3626
3627         /* XXX */
3628         /* additional physical CMOS drive detection should go here */
3629
3630         for (drive = 0; drive < N_DRIVE; drive++) {
3631                 unsigned int type = UDP->cmos;
3632                 struct floppy_drive_params *params;
3633                 const char *name = NULL;
3634                 static char temparea[32];
3635
3636                 if (type < ARRAY_SIZE(default_drive_params)) {
3637                         params = &default_drive_params[type].params;
3638                         if (type) {
3639                                 name = default_drive_params[type].name;
3640                                 allowed_drive_mask |= 1 << drive;
3641                         } else
3642                                 allowed_drive_mask &= ~(1 << drive);
3643                 } else {
3644                         params = &default_drive_params[0].params;
3645                         sprintf(temparea, "unknown type %d (usb?)", type);
3646                         name = temparea;
3647                 }
3648                 if (name) {
3649                         const char *prepend = ",";
3650                         if (first) {
3651                                 prepend = KERN_INFO "Floppy drive(s):";
3652                                 first = 0;
3653                         }
3654                         printk("%s fd%d is %s", prepend, drive, name);
3655                 }
3656                 *UDP = *params;
3657         }
3658         if (!first)
3659                 printk("\n");
3660 }
3661
3662 static int floppy_release(struct inode *inode, struct file *filp)
3663 {
3664         int drive = (long)inode->i_bdev->bd_disk->private_data;
3665
3666         mutex_lock(&open_lock);
3667         if (UDRS->fd_ref < 0)
3668                 UDRS->fd_ref = 0;
3669         else if (!UDRS->fd_ref--) {
3670                 DPRINT("floppy_release with fd_ref == 0");
3671                 UDRS->fd_ref = 0;
3672         }
3673         if (!UDRS->fd_ref)
3674                 opened_bdev[drive] = NULL;
3675         mutex_unlock(&open_lock);
3676
3677         return 0;
3678 }
3679
3680 /*
3681  * floppy_open check for aliasing (/dev/fd0 can be the same as
3682  * /dev/PS0 etc), and disallows simultaneous access to the same
3683  * drive with different device numbers.
3684  */
3685 static int floppy_open(struct inode *inode, struct file *filp)
3686 {
3687         int drive = (long)inode->i_bdev->bd_disk->private_data;
3688         int old_dev;
3689         int try;
3690         int res = -EBUSY;
3691         char *tmp;
3692
3693         filp->private_data = (void *)0;
3694         mutex_lock(&open_lock);
3695         old_dev = UDRS->fd_device;
3696         if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
3697                 goto out2;
3698
3699         if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
3700                 USETF(FD_DISK_CHANGED);
3701                 USETF(FD_VERIFY);
3702         }
3703
3704         if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (filp->f_flags & O_EXCL)))
3705                 goto out2;
3706
3707         if (filp->f_flags & O_EXCL)
3708                 UDRS->fd_ref = -1;
3709         else
3710                 UDRS->fd_ref++;
3711
3712         opened_bdev[drive] = inode->i_bdev;
3713
3714         res = -ENXIO;
3715
3716         if (!floppy_track_buffer) {
3717                 /* if opening an ED drive, reserve a big buffer,
3718                  * else reserve a small one */
3719                 if ((UDP->cmos == 6) || (UDP->cmos == 5))
3720                         try = 64;       /* Only 48 actually useful */
3721                 else
3722                         try = 32;       /* Only 24 actually useful */
3723
3724                 tmp = (char *)fd_dma_mem_alloc(1024 * try);
3725                 if (!tmp && !floppy_track_buffer) {
3726                         try >>= 1;      /* buffer only one side */
3727                         INFBOUND(try, 16);
3728                         tmp = (char *)fd_dma_mem_alloc(1024 * try);
3729                 }
3730                 if (!tmp && !floppy_track_buffer) {
3731                         fallback_on_nodma_alloc(&tmp, 2048 * try);
3732                 }
3733                 if (!tmp && !floppy_track_buffer) {
3734                         DPRINT("Unable to allocate DMA memory\n");
3735                         goto out;
3736                 }
3737                 if (floppy_track_buffer) {
3738                         if (tmp)
3739                                 fd_dma_mem_free((unsigned long)tmp, try * 1024);
3740                 } else {
3741                         buffer_min = buffer_max = -1;
3742                         floppy_track_buffer = tmp;
3743                         max_buffer_sectors = try;
3744                 }
3745         }
3746
3747         UDRS->fd_device = iminor(inode);
3748         set_capacity(disks[drive], floppy_sizes[iminor(inode)]);
3749         if (old_dev != -1 && old_dev != iminor(inode)) {
3750                 if (buffer_drive == drive)
3751                         buffer_track = -1;
3752         }
3753
3754         /* Allow ioctls if we have write-permissions even if read-only open.
3755          * Needed so that programs such as fdrawcmd still can work on write
3756          * protected disks */
3757         if ((filp->f_mode & FMODE_WRITE) || !file_permission(filp, MAY_WRITE))
3758                 filp->private_data = (void *)8;
3759
3760         if (UFDCS->rawcmd == 1)
3761                 UFDCS->rawcmd = 2;
3762
3763         if (!(filp->f_flags & O_NDELAY)) {
3764                 if (filp->f_mode & 3) {
3765                         UDRS->last_checked = 0;
3766                         check_disk_change(inode->i_bdev);
3767                         if (UTESTF(FD_DISK_CHANGED))
3768                                 goto out;
3769                 }
3770                 res = -EROFS;
3771                 if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
3772                         goto out;
3773         }
3774         mutex_unlock(&open_lock);
3775         return 0;
3776 out:
3777         if (UDRS->fd_ref < 0)
3778                 UDRS->fd_ref = 0;
3779         else
3780                 UDRS->fd_ref--;
3781         if (!UDRS->fd_ref)
3782                 opened_bdev[drive] = NULL;
3783 out2:
3784         mutex_unlock(&open_lock);
3785         return res;
3786 }
3787
3788 /*
3789  * Check if the disk has been changed or if a change has been faked.
3790  */
3791 static int check_floppy_change(struct gendisk *disk)
3792 {
3793         int drive = (long)disk->private_data;
3794
3795         if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
3796                 return 1;
3797
3798         if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
3799                 lock_fdc(drive, 0);
3800                 poll_drive(0, 0);
3801                 process_fd_request();
3802         }
3803
3804         if (UTESTF(FD_DISK_CHANGED) ||
3805             UTESTF(FD_VERIFY) ||
3806             test_bit(drive, &fake_change) ||
3807             (!ITYPE(UDRS->fd_device) && !current_type[drive]))
3808                 return 1;
3809         return 0;
3810 }
3811
3812 /*
3813  * This implements "read block 0" for floppy_revalidate().
3814  * Needed for format autodetection, checking whether there is
3815  * a disk in the drive, and whether that disk is writable.
3816  */
3817
3818 static int floppy_rb0_complete(struct bio *bio, unsigned int bytes_done,
3819                                int err)
3820 {
3821         if (bio->bi_size)
3822                 return 1;
3823
3824         complete((struct completion *)bio->bi_private);
3825         return 0;
3826 }
3827
3828 static int __floppy_read_block_0(struct block_device *bdev)
3829 {
3830         struct bio bio;
3831         struct bio_vec bio_vec;
3832         struct completion complete;
3833         struct page *page;
3834         size_t size;
3835
3836         page = alloc_page(GFP_NOIO);
3837         if (!page) {
3838                 process_fd_request();
3839                 return -ENOMEM;
3840         }
3841
3842         size = bdev->bd_block_size;
3843         if (!size)
3844                 size = 1024;
3845
3846         bio_init(&bio);
3847         bio.bi_io_vec = &bio_vec;
3848         bio_vec.bv_page = page;
3849         bio_vec.bv_len = size;
3850         bio_vec.bv_offset = 0;
3851         bio.bi_vcnt = 1;
3852         bio.bi_idx = 0;
3853         bio.bi_size = size;
3854         bio.bi_bdev = bdev;
3855         bio.bi_sector = 0;
3856         init_completion(&complete);
3857         bio.bi_private = &complete;
3858         bio.bi_end_io = floppy_rb0_complete;
3859
3860         submit_bio(READ, &bio);
3861         generic_unplug_device(bdev_get_queue(bdev));
3862         process_fd_request();
3863         wait_for_completion(&complete);
3864
3865         __free_page(page);
3866
3867         return 0;
3868 }
3869
3870 /* revalidate the floppy disk, i.e. trigger format autodetection by reading
3871  * the bootblock (block 0). "Autodetection" is also needed to check whether
3872  * there is a disk in the drive at all... Thus we also do it for fixed
3873  * geometry formats */
3874 static int floppy_revalidate(struct gendisk *disk)
3875 {
3876         int drive = (long)disk->private_data;
3877 #define NO_GEOM (!current_type[drive] && !ITYPE(UDRS->fd_device))
3878         int cf;
3879         int res = 0;
3880
3881         if (UTESTF(FD_DISK_CHANGED) ||
3882             UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
3883                 if (usage_count == 0) {
3884                         printk("VFS: revalidate called on non-open device.\n");
3885                         return -EFAULT;
3886                 }
3887                 lock_fdc(drive, 0);
3888                 cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
3889                 if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
3890                         process_fd_request();   /*already done by another thread */
3891                         return 0;
3892                 }
3893                 UDRS->maxblock = 0;
3894                 UDRS->maxtrack = 0;
3895                 if (buffer_drive == drive)
3896                         buffer_track = -1;
3897                 clear_bit(drive, &fake_change);
3898                 UCLEARF(FD_DISK_CHANGED);
3899                 if (cf)
3900                         UDRS->generation++;
3901                 if (NO_GEOM) {
3902                         /* auto-sensing */
3903                         res = __floppy_read_block_0(opened_bdev[drive]);
3904                 } else {
3905                         if (cf)
3906                                 poll_drive(0, FD_RAW_NEED_DISK);
3907                         process_fd_request();
3908                 }
3909         }
3910         set_capacity(disk, floppy_sizes[UDRS->fd_device]);
3911         return res;
3912 }
3913
3914 static struct block_device_operations floppy_fops = {
3915         .owner          = THIS_MODULE,
3916         .open           = floppy_open,
3917         .release        = floppy_release,
3918         .ioctl          = fd_ioctl,
3919         .getgeo         = fd_getgeo,
3920         .media_changed  = check_floppy_change,
3921         .revalidate_disk = floppy_revalidate,
3922 };
3923
3924 /*
3925  * Floppy Driver initialization
3926  * =============================
3927  */
3928
3929 /* Determine the floppy disk controller type */
3930 /* This routine was written by David C. Niemi */
3931 static char __init get_fdc_version(void)
3932 {
3933         int r;
3934
3935         output_byte(FD_DUMPREGS);       /* 82072 and better know DUMPREGS */
3936         if (FDCS->reset)
3937                 return FDC_NONE;
3938         if ((r = result()) <= 0x00)
3939                 return FDC_NONE;        /* No FDC present ??? */
3940         if ((r == 1) && (reply_buffer[0] == 0x80)) {
3941                 printk(KERN_INFO "FDC %d is an 8272A\n", fdc);
3942                 return FDC_8272A;       /* 8272a/765 don't know DUMPREGS */
3943         }
3944         if (r != 10) {
3945                 printk
3946                     ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
3947                      fdc, r);
3948                 return FDC_UNKNOWN;
3949         }
3950
3951         if (!fdc_configure()) {
3952                 printk(KERN_INFO "FDC %d is an 82072\n", fdc);
3953                 return FDC_82072;       /* 82072 doesn't know CONFIGURE */
3954         }
3955
3956         output_byte(FD_PERPENDICULAR);
3957         if (need_more_output() == MORE_OUTPUT) {
3958                 output_byte(0);
3959         } else {
3960                 printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
3961                 return FDC_82072A;      /* 82072A as found on Sparcs. */
3962         }
3963
3964         output_byte(FD_UNLOCK);
3965         r = result();
3966         if ((r == 1) && (reply_buffer[0] == 0x80)) {
3967                 printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
3968                 return FDC_82077_ORIG;  /* Pre-1991 82077, doesn't know
3969                                          * LOCK/UNLOCK */
3970         }
3971         if ((r != 1) || (reply_buffer[0] != 0x00)) {
3972                 printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
3973                        fdc, r);
3974                 return FDC_UNKNOWN;
3975         }
3976         output_byte(FD_PARTID);
3977         r = result();
3978         if (r != 1) {
3979                 printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
3980                        fdc, r);
3981                 return FDC_UNKNOWN;
3982         }
3983         if (reply_buffer[0] == 0x80) {
3984                 printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);
3985                 return FDC_82077;       /* Revised 82077AA passes all the tests */
3986         }
3987         switch (reply_buffer[0] >> 5) {
3988         case 0x0:
3989                 /* Either a 82078-1 or a 82078SL running at 5Volt */
3990                 printk(KERN_INFO "FDC %d is an 82078.\n", fdc);
3991                 return FDC_82078;
3992         case 0x1:
3993                 printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);
3994                 return FDC_82078;
3995         case 0x2:
3996                 printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
3997                 return FDC_S82078B;
3998         case 0x3:
3999                 printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",
4000                        fdc);
4001                 return FDC_87306;
4002         default:
4003                 printk(KERN_INFO
4004                        "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
4005                        fdc, reply_buffer[0] >> 5);
4006                 return FDC_82078_UNKN;
4007         }
4008 }                               /* get_fdc_version */
4009
4010 /* lilo configuration */
4011
4012 static void __init floppy_set_flags(int *ints, int param, int param2)
4013 {
4014         int i;
4015
4016         for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4017                 if (param)
4018                         default_drive_params[i].params.flags |= param2;
4019                 else
4020                         default_drive_params[i].params.flags &= ~param2;
4021         }
4022         DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4023 }
4024
4025 static void __init daring(int *ints, int param, int param2)
4026 {
4027         int i;
4028
4029         for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4030                 if (param) {
4031                         default_drive_params[i].params.select_delay = 0;
4032                         default_drive_params[i].params.flags |=
4033                             FD_SILENT_DCL_CLEAR;
4034                 } else {
4035                         default_drive_params[i].params.select_delay =
4036                             2 * HZ / 100;
4037                         default_drive_params[i].params.flags &=
4038                             ~FD_SILENT_DCL_CLEAR;
4039                 }
4040         }
4041         DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4042 }
4043
4044 static void __init set_cmos(int *ints, int dummy, int dummy2)
4045 {
4046         int current_drive = 0;
4047
4048         if (ints[0] != 2) {
4049                 DPRINT("wrong number of parameters for CMOS\n");
4050                 return;
4051         }
4052         current_drive = ints[1];
4053         if (current_drive < 0 || current_drive >= 8) {
4054                 DPRINT("bad drive for set_cmos\n");
4055                 return;
4056         }
4057 #if N_FDC > 1
4058         if (current_drive >= 4 && !FDC2)
4059                 FDC2 = 0x370;
4060 #endif
4061         DP->cmos = ints[2];
4062         DPRINT("setting CMOS code to %d\n", ints[2]);
4063 }
4064
4065 static struct param_table {
4066         const char *name;
4067         void (*fn) (int *ints, int param, int param2);
4068         int *var;
4069         int def_param;
4070         int param2;
4071 } config_params[] __initdata = {
4072         {"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0}, /* obsolete */
4073         {"all_drives", NULL, &allowed_drive_mask, 0xff, 0},     /* obsolete */
4074         {"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
4075         {"irq", NULL, &FLOPPY_IRQ, 6, 0},
4076         {"dma", NULL, &FLOPPY_DMA, 2, 0},
4077         {"daring", daring, NULL, 1, 0},
4078 #if N_FDC > 1
4079         {"two_fdc", NULL, &FDC2, 0x370, 0},
4080         {"one_fdc", NULL, &FDC2, 0, 0},
4081 #endif
4082         {"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
4083         {"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
4084         {"messages", floppy_set_flags, NULL, 1, FTD_MSG},
4085         {"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
4086         {"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
4087         {"nodma", NULL, &can_use_virtual_dma, 1, 0},
4088         {"omnibook", NULL, &can_use_virtual_dma, 1, 0},
4089         {"yesdma", NULL, &can_use_virtual_dma, 0, 0},
4090         {"fifo_depth", NULL, &fifo_depth, 0xa, 0},
4091         {"nofifo", NULL, &no_fifo, 0x20, 0},
4092         {"usefifo", NULL, &no_fifo, 0, 0},
4093         {"cmos", set_cmos, NULL, 0, 0},
4094         {"slow", NULL, &slow_floppy, 1, 0},
4095         {"unexpected_interrupts", NULL, &print_unex, 1, 0},
4096         {"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
4097         {"L40SX", NULL, &print_unex, 0, 0}
4098
4099         EXTRA_FLOPPY_PARAMS
4100 };
4101
4102 static int __init floppy_setup(char *str)
4103 {
4104         int i;
4105         int param;
4106         int ints[11];
4107
4108         str = get_options(str, ARRAY_SIZE(ints), ints);
4109         if (str) {
4110                 for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4111                         if (strcmp(str, config_params[i].name) == 0) {
4112                                 if (ints[0])
4113                                         param = ints[1];
4114                                 else
4115                                         param = config_params[i].def_param;
4116                                 if (config_params[i].fn)
4117                                         config_params[i].
4118                                             fn(ints, param,
4119                                                config_params[i].param2);
4120                                 if (config_params[i].var) {
4121                                         DPRINT("%s=%d\n", str, param);
4122                                         *config_params[i].var = param;
4123                                 }
4124                                 return 1;
4125                         }
4126                 }
4127         }
4128         if (str) {
4129                 DPRINT("unknown floppy option [%s]\n", str);
4130
4131                 DPRINT("allowed options are:");
4132                 for (i = 0; i < ARRAY_SIZE(config_params); i++)
4133                         printk(" %s", config_params[i].name);
4134                 printk("\n");
4135         } else
4136                 DPRINT("botched floppy option\n");
4137         DPRINT("Read Documentation/floppy.txt\n");
4138         return 0;
4139 }
4140
4141 static int have_no_fdc = -ENODEV;
4142
4143 static ssize_t floppy_cmos_show(struct device *dev,
4144                                 struct device_attribute *attr, char *buf)
4145 {
4146         struct platform_device *p;
4147         int drive;
4148
4149         p = container_of(dev, struct platform_device,dev);
4150         drive = p->id;
4151         return sprintf(buf, "%X\n", UDP->cmos);
4152 }
4153 DEVICE_ATTR(cmos,S_IRUGO,floppy_cmos_show,NULL);
4154
4155 static void floppy_device_release(struct device *dev)
4156 {
4157         complete(&device_release);
4158 }
4159
4160 static struct platform_device floppy_device[N_DRIVE];
4161
4162 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4163 {
4164         int drive = (*part & 3) | ((*part & 0x80) >> 5);
4165         if (drive >= N_DRIVE ||
4166             !(allowed_drive_mask & (1 << drive)) ||
4167             fdc_state[FDC(drive)].version == FDC_NONE)
4168                 return NULL;
4169         if (((*part >> 2) & 0x1f) >= ARRAY_SIZE(floppy_type))
4170                 return NULL;
4171         *part = 0;
4172         return get_disk(disks[drive]);
4173 }
4174
4175 static int __init floppy_init(void)
4176 {
4177         int i, unit, drive;
4178         int err, dr;
4179
4180         raw_cmd = NULL;
4181
4182         for (dr = 0; dr < N_DRIVE; dr++) {
4183                 disks[dr] = alloc_disk(1);
4184                 if (!disks[dr]) {
4185                         err = -ENOMEM;
4186                         goto out_put_disk;
4187                 }
4188
4189                 disks[dr]->major = FLOPPY_MAJOR;
4190                 disks[dr]->first_minor = TOMINOR(dr);
4191                 disks[dr]->fops = &floppy_fops;
4192                 sprintf(disks[dr]->disk_name, "fd%d", dr);
4193
4194                 init_timer(&motor_off_timer[dr]);
4195                 motor_off_timer[dr].data = dr;
4196                 motor_off_timer[dr].function = motor_off_callback;
4197         }
4198
4199         err = register_blkdev(FLOPPY_MAJOR, "fd");
4200         if (err)
4201                 goto out_put_disk;
4202
4203         floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
4204         if (!floppy_queue) {
4205                 err = -ENOMEM;
4206                 goto out_unreg_blkdev;
4207         }
4208         blk_queue_max_sectors(floppy_queue, 64);
4209
4210         blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4211                             floppy_find, NULL, NULL);
4212
4213         for (i = 0; i < 256; i++)
4214                 if (ITYPE(i))
4215                         floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4216                 else
4217                         floppy_sizes[i] = MAX_DISK_SIZE << 1;
4218
4219         reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
4220         config_types();
4221
4222         for (i = 0; i < N_FDC; i++) {
4223                 fdc = i;
4224                 CLEARSTRUCT(FDCS);
4225                 FDCS->dtr = -1;
4226                 FDCS->dor = 0x4;
4227 #if defined(__sparc__) || defined(__mc68000__)
4228                 /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
4229 #ifdef __mc68000__
4230                 if (MACH_IS_SUN3X)
4231 #endif
4232                         FDCS->version = FDC_82072A;
4233 #endif
4234         }
4235
4236         use_virtual_dma = can_use_virtual_dma & 1;
4237 #if defined(CONFIG_PPC_MERGE)
4238         if (check_legacy_ioport(FDC1)) {
4239                 del_timer(&fd_timeout);
4240                 err = -ENODEV;
4241                 goto out_unreg_region;
4242         }
4243 #endif
4244         fdc_state[0].address = FDC1;
4245         if (fdc_state[0].address == -1) {
4246                 del_timer(&fd_timeout);
4247                 err = -ENODEV;
4248                 goto out_unreg_region;
4249         }
4250 #if N_FDC > 1
4251         fdc_state[1].address = FDC2;
4252 #endif
4253
4254         fdc = 0;                /* reset fdc in case of unexpected interrupt */
4255         err = floppy_grab_irq_and_dma();
4256         if (err) {
4257                 del_timer(&fd_timeout);
4258                 err = -EBUSY;
4259                 goto out_unreg_region;
4260         }
4261
4262         /* initialise drive state */
4263         for (drive = 0; drive < N_DRIVE; drive++) {
4264                 CLEARSTRUCT(UDRS);
4265                 CLEARSTRUCT(UDRWE);
4266                 USETF(FD_DISK_NEWCHANGE);
4267                 USETF(FD_DISK_CHANGED);
4268                 USETF(FD_VERIFY);
4269                 UDRS->fd_device = -1;
4270                 floppy_track_buffer = NULL;
4271                 max_buffer_sectors = 0;
4272         }
4273         /*
4274          * Small 10 msec delay to let through any interrupt that
4275          * initialization might have triggered, to not
4276          * confuse detection:
4277          */
4278         msleep(10);
4279
4280         for (i = 0; i < N_FDC; i++) {
4281                 fdc = i;
4282                 FDCS->driver_version = FD_DRIVER_VERSION;
4283                 for (unit = 0; unit < 4; unit++)
4284                         FDCS->track[unit] = 0;
4285                 if (FDCS->address == -1)
4286                         continue;
4287                 FDCS->rawcmd = 2;
4288                 if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
4289                         /* free ioports reserved by floppy_grab_irq_and_dma() */
4290                         release_region(FDCS->address + 2, 4);
4291                         release_region(FDCS->address + 7, 1);
4292                         FDCS->address = -1;
4293                         FDCS->version = FDC_NONE;
4294                         continue;
4295                 }
4296                 /* Try to determine the floppy controller type */
4297                 FDCS->version = get_fdc_version();
4298                 if (FDCS->version == FDC_NONE) {
4299                         /* free ioports reserved by floppy_grab_irq_and_dma() */
4300                         release_region(FDCS->address + 2, 4);
4301                         release_region(FDCS->address + 7, 1);
4302                         FDCS->address = -1;
4303                         continue;
4304                 }
4305                 if (can_use_virtual_dma == 2 && FDCS->version < FDC_82072A)
4306                         can_use_virtual_dma = 0;
4307
4308                 have_no_fdc = 0;
4309                 /* Not all FDCs seem to be able to handle the version command
4310                  * properly, so force a reset for the standard FDC clones,
4311                  * to avoid interrupt garbage.
4312                  */
4313                 user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
4314         }
4315         fdc = 0;
4316         del_timer(&fd_timeout);
4317         current_drive = 0;
4318         initialising = 0;
4319         if (have_no_fdc) {
4320                 DPRINT("no floppy controllers found\n");
4321                 err = have_no_fdc;
4322                 goto out_flush_work;
4323         }
4324
4325         for (drive = 0; drive < N_DRIVE; drive++) {
4326                 if (!(allowed_drive_mask & (1 << drive)))
4327                         continue;
4328                 if (fdc_state[FDC(drive)].version == FDC_NONE)
4329                         continue;
4330
4331                 floppy_device[drive].name = floppy_device_name;
4332                 floppy_device[drive].id = drive;
4333                 floppy_device[drive].dev.release = floppy_device_release;
4334
4335                 err = platform_device_register(&floppy_device[drive]);
4336                 if (err)
4337                         goto out_flush_work;
4338
4339                 device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
4340                 /* to be cleaned up... */
4341                 disks[drive]->private_data = (void *)(long)drive;
4342                 disks[drive]->queue = floppy_queue;
4343                 disks[drive]->flags |= GENHD_FL_REMOVABLE;
4344                 disks[drive]->driverfs_dev = &floppy_device[drive].dev;
4345                 add_disk(disks[drive]);
4346         }
4347
4348         return 0;
4349
4350 out_flush_work:
4351         flush_scheduled_work();
4352         if (usage_count)
4353                 floppy_release_irq_and_dma();
4354 out_unreg_region:
4355         blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4356         blk_cleanup_queue(floppy_queue);
4357 out_unreg_blkdev:
4358         unregister_blkdev(FLOPPY_MAJOR, "fd");
4359 out_put_disk:
4360         while (dr--) {
4361                 del_timer(&motor_off_timer[dr]);
4362                 put_disk(disks[dr]);
4363         }
4364         return err;
4365 }
4366
4367 static DEFINE_SPINLOCK(floppy_usage_lock);
4368
4369 static int floppy_grab_irq_and_dma(void)
4370 {
4371         unsigned long flags;
4372
4373         spin_lock_irqsave(&floppy_usage_lock, flags);
4374         if (usage_count++) {
4375                 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4376                 return 0;
4377         }
4378         spin_unlock_irqrestore(&floppy_usage_lock, flags);
4379
4380         /*
4381          * We might have scheduled a free_irq(), wait it to
4382          * drain first:
4383          */
4384         flush_scheduled_work();
4385
4386         if (fd_request_irq()) {
4387                 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4388                        FLOPPY_IRQ);
4389                 spin_lock_irqsave(&floppy_usage_lock, flags);
4390                 usage_count--;
4391                 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4392                 return -1;
4393         }
4394         if (fd_request_dma()) {
4395                 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4396                        FLOPPY_DMA);
4397                 fd_free_irq();
4398                 spin_lock_irqsave(&floppy_usage_lock, flags);
4399                 usage_count--;
4400                 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4401                 return -1;
4402         }
4403
4404         for (fdc = 0; fdc < N_FDC; fdc++) {
4405                 if (FDCS->address != -1) {
4406                         if (!request_region(FDCS->address + 2, 4, "floppy")) {
4407                                 DPRINT("Floppy io-port 0x%04lx in use\n",
4408                                        FDCS->address + 2);
4409                                 goto cleanup1;
4410                         }
4411                         if (!request_region(FDCS->address + 7, 1, "floppy DIR")) {
4412                                 DPRINT("Floppy io-port 0x%04lx in use\n",
4413                                        FDCS->address + 7);
4414                                 goto cleanup2;
4415                         }
4416                         /* address + 6 is reserved, and may be taken by IDE.
4417                          * Unfortunately, Adaptec doesn't know this :-(, */
4418                 }
4419         }
4420         for (fdc = 0; fdc < N_FDC; fdc++) {
4421                 if (FDCS->address != -1) {
4422                         reset_fdc_info(1);
4423                         fd_outb(FDCS->dor, FD_DOR);
4424                 }
4425         }
4426         fdc = 0;
4427         set_dor(0, ~0, 8);      /* avoid immediate interrupt */
4428
4429         for (fdc = 0; fdc < N_FDC; fdc++)
4430                 if (FDCS->address != -1)
4431                         fd_outb(FDCS->dor, FD_DOR);
4432         /*
4433          *      The driver will try and free resources and relies on us
4434          *      to know if they were allocated or not.
4435          */
4436         fdc = 0;
4437         irqdma_allocated = 1;
4438         return 0;
4439 cleanup2:
4440         release_region(FDCS->address + 2, 4);
4441 cleanup1:
4442         fd_free_irq();
4443         fd_free_dma();
4444         while (--fdc >= 0) {
4445                 release_region(FDCS->address + 2, 4);
4446                 release_region(FDCS->address + 7, 1);
4447         }
4448         spin_lock_irqsave(&floppy_usage_lock, flags);
4449         usage_count--;
4450         spin_unlock_irqrestore(&floppy_usage_lock, flags);
4451         return -1;
4452 }
4453
4454 static void floppy_release_irq_and_dma(void)
4455 {
4456         int old_fdc;
4457 #ifdef FLOPPY_SANITY_CHECK
4458 #ifndef __sparc__
4459         int drive;
4460 #endif
4461 #endif
4462         long tmpsize;
4463         unsigned long tmpaddr;
4464         unsigned long flags;
4465
4466         spin_lock_irqsave(&floppy_usage_lock, flags);
4467         if (--usage_count) {
4468                 spin_unlock_irqrestore(&floppy_usage_lock, flags);
4469                 return;
4470         }
4471         spin_unlock_irqrestore(&floppy_usage_lock, flags);
4472         if (irqdma_allocated) {
4473                 fd_disable_dma();
4474                 fd_free_dma();
4475                 fd_free_irq();
4476                 irqdma_allocated = 0;
4477         }
4478         set_dor(0, ~0, 8);
4479 #if N_FDC > 1
4480         set_dor(1, ~8, 0);
4481 #endif
4482         floppy_enable_hlt();
4483
4484         if (floppy_track_buffer && max_buffer_sectors) {
4485                 tmpsize = max_buffer_sectors * 1024;
4486                 tmpaddr = (unsigned long)floppy_track_buffer;
4487                 floppy_track_buffer = NULL;
4488                 max_buffer_sectors = 0;
4489                 buffer_min = buffer_max = -1;
4490                 fd_dma_mem_free(tmpaddr, tmpsize);
4491         }
4492 #ifdef FLOPPY_SANITY_CHECK
4493 #ifndef __sparc__
4494         for (drive = 0; drive < N_FDC * 4; drive++)
4495                 if (timer_pending(motor_off_timer + drive))
4496                         printk("motor off timer %d still active\n", drive);
4497 #endif
4498
4499         if (timer_pending(&fd_timeout))
4500                 printk("floppy timer still active:%s\n", timeout_message);
4501         if (timer_pending(&fd_timer))
4502                 printk("auxiliary floppy timer still active\n");
4503         if (floppy_work.pending)
4504                 printk("work still pending\n");
4505 #endif
4506         old_fdc = fdc;
4507         for (fdc = 0; fdc < N_FDC; fdc++)
4508                 if (FDCS->address != -1) {
4509                         release_region(FDCS->address + 2, 4);
4510                         release_region(FDCS->address + 7, 1);
4511                 }
4512         fdc = old_fdc;
4513 }
4514
4515 #ifdef MODULE
4516
4517 static char *floppy;
4518
4519 static void __init parse_floppy_cfg_string(char *cfg)
4520 {
4521         char *ptr;
4522
4523         while (*cfg) {
4524                 for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != '\t'; cfg++) ;
4525                 if (*cfg) {
4526                         *cfg = '\0';
4527                         cfg++;
4528                 }
4529                 if (*ptr)
4530                         floppy_setup(ptr);
4531         }
4532 }
4533
4534 int __init init_module(void)
4535 {
4536         if (floppy)
4537                 parse_floppy_cfg_string(floppy);
4538         return floppy_init();
4539 }
4540
4541 void cleanup_module(void)
4542 {
4543         int drive;
4544
4545         init_completion(&device_release);
4546         blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4547         unregister_blkdev(FLOPPY_MAJOR, "fd");
4548
4549         for (drive = 0; drive < N_DRIVE; drive++) {
4550                 del_timer_sync(&motor_off_timer[drive]);
4551
4552                 if ((allowed_drive_mask & (1 << drive)) &&
4553                     fdc_state[FDC(drive)].version != FDC_NONE) {
4554                         del_gendisk(disks[drive]);
4555                         device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
4556                         platform_device_unregister(&floppy_device[drive]);
4557                 }
4558                 put_disk(disks[drive]);
4559         }
4560
4561         del_timer_sync(&fd_timeout);
4562         del_timer_sync(&fd_timer);
4563         blk_cleanup_queue(floppy_queue);
4564
4565         if (usage_count)
4566                 floppy_release_irq_and_dma();
4567
4568         /* eject disk, if any */
4569         fd_eject(0);
4570
4571         wait_for_completion(&device_release);
4572 }
4573
4574 module_param(floppy, charp, 0);
4575 module_param(FLOPPY_IRQ, int, 0);
4576 module_param(FLOPPY_DMA, int, 0);
4577 MODULE_AUTHOR("Alain L. Knaff");
4578 MODULE_SUPPORTED_DEVICE("fd");
4579 MODULE_LICENSE("GPL");
4580
4581 #else
4582
4583 __setup("floppy=", floppy_setup);
4584 module_init(floppy_init)
4585 #endif
4586
4587 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);