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