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