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