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

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