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
 195 /*
 196  * PS/2 floppies have much slower step rates than regular floppies.
 197  * It's been recommended that take about 1/4 of the default speed
 198  * in some more extreme cases.
 199  */
 200 static DEFINE_MUTEX(floppy_mutex);
 201 static int slow_floppy;
 202
 203 #include <asm/dma.h>
 204 #include <asm/irq.h>
 205
 206 static int FLOPPY_IRQ = 6;
 207 static int FLOPPY_DMA = 2;
 208 static int can_use_virtual_dma = 2;
 209 /* =======
 210  * can use virtual DMA:
 211  * 0 = use of virtual DMA disallowed by config
 212  * 1 = use of virtual DMA prescribed by config
 213  * 2 = no virtual DMA preference configured.  By default try hard DMA,
 214  * but fall back on virtual DMA when not enough memory available
 215  */
 216
 217 static int use_virtual_dma;
 218 /* =======
 219  * use virtual DMA
 220  * 0 using hard DMA
 221  * 1 using virtual DMA
 222  * This variable is set to virtual when a DMA mem problem arises, and
 223  * reset back in floppy_grab_irq_and_dma.
 224  * It is not safe to reset it in other circumstances, because the floppy
 225  * driver may have several buffers in use at once, and we do currently not
 226  * record each buffers capabilities
 227  */
 228
 229 static DEFINE_SPINLOCK(floppy_lock);
 230
 231 static unsigned short virtual_dma_port = 0x3f0;
 232 irqreturn_t floppy_interrupt(int irq, void *dev_id);
 233 static int set_dor(int fdc, char mask, char data);
 234
 235 #define K_64    0x10000         /* 64KB */
 236
 237 /* the following is the mask of allowed drives. By default units 2 and
 238  * 3 of both floppy controllers are disabled, because switching on the
 239  * motor of these drives causes system hangs on some PCI computers. drive
 240  * 0 is the low bit (0x1), and drive 7 is the high bit (0x80). Bits are on if
 241  * a drive is allowed.
 242  *
 243  * NOTE: This must come before we include the arch floppy header because
 244  *       some ports reference this variable from there. -DaveM
 245  */
 246
 247 static int allowed_drive_mask = 0x33;
 248
 249 #include <asm/floppy.h>
 250
 251 static int irqdma_allocated;
 252
 253 #include <linux/blkdev.h>
 254 #include <linux/blkpg.h>
 255 #include <linux/cdrom.h>        /* for the compatibility eject ioctl */
 256 #include <linux/completion.h>
 257
 258 static struct request *current_req;
 259 static void do_fd_request(struct request_queue *q);
 260 static int set_next_request(void);
 261
 262 #ifndef fd_get_dma_residue
 263 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
 264 #endif
 265
 266 /* Dma Memory related stuff */
 267
 268 #ifndef fd_dma_mem_free
 269 #define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
 270 #endif
 271
 272 #ifndef fd_dma_mem_alloc
 273 #define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL, get_order(size))
 274 #endif
 275
 276 static inline void fallback_on_nodma_alloc(char **addr, size_t l)
 277 {
 278 #ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
 279         if (*addr)
 280                 return;         /* we have the memory */
 281         if (can_use_virtual_dma != 2)
 282                 return;         /* no fallback allowed */
 283         pr_info("DMA memory shortage. Temporarily falling back on virtual DMA\n");
 284         *addr = (char *)nodma_mem_alloc(l);
 285 #else
 286         return;
 287 #endif
 288 }
 289
 290 /* End dma memory related stuff */
 291
 292 static unsigned long fake_change;
 293 static bool initialized;
 294
 295 #define ITYPE(x)        (((x) >> 2) & 0x1f)
 296 #define TOMINOR(x)      ((x & 3) | ((x & 4) << 5))
 297 #define UNIT(x)         ((x) & 0x03)            /* drive on fdc */
 298 #define FDC(x)          (((x) & 0x04) >> 2)     /* fdc of drive */
 299         /* reverse mapping from unit and fdc to drive */
 300 #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
 301
 302 #define DP      (&drive_params[current_drive])
 303 #define DRS     (&drive_state[current_drive])
 304 #define DRWE    (&write_errors[current_drive])
 305 #define FDCS    (&fdc_state[fdc])
 306
 307 #define UDP     (&drive_params[drive])
 308 #define UDRS    (&drive_state[drive])
 309 #define UDRWE   (&write_errors[drive])
 310 #define UFDCS   (&fdc_state[FDC(drive)])
 311
 312 #define PH_HEAD(floppy, head) (((((floppy)->stretch & 2) >> 1) ^ head) << 2)
 313 #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
 314
 315 /* read/write */
 316 #define COMMAND         (raw_cmd->cmd[0])
 317 #define DR_SELECT       (raw_cmd->cmd[1])
 318 #define TRACK           (raw_cmd->cmd[2])
 319 #define HEAD            (raw_cmd->cmd[3])
 320 #define SECTOR          (raw_cmd->cmd[4])
 321 #define SIZECODE        (raw_cmd->cmd[5])
 322 #define SECT_PER_TRACK  (raw_cmd->cmd[6])
 323 #define GAP             (raw_cmd->cmd[7])
 324 #define SIZECODE2       (raw_cmd->cmd[8])
 325 #define NR_RW 9
 326
 327 /* format */
 328 #define F_SIZECODE      (raw_cmd->cmd[2])
 329 #define F_SECT_PER_TRACK (raw_cmd->cmd[3])
 330 #define F_GAP           (raw_cmd->cmd[4])
 331 #define F_FILL          (raw_cmd->cmd[5])
 332 #define NR_F 6
 333
 334 /*
 335  * Maximum disk size (in kilobytes).
 336  * This default is used whenever the current disk size is unknown.
 337  * [Now it is rather a minimum]
 338  */
 339 #define MAX_DISK_SIZE 4         /* 3984 */
 340
 341 /*
 342  * globals used by 'result()'
 343  */
 344 #define MAX_REPLIES 16
 345 static unsigned char reply_buffer[MAX_REPLIES];
 346 static int inr;         /* size of reply buffer, when called from interrupt */
 347 #define ST0             (reply_buffer[0])
 348 #define ST1             (reply_buffer[1])
 349 #define ST2             (reply_buffer[2])
 350 #define ST3             (reply_buffer[0])       /* result of GETSTATUS */
 351 #define R_TRACK         (reply_buffer[3])
 352 #define R_HEAD          (reply_buffer[4])
 353 #define R_SECTOR        (reply_buffer[5])
 354 #define R_SIZECODE      (reply_buffer[6])
 355
 356 #define SEL_DLY         (2 * HZ / 100)
 357
 358 /*
 359  * this struct defines the different floppy drive types.
 360  */
 361 static struct {
 362         struct floppy_drive_params params;
 363         const char *name;       /* name printed while booting */
 364 } default_drive_params[] = {
 365 /* NOTE: the time values in jiffies should be in msec!
 366  CMOS drive type
 367   |     Maximum data rate supported by drive type
 368   |     |   Head load time, msec
 369   |     |   |   Head unload time, msec (not used)
 370   |     |   |   |     Step rate interval, usec
 371   |     |   |   |     |       Time needed for spinup time (jiffies)
 372   |     |   |   |     |       |      Timeout for spinning down (jiffies)
 373   |     |   |   |     |       |      |   Spindown offset (where disk stops)
 374   |     |   |   |     |       |      |   |     Select delay
 375   |     |   |   |     |       |      |   |     |     RPS
 376   |     |   |   |     |       |      |   |     |     |    Max number of tracks
 377   |     |   |   |     |       |      |   |     |     |    |     Interrupt timeout
 378   |     |   |   |     |       |      |   |     |     |    |     |   Max nonintlv. sectors
 379   |     |   |   |     |       |      |   |     |     |    |     |   | -Max Errors- flags */
 380 {{0,  500, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  80, 3*HZ, 20, {3,1,2,0,2}, 0,
 381       0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
 382
 383 {{1,  300, 16, 16, 8000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  40, 3*HZ, 17, {3,1,2,0,2}, 0,
 384       0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" }, /*5 1/4 360 KB PC*/
 385
 386 {{2,  500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6,  83, 3*HZ, 17, {3,1,2,0,2}, 0,
 387       0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" }, /*5 1/4 HD AT*/
 388
 389 {{3,  250, 16, 16, 3000,    1*HZ, 3*HZ,  0, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
 390       0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" }, /*3 1/2 DD*/
 391
 392 {{4,  500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 20, {3,1,2,0,2}, 0,
 393       0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" }, /*3 1/2 HD*/
 394
 395 {{5, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
 396       0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" }, /*3 1/2 ED*/
 397
 398 {{6, 1000, 15,  8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5,  83, 3*HZ, 40, {3,1,2,0,2}, 0,
 399       0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" } /*3 1/2 ED*/
 400 /*    |  --autodetected formats---    |      |      |
 401  *    read_track                      |      |    Name printed when booting
 402  *                                    |     Native format
 403  *                  Frequency of disk change checks */
 404 };
 405
 406 static struct floppy_drive_params drive_params[N_DRIVE];
 407 static struct floppy_drive_struct drive_state[N_DRIVE];
 408 static struct floppy_write_errors write_errors[N_DRIVE];
 409 static struct timer_list motor_off_timer[N_DRIVE];
 410 static struct gendisk *disks[N_DRIVE];
 411 static struct block_device *opened_bdev[N_DRIVE];
 412 static DEFINE_MUTEX(open_lock);
 413 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
 414 static int fdc_queue;
 415
 416 /*
 417  * This struct defines the different floppy types.
 418  *
 419  * Bit 0 of 'stretch' tells if the tracks need to be doubled for some
 420  * types (e.g. 360kB diskette in 1.2MB drive, etc.).  Bit 1 of 'stretch'
 421  * tells if the disk is in Commodore 1581 format, which means side 0 sectors
 422  * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
 423  * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
 424  * 1581's logical side 0 is on physical side 1, whereas the Sharp's logical
 425  * side 0 is on physical side 0 (but with the misnamed sector IDs).
 426  * 'stretch' should probably be renamed to something more general, like
 427  * 'options'.
 428  *
 429  * Bits 2 through 9 of 'stretch' tell the number of the first sector.
 430  * The LSB (bit 2) is flipped. For most disks, the first sector
 431  * is 1 (represented by 0x00<<2).  For some CP/M and music sampler
 432  * disks (such as Ensoniq EPS 16plus) it is 0 (represented as 0x01<<2).
 433  * For Amstrad CPC disks it is 0xC1 (represented as 0xC0<<2).
 434  *
 435  * Other parameters should be self-explanatory (see also setfdprm(8)).
 436  */
 437 /*
 438             Size
 439              |  Sectors per track
 440              |  | Head
 441              |  | |  Tracks
 442              |  | |  | Stretch
 443              |  | |  | |  Gap 1 size
 444              |  | |  | |    |  Data rate, | 0x40 for perp
 445              |  | |  | |    |    |  Spec1 (stepping rate, head unload
 446              |  | |  | |    |    |    |    /fmt gap (gap2) */
 447 static struct floppy_struct floppy_type[32] = {
 448         {    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL    }, /*  0 no testing    */
 449         {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360"  }, /*  1 360KB PC      */
 450         { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" }, /*  2 1.2MB AT      */
 451         {  720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360"  }, /*  3 360KB SS 3.5" */
 452         { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720"  }, /*  4 720KB 3.5"    */
 453         {  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360"  }, /*  5 360KB AT      */
 454         { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720"  }, /*  6 720KB AT      */
 455         { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" }, /*  7 1.44MB 3.5"   */
 456         { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" }, /*  8 2.88MB 3.5"   */
 457         { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" }, /*  9 3.12MB 3.5"   */
 458
 459         { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25"  */
 460         { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" }, /* 11 1.68MB 3.5"   */
 461         {  820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410"  }, /* 12 410KB 5.25"   */
 462         { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820"  }, /* 13 820KB 3.5"    */
 463         { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" }, /* 14 1.48MB 5.25"  */
 464         { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" }, /* 15 1.72MB 3.5"   */
 465         {  840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420"  }, /* 16 420KB 5.25"   */
 466         { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830"  }, /* 17 830KB 3.5"    */
 467         { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" }, /* 18 1.49MB 5.25"  */
 468         { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" }, /* 19 1.74 MB 3.5"  */
 469
 470         { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880"  }, /* 20 880KB 5.25"   */
 471         { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" }, /* 21 1.04MB 3.5"   */
 472         { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" }, /* 22 1.12MB 3.5"   */
 473         { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" }, /* 23 1.6MB 5.25"   */
 474         { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" }, /* 24 1.76MB 3.5"   */
 475         { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" }, /* 25 1.92MB 3.5"   */
 476         { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" }, /* 26 3.20MB 3.5"   */
 477         { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" }, /* 27 3.52MB 3.5"   */
 478         { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" }, /* 28 3.84MB 3.5"   */
 479         { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" }, /* 29 1.84MB 3.5"   */
 480
 481         { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800"  }, /* 30 800KB 3.5"    */
 482         { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5"    */
 483 };
 484
 485 #define SECTSIZE (_FD_SECTSIZE(*floppy))
 486
 487 /* Auto-detection: Disk type used until the next media change occurs. */
 488 static struct floppy_struct *current_type[N_DRIVE];
 489
 490 /*
 491  * User-provided type information. current_type points to
 492  * the respective entry of this array.
 493  */
 494 static struct floppy_struct user_params[N_DRIVE];
 495
 496 static sector_t floppy_sizes[256];
 497
 498 static char floppy_device_name[] = "floppy";
 499
 500 /*
 501  * The driver is trying to determine the correct media format
 502  * while probing is set. rw_interrupt() clears it after a
 503  * successful access.
 504  */
 505 static int probing;
 506
 507 /* Synchronization of FDC access. */
 508 #define FD_COMMAND_NONE         -1
 509 #define FD_COMMAND_ERROR        2
 510 #define FD_COMMAND_OKAY         3
 511
 512 static volatile int command_status = FD_COMMAND_NONE;
 513 static unsigned long fdc_busy;
 514 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
 515 static DECLARE_WAIT_QUEUE_HEAD(command_done);
 516
 517 /* Errors during formatting are counted here. */
 518 static int format_errors;
 519
 520 /* Format request descriptor. */
 521 static struct format_descr format_req;
 522
 523 /*
 524  * Rate is 0 for 500kb/s, 1 for 300kbps, 2 for 250kbps
 525  * Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
 526  * H is head unload time (1=16ms, 2=32ms, etc)
 527  */
 528
 529 /*
 530  * Track buffer
 531  * Because these are written to by the DMA controller, they must
 532  * not contain a 64k byte boundary crossing, or data will be
 533  * corrupted/lost.
 534  */
 535 static char *floppy_track_buffer;
 536 static int max_buffer_sectors;
 537
 538 static int *errors;
 539 typedef void (*done_f)(int);
 540 static const struct cont_t {
 541         void (*interrupt)(void);
 542                                 /* this is called after the interrupt of the
 543                                  * main command */
 544         void (*redo)(void);     /* this is called to retry the operation */
 545         void (*error)(void);    /* this is called to tally an error */
 546         done_f done;            /* this is called to say if the operation has
 547                                  * succeeded/failed */
 548 } *cont;
 549
 550 static void floppy_ready(void);
 551 static void floppy_start(void);
 552 static void process_fd_request(void);
 553 static void recalibrate_floppy(void);
 554 static void floppy_shutdown(struct work_struct *);
 555
 556 static int floppy_request_regions(int);
 557 static void floppy_release_regions(int);
 558 static int floppy_grab_irq_and_dma(void);
 559 static void floppy_release_irq_and_dma(void);
 560
 561 /*
 562  * The "reset" variable should be tested whenever an interrupt is scheduled,
 563  * after the commands have been sent. This is to ensure that the driver doesn't
 564  * get wedged when the interrupt doesn't come because of a failed command.
 565  * reset doesn't need to be tested before sending commands, because
 566  * output_byte is automatically disabled when reset is set.
 567  */
 568 static void reset_fdc(void);
 569
 570 /*
 571  * These are global variables, as that's the easiest way to give
 572  * information to interrupts. They are the data used for the current
 573  * request.
 574  */
 575 #define NO_TRACK        -1
 576 #define NEED_1_RECAL    -2
 577 #define NEED_2_RECAL    -3
 578
 579 static atomic_t usage_count = ATOMIC_INIT(0);
 580
 581 /* buffer related variables */
 582 static int buffer_track = -1;
 583 static int buffer_drive = -1;
 584 static int buffer_min = -1;
 585 static int buffer_max = -1;
 586
 587 /* fdc related variables, should end up in a struct */
 588 static struct floppy_fdc_state fdc_state[N_FDC];
 589 static int fdc;                 /* current fdc */
 590
 591 static struct workqueue_struct *floppy_wq;
 592
 593 static struct floppy_struct *_floppy = floppy_type;
 594 static unsigned char current_drive;
 595 static long current_count_sectors;
 596 static unsigned char fsector_t; /* sector in track */
 597 static unsigned char in_sector_offset;  /* offset within physical sector,
 598                                          * expressed in units of 512 bytes */
 599
 600 static inline bool drive_no_geom(int drive)
 601 {
 602         return !current_type[drive] && !ITYPE(UDRS->fd_device);
 603 }
 604
 605 #ifndef fd_eject
 606 static inline int fd_eject(int drive)
 607 {
 608         return -EINVAL;
 609 }
 610 #endif
 611
 612 /*
 613  * Debugging
 614  * =========
 615  */
 616 #ifdef DEBUGT
 617 static long unsigned debugtimer;
 618
 619 static inline void set_debugt(void)
 620 {
 621         debugtimer = jiffies;
 622 }
 623
 624 static inline void debugt(const char *func, const char *msg)
 625 {
 626         if (DP->flags & DEBUGT)
 627                 pr_info("%s:%s dtime=%lu\n", func, msg, jiffies - debugtimer);
 628 }
 629 #else
 630 static inline void set_debugt(void) { }
 631 static inline void debugt(const char *func, const char *msg) { }
 632 #endif /* DEBUGT */
 633
 634
 635 static DECLARE_DELAYED_WORK(fd_timeout, floppy_shutdown);
 636 static const char *timeout_message;
 637
 638 static void is_alive(const char *func, const char *message)
 639 {
 640         /* this routine checks whether the floppy driver is "alive" */
 641         if (test_bit(0, &fdc_busy) && command_status < 2 &&
 642             !delayed_work_pending(&fd_timeout)) {
 643                 DPRINT("%s: timeout handler died.  %s\n", func, message);
 644         }
 645 }
 646
 647 static void (*do_floppy)(void) = NULL;
 648
 649 #define OLOGSIZE 20
 650
 651 static void (*lasthandler)(void);
 652 static unsigned long interruptjiffies;
 653 static unsigned long resultjiffies;
 654 static int resultsize;
 655 static unsigned long lastredo;
 656
 657 static struct output_log {
 658         unsigned char data;
 659         unsigned char status;
 660         unsigned long jiffies;
 661 } output_log[OLOGSIZE];
 662
 663 static int output_log_pos;
 664
 665 #define current_reqD -1
 666 #define MAXTIMEOUT -2
 667
 668 static void __reschedule_timeout(int drive, const char *message)
 669 {
 670         unsigned long delay;
 671
 672         if (drive == current_reqD)
 673                 drive = current_drive;
 674         __cancel_delayed_work(&fd_timeout);
 675
 676         if (drive < 0 || drive >= N_DRIVE) {
 677                 delay = 20UL * HZ;
 678                 drive = 0;
 679         } else
 680                 delay = UDP->timeout;
 681
 682         queue_delayed_work(floppy_wq, &fd_timeout, delay);
 683         if (UDP->flags & FD_DEBUG)
 684                 DPRINT("reschedule timeout %s\n", message);
 685         timeout_message = message;
 686 }
 687
 688 static void reschedule_timeout(int drive, const char *message)
 689 {
 690         unsigned long flags;
 691
 692         spin_lock_irqsave(&floppy_lock, flags);
 693         __reschedule_timeout(drive, message);
 694         spin_unlock_irqrestore(&floppy_lock, flags);
 695 }
 696
 697 #define INFBOUND(a, b) (a) = max_t(int, a, b)
 698 #define SUPBOUND(a, b) (a) = min_t(int, a, b)
 699
 700 /*
 701  * Bottom half floppy driver.
 702  * ==========================
 703  *
 704  * This part of the file contains the code talking directly to the hardware,
 705  * and also the main service loop (seek-configure-spinup-command)
 706  */
 707
 708 /*
 709  * disk change.
 710  * This routine is responsible for maintaining the FD_DISK_CHANGE flag,
 711  * and the last_checked date.
 712  *
 713  * last_checked is the date of the last check which showed 'no disk change'
 714  * FD_DISK_CHANGE is set under two conditions:
 715  * 1. The floppy has been changed after some i/o to that floppy already
 716  *    took place.
 717  * 2. No floppy disk is in the drive. This is done in order to ensure that
 718  *    requests are quickly flushed in case there is no disk in the drive. It
 719  *    follows that FD_DISK_CHANGE can only be cleared if there is a disk in
 720  *    the drive.
 721  *
 722  * For 1., maxblock is observed. Maxblock is 0 if no i/o has taken place yet.
 723  * For 2., FD_DISK_NEWCHANGE is watched. FD_DISK_NEWCHANGE is cleared on
 724  *  each seek. If a disk is present, the disk change line should also be
 725  *  cleared on each seek. Thus, if FD_DISK_NEWCHANGE is clear, but the disk
 726  *  change line is set, this means either that no disk is in the drive, or
 727  *  that it has been removed since the last seek.
 728  *
 729  * This means that we really have a third possibility too:
 730  *  The floppy has been changed after the last seek.
 731  */
 732
 733 static int disk_change(int drive)
 734 {
 735         int fdc = FDC(drive);
 736
 737         if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
 738                 DPRINT("WARNING disk change called early\n");
 739         if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
 740             (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
 741                 DPRINT("probing disk change on unselected drive\n");
 742                 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
 743                        (unsigned int)FDCS->dor);
 744         }
 745
 746         debug_dcl(UDP->flags,
 747                   "checking disk change line for drive %d\n", drive);
 748         debug_dcl(UDP->flags, "jiffies=%lu\n", jiffies);
 749         debug_dcl(UDP->flags, "disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
 750         debug_dcl(UDP->flags, "flags=%lx\n", UDRS->flags);
 751
 752         if (UDP->flags & FD_BROKEN_DCL)
 753                 return test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
 754         if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
 755                 set_bit(FD_VERIFY_BIT, &UDRS->flags);
 756                                         /* verify write protection */
 757
 758                 if (UDRS->maxblock)     /* mark it changed */
 759                         set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
 760
 761                 /* invalidate its geometry */
 762                 if (UDRS->keep_data >= 0) {
 763                         if ((UDP->flags & FTD_MSG) &&
 764                             current_type[drive] != NULL)
 765                                 DPRINT("Disk type is undefined after disk change\n");
 766                         current_type[drive] = NULL;
 767                         floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
 768                 }
 769
 770                 return 1;
 771         } else {
 772                 UDRS->last_checked = jiffies;
 773                 clear_bit(FD_DISK_NEWCHANGE_BIT, &UDRS->flags);
 774         }
 775         return 0;
 776 }
 777
 778 static inline int is_selected(int dor, int unit)
 779 {
 780         return ((dor & (0x10 << unit)) && (dor & 3) == unit);
 781 }
 782
 783 static bool is_ready_state(int status)
 784 {
 785         int state = status & (STATUS_READY | STATUS_DIR | STATUS_DMA);
 786         return state == STATUS_READY;
 787 }
 788
 789 static int set_dor(int fdc, char mask, char data)
 790 {
 791         unsigned char unit;
 792         unsigned char drive;
 793         unsigned char newdor;
 794         unsigned char olddor;
 795
 796         if (FDCS->address == -1)
 797                 return -1;
 798
 799         olddor = FDCS->dor;
 800         newdor = (olddor & mask) | data;
 801         if (newdor != olddor) {
 802                 unit = olddor & 0x3;
 803                 if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
 804                         drive = REVDRIVE(fdc, unit);
 805                         debug_dcl(UDP->flags,
 806                                   "calling disk change from set_dor\n");
 807                         disk_change(drive);
 808                 }
 809                 FDCS->dor = newdor;
 810                 fd_outb(newdor, FD_DOR);
 811
 812                 unit = newdor & 0x3;
 813                 if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
 814                         drive = REVDRIVE(fdc, unit);
 815                         UDRS->select_date = jiffies;
 816                 }
 817         }
 818         return olddor;
 819 }
 820
 821 static void twaddle(void)
 822 {
 823         if (DP->select_delay)
 824                 return;
 825         fd_outb(FDCS->dor & ~(0x10 << UNIT(current_drive)), FD_DOR);
 826         fd_outb(FDCS->dor, FD_DOR);
 827         DRS->select_date = jiffies;
 828 }
 829
 830 /*
 831  * Reset all driver information about the current fdc.
 832  * This is needed after a reset, and after a raw command.
 833  */
 834 static void reset_fdc_info(int mode)
 835 {
 836         int drive;
 837
 838         FDCS->spec1 = FDCS->spec2 = -1;
 839         FDCS->need_configure = 1;
 840         FDCS->perp_mode = 1;
 841         FDCS->rawcmd = 0;
 842         for (drive = 0; drive < N_DRIVE; drive++)
 843                 if (FDC(drive) == fdc && (mode || UDRS->track != NEED_1_RECAL))
 844                         UDRS->track = NEED_2_RECAL;
 845 }
 846
 847 /* selects the fdc and drive, and enables the fdc's input/dma. */
 848 static void set_fdc(int drive)
 849 {
 850         if (drive >= 0 && drive < N_DRIVE) {
 851                 fdc = FDC(drive);
 852                 current_drive = drive;
 853         }
 854         if (fdc != 1 && fdc != 0) {
 855                 pr_info("bad fdc value\n");
 856                 return;
 857         }
 858         set_dor(fdc, ~0, 8);
 859 #if N_FDC > 1
 860         set_dor(1 - fdc, ~8, 0);
 861 #endif
 862         if (FDCS->rawcmd == 2)
 863                 reset_fdc_info(1);
 864         if (fd_inb(FD_STATUS) != STATUS_READY)
 865                 FDCS->reset = 1;
 866 }
 867
 868 /* locks the driver */
 869 static int lock_fdc(int drive, bool interruptible)
 870 {
 871         if (WARN(atomic_read(&usage_count) == 0,
 872                  "Trying to lock fdc while usage count=0\n"))
 873                 return -1;
 874
 875         if (wait_event_interruptible(fdc_wait, !test_and_set_bit(0, &fdc_busy)))
 876                 return -EINTR;
 877
 878         command_status = FD_COMMAND_NONE;
 879
 880         reschedule_timeout(drive, "lock fdc");
 881         set_fdc(drive);
 882         return 0;
 883 }
 884
 885 /* unlocks the driver */
 886 static void unlock_fdc(void)
 887 {
 888         if (!test_bit(0, &fdc_busy))
 889                 DPRINT("FDC access conflict!\n");
 890
 891         raw_cmd = NULL;
 892         command_status = FD_COMMAND_NONE;
 893         __cancel_delayed_work(&fd_timeout);
 894         do_floppy = NULL;
 895         cont = NULL;
 896         clear_bit(0, &fdc_busy);
 897         wake_up(&fdc_wait);
 898 }
 899
 900 /* switches the motor off after a given timeout */
 901 static void motor_off_callback(unsigned long nr)
 902 {
 903         unsigned char mask = ~(0x10 << UNIT(nr));
 904
 905         set_dor(FDC(nr), mask, 0);
 906 }
 907
 908 /* schedules motor off */
 909 static void floppy_off(unsigned int drive)
 910 {
 911         unsigned long volatile delta;
 912         int fdc = FDC(drive);
 913
 914         if (!(FDCS->dor & (0x10 << UNIT(drive))))
 915                 return;
 916
 917         del_timer(motor_off_timer + drive);
 918
 919         /* make spindle stop in a position which minimizes spinup time
 920          * next time */
 921         if (UDP->rps) {
 922                 delta = jiffies - UDRS->first_read_date + HZ -
 923                     UDP->spindown_offset;
 924                 delta = ((delta * UDP->rps) % HZ) / UDP->rps;
 925                 motor_off_timer[drive].expires =
 926                     jiffies + UDP->spindown - delta;
 927         }
 928         add_timer(motor_off_timer + drive);
 929 }
 930
 931 /*
 932  * cycle through all N_DRIVE floppy drives, for disk change testing.
 933  * stopping at current drive. This is done before any long operation, to
 934  * be sure to have up to date disk change information.
 935  */
 936 static void scandrives(void)
 937 {
 938         int i;
 939         int drive;
 940         int saved_drive;
 941
 942         if (DP->select_delay)
 943                 return;
 944
 945         saved_drive = current_drive;
 946         for (i = 0; i < N_DRIVE; i++) {
 947                 drive = (saved_drive + i + 1) % N_DRIVE;
 948                 if (UDRS->fd_ref == 0 || UDP->select_delay != 0)
 949                         continue;       /* skip closed drives */
 950                 set_fdc(drive);
 951                 if (!(set_dor(fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
 952                       (0x10 << UNIT(drive))))
 953                         /* switch the motor off again, if it was off to
 954                          * begin with */
 955                         set_dor(fdc, ~(0x10 << UNIT(drive)), 0);
 956         }
 957         set_fdc(saved_drive);
 958 }
 959
 960 static void empty(void)
 961 {
 962 }
 963
 964 static DECLARE_WORK(floppy_work, NULL);
 965
 966 static void schedule_bh(void (*handler)(void))
 967 {
 968         WARN_ON(work_pending(&floppy_work));
 969
 970         PREPARE_WORK(&floppy_work, (work_func_t)handler);
 971         queue_work(floppy_wq, &floppy_work);
 972 }
 973
 974 static DECLARE_DELAYED_WORK(fd_timer, NULL);
 975
 976 static void cancel_activity(void)
 977 {
 978         do_floppy = NULL;
 979         cancel_delayed_work_sync(&fd_timer);
 980         cancel_work_sync(&floppy_work);
 981 }
 982
 983 /* this function makes sure that the disk stays in the drive during the
 984  * transfer */
 985 static void fd_watchdog(struct work_struct *arg)
 986 {
 987         debug_dcl(DP->flags, "calling disk change from watchdog\n");
 988
 989         if (disk_change(current_drive)) {
 990                 DPRINT("disk removed during i/o\n");
 991                 cancel_activity();
 992                 cont->done(0);
 993                 reset_fdc();
 994         } else {
 995                 cancel_delayed_work(&fd_timer);
 996                 PREPARE_DELAYED_WORK(&fd_timer, fd_watchdog);
 997                 queue_delayed_work(floppy_wq, &fd_timer, HZ / 10);
 998         }
 999 }
1000
1001 static void main_command_interrupt(void)
1002 {
1003         cancel_delayed_work(&fd_timer);
1004         cont->interrupt();
1005 }
1006
1007 /* waits for a delay (spinup or select) to pass */
1008 static int fd_wait_for_completion(unsigned long expires, work_func_t function)
1009 {
1010         if (FDCS->reset) {
1011                 reset_fdc();    /* do the reset during sleep to win time
1012                                  * if we don't need to sleep, it's a good
1013                                  * occasion anyways */
1014                 return 1;
1015         }
1016
1017         if (time_before(jiffies, expires)) {
1018                 cancel_delayed_work(&fd_timer);
1019                 PREPARE_DELAYED_WORK(&fd_timer, function);
1020                 queue_delayed_work(floppy_wq, &fd_timer, expires - jiffies);
1021                 return 1;
1022         }
1023         return 0;
1024 }
1025
1026 static void setup_DMA(void)
1027 {
1028         unsigned long f;
1029
1030         if (raw_cmd->length == 0) {
1031                 int i;
1032
1033                 pr_info("zero dma transfer size:");
1034                 for (i = 0; i < raw_cmd->cmd_count; i++)
1035                         pr_cont("%x,", raw_cmd->cmd[i]);
1036                 pr_cont("\n");
1037                 cont->done(0);
1038                 FDCS->reset = 1;
1039                 return;
1040         }
1041         if (((unsigned long)raw_cmd->kernel_data) % 512) {
1042                 pr_info("non aligned address: %p\n", raw_cmd->kernel_data);
1043                 cont->done(0);
1044                 FDCS->reset = 1;
1045                 return;
1046         }
1047         f = claim_dma_lock();
1048         fd_disable_dma();
1049 #ifdef fd_dma_setup
1050         if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1051                          (raw_cmd->flags & FD_RAW_READ) ?
1052                          DMA_MODE_READ : DMA_MODE_WRITE, FDCS->address) < 0) {
1053                 release_dma_lock(f);
1054                 cont->done(0);
1055                 FDCS->reset = 1;
1056                 return;
1057         }
1058         release_dma_lock(f);
1059 #else
1060         fd_clear_dma_ff();
1061         fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1062         fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
1063                         DMA_MODE_READ : DMA_MODE_WRITE);
1064         fd_set_dma_addr(raw_cmd->kernel_data);
1065         fd_set_dma_count(raw_cmd->length);
1066         virtual_dma_port = FDCS->address;
1067         fd_enable_dma();
1068         release_dma_lock(f);
1069 #endif
1070 }
1071
1072 static void show_floppy(void);
1073
1074 /* waits until the fdc becomes ready */
1075 static int wait_til_ready(void)
1076 {
1077         int status;
1078         int counter;
1079
1080         if (FDCS->reset)
1081                 return -1;
1082         for (counter = 0; counter < 10000; counter++) {
1083                 status = fd_inb(FD_STATUS);
1084                 if (status & STATUS_READY)
1085                         return status;
1086         }
1087         if (initialized) {
1088                 DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
1089                 show_floppy();
1090         }
1091         FDCS->reset = 1;
1092         return -1;
1093 }
1094
1095 /* sends a command byte to the fdc */
1096 static int output_byte(char byte)
1097 {
1098         int status = wait_til_ready();
1099
1100         if (status < 0)
1101                 return -1;
1102
1103         if (is_ready_state(status)) {
1104                 fd_outb(byte, FD_DATA);
1105                 output_log[output_log_pos].data = byte;
1106                 output_log[output_log_pos].status = status;
1107                 output_log[output_log_pos].jiffies = jiffies;
1108                 output_log_pos = (output_log_pos + 1) % OLOGSIZE;
1109                 return 0;
1110         }
1111         FDCS->reset = 1;
1112         if (initialized) {
1113                 DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
1114                        byte, fdc, status);
1115                 show_floppy();
1116         }
1117         return -1;
1118 }
1119
1120 /* gets the response from the fdc */
1121 static int result(void)
1122 {
1123         int i;
1124         int status = 0;
1125
1126         for (i = 0; i < MAX_REPLIES; i++) {
1127                 status = wait_til_ready();
1128                 if (status < 0)
1129                         break;
1130                 status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
1131                 if ((status & ~STATUS_BUSY) == STATUS_READY) {
1132                         resultjiffies = jiffies;
1133                         resultsize = i;
1134                         return i;
1135                 }
1136                 if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
1137                         reply_buffer[i] = fd_inb(FD_DATA);
1138                 else
1139                         break;
1140         }
1141         if (initialized) {
1142                 DPRINT("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
1143                        fdc, status, i);
1144                 show_floppy();
1145         }
1146         FDCS->reset = 1;
1147         return -1;
1148 }
1149
1150 #define MORE_OUTPUT -2
1151 /* does the fdc need more output? */
1152 static int need_more_output(void)
1153 {
1154         int status = wait_til_ready();
1155
1156         if (status < 0)
1157                 return -1;
1158
1159         if (is_ready_state(status))
1160                 return MORE_OUTPUT;
1161
1162         return result();
1163 }
1164
1165 /* Set perpendicular mode as required, based on data rate, if supported.
1166  * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
1167  */
1168 static void perpendicular_mode(void)
1169 {
1170         unsigned char perp_mode;
1171
1172         if (raw_cmd->rate & 0x40) {
1173                 switch (raw_cmd->rate & 3) {
1174                 case 0:
1175                         perp_mode = 2;
1176                         break;
1177                 case 3:
1178                         perp_mode = 3;
1179                         break;
1180                 default:
1181                         DPRINT("Invalid data rate for perpendicular mode!\n");
1182                         cont->done(0);
1183                         FDCS->reset = 1;
1184                                         /*
1185                                          * convenient way to return to
1186                                          * redo without too much hassle
1187                                          * (deep stack et al.)
1188                                          */
1189                         return;
1190                 }
1191         } else
1192                 perp_mode = 0;
1193
1194         if (FDCS->perp_mode == perp_mode)
1195                 return;
1196         if (FDCS->version >= FDC_82077_ORIG) {
1197                 output_byte(FD_PERPENDICULAR);
1198                 output_byte(perp_mode);
1199                 FDCS->perp_mode = perp_mode;
1200         } else if (perp_mode) {
1201                 DPRINT("perpendicular mode not supported by this FDC.\n");
1202         }
1203 }                               /* perpendicular_mode */
1204
1205 static int fifo_depth = 0xa;
1206 static int no_fifo;
1207
1208 static int fdc_configure(void)
1209 {
1210         /* Turn on FIFO */
1211         output_byte(FD_CONFIGURE);
1212         if (need_more_output() != MORE_OUTPUT)
1213                 return 0;
1214         output_byte(0);
1215         output_byte(0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1216         output_byte(0);         /* pre-compensation from track
1217                                    0 upwards */
1218         return 1;
1219 }
1220
1221 #define NOMINAL_DTR 500
1222
1223 /* Issue a "SPECIFY" command to set the step rate time, head unload time,
1224  * head load time, and DMA disable flag to values needed by floppy.
1225  *
1226  * The value "dtr" is the data transfer rate in Kbps.  It is needed
1227  * to account for the data rate-based scaling done by the 82072 and 82077
1228  * FDC types.  This parameter is ignored for other types of FDCs (i.e.
1229  * 8272a).
1230  *
1231  * Note that changing the data transfer rate has a (probably deleterious)
1232  * effect on the parameters subject to scaling for 82072/82077 FDCs, so
1233  * fdc_specify is called again after each data transfer rate
1234  * change.
1235  *
1236  * srt: 1000 to 16000 in microseconds
1237  * hut: 16 to 240 milliseconds
1238  * hlt: 2 to 254 milliseconds
1239  *
1240  * These values are rounded up to the next highest available delay time.
1241  */
1242 static void fdc_specify(void)
1243 {
1244         unsigned char spec1;
1245         unsigned char spec2;
1246         unsigned long srt;
1247         unsigned long hlt;
1248         unsigned long hut;
1249         unsigned long dtr = NOMINAL_DTR;
1250         unsigned long scale_dtr = NOMINAL_DTR;
1251         int hlt_max_code = 0x7f;
1252         int hut_max_code = 0xf;
1253
1254         if (FDCS->need_configure && FDCS->version >= FDC_82072A) {
1255                 fdc_configure();
1256                 FDCS->need_configure = 0;
1257         }
1258
1259         switch (raw_cmd->rate & 0x03) {
1260         case 3:
1261                 dtr = 1000;
1262                 break;
1263         case 1:
1264                 dtr = 300;
1265                 if (FDCS->version >= FDC_82078) {
1266                         /* chose the default rate table, not the one
1267                          * where 1 = 2 Mbps */
1268                         output_byte(FD_DRIVESPEC);
1269                         if (need_more_output() == MORE_OUTPUT) {
1270                                 output_byte(UNIT(current_drive));
1271                                 output_byte(0xc0);
1272                         }
1273                 }
1274                 break;
1275         case 2:
1276                 dtr = 250;
1277                 break;
1278         }
1279
1280         if (FDCS->version >= FDC_82072) {
1281                 scale_dtr = dtr;
1282                 hlt_max_code = 0x00;    /* 0==256msec*dtr0/dtr (not linear!) */
1283                 hut_max_code = 0x0;     /* 0==256msec*dtr0/dtr (not linear!) */
1284         }
1285
1286         /* Convert step rate from microseconds to milliseconds and 4 bits */
1287         srt = 16 - DIV_ROUND_UP(DP->srt * scale_dtr / 1000, NOMINAL_DTR);
1288         if (slow_floppy)
1289                 srt = srt / 4;
1290
1291         SUPBOUND(srt, 0xf);
1292         INFBOUND(srt, 0);
1293
1294         hlt = DIV_ROUND_UP(DP->hlt * scale_dtr / 2, NOMINAL_DTR);
1295         if (hlt < 0x01)
1296                 hlt = 0x01;
1297         else if (hlt > 0x7f)
1298                 hlt = hlt_max_code;
1299
1300         hut = DIV_ROUND_UP(DP->hut * scale_dtr / 16, NOMINAL_DTR);
1301         if (hut < 0x1)
1302                 hut = 0x1;
1303         else if (hut > 0xf)
1304                 hut = hut_max_code;
1305
1306         spec1 = (srt << 4) | hut;
1307         spec2 = (hlt << 1) | (use_virtual_dma & 1);
1308
1309         /* If these parameters did not change, just return with success */
1310         if (FDCS->spec1 != spec1 || FDCS->spec2 != spec2) {
1311                 /* Go ahead and set spec1 and spec2 */
1312                 output_byte(FD_SPECIFY);
1313                 output_byte(FDCS->spec1 = spec1);
1314                 output_byte(FDCS->spec2 = spec2);
1315         }
1316 }                               /* fdc_specify */
1317
1318 /* Set the FDC's data transfer rate on behalf of the specified drive.
1319  * NOTE: with 82072/82077 FDCs, changing the data rate requires a reissue
1320  * of the specify command (i.e. using the fdc_specify function).
1321  */
1322 static int fdc_dtr(void)
1323 {
1324         /* If data rate not already set to desired value, set it. */
1325         if ((raw_cmd->rate & 3) == FDCS->dtr)
1326                 return 0;
1327
1328         /* Set dtr */
1329         fd_outb(raw_cmd->rate & 3, FD_DCR);
1330
1331         /* TODO: some FDC/drive combinations (C&T 82C711 with TEAC 1.2MB)
1332          * need a stabilization period of several milliseconds to be
1333          * enforced after data rate changes before R/W operations.
1334          * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
1335          */
1336         FDCS->dtr = raw_cmd->rate & 3;
1337         return fd_wait_for_completion(jiffies + 2UL * HZ / 100,
1338                                       (work_func_t)floppy_ready);
1339 }                               /* fdc_dtr */
1340
1341 static void tell_sector(void)
1342 {
1343         pr_cont(": track %d, head %d, sector %d, size %d",
1344                 R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
1345 }                               /* tell_sector */
1346
1347 static void print_errors(void)
1348 {
1349         DPRINT("");
1350         if (ST0 & ST0_ECE) {
1351                 pr_cont("Recalibrate failed!");
1352         } else if (ST2 & ST2_CRC) {
1353                 pr_cont("data CRC error");
1354                 tell_sector();
1355         } else if (ST1 & ST1_CRC) {
1356                 pr_cont("CRC error");
1357                 tell_sector();
1358         } else if ((ST1 & (ST1_MAM | ST1_ND)) ||
1359                    (ST2 & ST2_MAM)) {
1360                 if (!probing) {
1361                         pr_cont("sector not found");
1362                         tell_sector();
1363                 } else
1364                         pr_cont("probe failed...");
1365         } else if (ST2 & ST2_WC) {      /* seek error */
1366                 pr_cont("wrong cylinder");
1367         } else if (ST2 & ST2_BC) {      /* cylinder marked as bad */
1368                 pr_cont("bad cylinder");
1369         } else {
1370                 pr_cont("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
1371                         ST0, ST1, ST2);
1372                 tell_sector();
1373         }
1374         pr_cont("\n");
1375 }
1376
1377 /*
1378  * OK, this error interpreting routine is called after a
1379  * DMA read/write has succeeded
1380  * or failed, so we check the results, and copy any buffers.
1381  * hhb: Added better error reporting.
1382  * ak: Made this into a separate routine.
1383  */
1384 static int interpret_errors(void)
1385 {
1386         char bad;
1387
1388         if (inr != 7) {
1389                 DPRINT("-- FDC reply error\n");
1390                 FDCS->reset = 1;
1391                 return 1;
1392         }
1393
1394         /* check IC to find cause of interrupt */
1395         switch (ST0 & ST0_INTR) {
1396         case 0x40:              /* error occurred during command execution */
1397                 if (ST1 & ST1_EOC)
1398                         return 0;       /* occurs with pseudo-DMA */
1399                 bad = 1;
1400                 if (ST1 & ST1_WP) {
1401                         DPRINT("Drive is write protected\n");
1402                         clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
1403                         cont->done(0);
1404                         bad = 2;
1405                 } else if (ST1 & ST1_ND) {
1406                         set_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
1407                 } else if (ST1 & ST1_OR) {
1408                         if (DP->flags & FTD_MSG)
1409                                 DPRINT("Over/Underrun - retrying\n");
1410                         bad = 0;
1411                 } else if (*errors >= DP->max_errors.reporting) {
1412                         print_errors();
1413                 }
1414                 if (ST2 & ST2_WC || ST2 & ST2_BC)
1415                         /* wrong cylinder => recal */
1416                         DRS->track = NEED_2_RECAL;
1417                 return bad;
1418         case 0x80:              /* invalid command given */
1419                 DPRINT("Invalid FDC command given!\n");
1420                 cont->done(0);
1421                 return 2;
1422         case 0xc0:
1423                 DPRINT("Abnormal termination caused by polling\n");
1424                 cont->error();
1425                 return 2;
1426         default:                /* (0) Normal command termination */
1427                 return 0;
1428         }
1429 }
1430
1431 /*
1432  * This routine is called when everything should be correctly set up
1433  * for the transfer (i.e. floppy motor is on, the correct floppy is
1434  * selected, and the head is sitting on the right track).
1435  */
1436 static void setup_rw_floppy(void)
1437 {
1438         int i;
1439         int r;
1440         int flags;
1441         int dflags;
1442         unsigned long ready_date;
1443         work_func_t function;
1444
1445         flags = raw_cmd->flags;
1446         if (flags & (FD_RAW_READ | FD_RAW_WRITE))
1447                 flags |= FD_RAW_INTR;
1448
1449         if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
1450                 ready_date = DRS->spinup_date + DP->spinup;
1451                 /* If spinup will take a long time, rerun scandrives
1452                  * again just before spinup completion. Beware that
1453                  * after scandrives, we must again wait for selection.
1454                  */
1455                 if (time_after(ready_date, jiffies + DP->select_delay)) {
1456                         ready_date -= DP->select_delay;
1457                         function = (work_func_t)floppy_start;
1458                 } else
1459                         function = (work_func_t)setup_rw_floppy;
1460
1461                 /* wait until the floppy is spinning fast enough */
1462                 if (fd_wait_for_completion(ready_date, function))
1463                         return;
1464         }
1465         dflags = DRS->flags;
1466
1467         if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
1468                 setup_DMA();
1469
1470         if (flags & FD_RAW_INTR)
1471                 do_floppy = main_command_interrupt;
1472
1473         r = 0;
1474         for (i = 0; i < raw_cmd->cmd_count; i++)
1475                 r |= output_byte(raw_cmd->cmd[i]);
1476
1477         debugt(__func__, "rw_command");
1478
1479         if (r) {
1480                 cont->error();
1481                 reset_fdc();
1482                 return;
1483         }
1484
1485         if (!(flags & FD_RAW_INTR)) {
1486                 inr = result();
1487                 cont->interrupt();
1488         } else if (flags & FD_RAW_NEED_DISK)
1489                 fd_watchdog(NULL);
1490 }
1491
1492 static int blind_seek;
1493
1494 /*
1495  * This is the routine called after every seek (or recalibrate) interrupt
1496  * from the floppy controller.
1497  */
1498 static void seek_interrupt(void)
1499 {
1500         debugt(__func__, "");
1501         if (inr != 2 || (ST0 & 0xF8) != 0x20) {
1502                 DPRINT("seek failed\n");
1503                 DRS->track = NEED_2_RECAL;
1504                 cont->error();
1505                 cont->redo();
1506                 return;
1507         }
1508         if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
1509                 debug_dcl(DP->flags,
1510                           "clearing NEWCHANGE flag because of effective seek\n");
1511                 debug_dcl(DP->flags, "jiffies=%lu\n", jiffies);
1512                 clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
1513                                         /* effective seek */
1514                 DRS->select_date = jiffies;
1515         }
1516         DRS->track = ST1;
1517         floppy_ready();
1518 }
1519
1520 static void check_wp(void)
1521 {
1522         if (test_bit(FD_VERIFY_BIT, &DRS->flags)) {
1523                                         /* check write protection */
1524                 output_byte(FD_GETSTATUS);
1525                 output_byte(UNIT(current_drive));
1526                 if (result() != 1) {
1527                         FDCS->reset = 1;
1528                         return;
1529                 }
1530                 clear_bit(FD_VERIFY_BIT, &DRS->flags);
1531                 clear_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
1532                 debug_dcl(DP->flags,
1533                           "checking whether disk is write protected\n");
1534                 debug_dcl(DP->flags, "wp=%x\n", ST3 & 0x40);
1535                 if (!(ST3 & 0x40))
1536                         set_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
1537                 else
1538                         clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
1539         }
1540 }
1541
1542 static void seek_floppy(void)
1543 {
1544         int track;
1545
1546         blind_seek = 0;
1547
1548         debug_dcl(DP->flags, "calling disk change from %s\n", __func__);
1549
1550         if (!test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
1551             disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1552                 /* the media changed flag should be cleared after the seek.
1553                  * If it isn't, this means that there is really no disk in
1554                  * the drive.
1555                  */
1556                 set_bit(FD_DISK_CHANGED_BIT, &DRS->flags);
1557                 cont->done(0);
1558                 cont->redo();
1559                 return;
1560         }
1561         if (DRS->track <= NEED_1_RECAL) {
1562                 recalibrate_floppy();
1563                 return;
1564         } else if (test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
1565                    (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1566                    (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
1567                 /* we seek to clear the media-changed condition. Does anybody
1568                  * know a more elegant way, which works on all drives? */
1569                 if (raw_cmd->track)
1570                         track = raw_cmd->track - 1;
1571                 else {
1572                         if (DP->flags & FD_SILENT_DCL_CLEAR) {
1573                                 set_dor(fdc, ~(0x10 << UNIT(current_drive)), 0);
1574                                 blind_seek = 1;
1575                                 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1576                         }
1577                         track = 1;
1578                 }
1579         } else {
1580                 check_wp();
1581                 if (raw_cmd->track != DRS->track &&
1582                     (raw_cmd->flags & FD_RAW_NEED_SEEK))
1583                         track = raw_cmd->track;
1584                 else {
1585                         setup_rw_floppy();
1586                         return;
1587                 }
1588         }
1589
1590         do_floppy = seek_interrupt;
1591         output_byte(FD_SEEK);
1592         output_byte(UNIT(current_drive));
1593         if (output_byte(track) < 0) {
1594                 reset_fdc();
1595                 return;
1596         }
1597         debugt(__func__, "");
1598 }
1599
1600 static void recal_interrupt(void)
1601 {
1602         debugt(__func__, "");
1603         if (inr != 2)
1604                 FDCS->reset = 1;
1605         else if (ST0 & ST0_ECE) {
1606                 switch (DRS->track) {
1607                 case NEED_1_RECAL:
1608                         debugt(__func__, "need 1 recal");
1609                         /* after a second recalibrate, we still haven't
1610                          * reached track 0. Probably no drive. Raise an
1611                          * error, as failing immediately might upset
1612                          * computers possessed by the Devil :-) */
1613                         cont->error();
1614                         cont->redo();
1615                         return;
1616                 case NEED_2_RECAL:
1617                         debugt(__func__, "need 2 recal");
1618                         /* If we already did a recalibrate,
1619                          * and we are not at track 0, this
1620                          * means we have moved. (The only way
1621                          * not to move at recalibration is to
1622                          * be already at track 0.) Clear the
1623                          * new change flag */
1624                         debug_dcl(DP->flags,
1625                                   "clearing NEWCHANGE flag because of second recalibrate\n");
1626
1627                         clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
1628                         DRS->select_date = jiffies;
1629                         /* fall through */
1630                 default:
1631                         debugt(__func__, "default");
1632                         /* Recalibrate moves the head by at
1633                          * most 80 steps. If after one
1634                          * recalibrate we don't have reached
1635                          * track 0, this might mean that we
1636                          * started beyond track 80.  Try
1637                          * again.  */
1638                         DRS->track = NEED_1_RECAL;
1639                         break;
1640                 }
1641         } else
1642                 DRS->track = ST1;
1643         floppy_ready();
1644 }
1645
1646 static void print_result(char *message, int inr)
1647 {
1648         int i;
1649
1650         DPRINT("%s ", message);
1651         if (inr >= 0)
1652                 for (i = 0; i < inr; i++)
1653                         pr_cont("repl[%d]=%x ", i, reply_buffer[i]);
1654         pr_cont("\n");
1655 }
1656
1657 /* interrupt handler. Note that this can be called externally on the Sparc */
1658 irqreturn_t floppy_interrupt(int irq, void *dev_id)
1659 {
1660         int do_print;
1661         unsigned long f;
1662         void (*handler)(void) = do_floppy;
1663
1664         lasthandler = handler;
1665         interruptjiffies = jiffies;
1666
1667         f = claim_dma_lock();
1668         fd_disable_dma();
1669         release_dma_lock(f);
1670
1671         do_floppy = NULL;
1672         if (fdc >= N_FDC || FDCS->address == -1) {
1673                 /* we don't even know which FDC is the culprit */
1674                 pr_info("DOR0=%x\n", fdc_state[0].dor);
1675                 pr_info("floppy interrupt on bizarre fdc %d\n", fdc);
1676                 pr_info("handler=%pf\n", handler);
1677                 is_alive(__func__, "bizarre fdc");
1678                 return IRQ_NONE;
1679         }
1680
1681         FDCS->reset = 0;
1682         /* We have to clear the reset flag here, because apparently on boxes
1683          * with level triggered interrupts (PS/2, Sparc, ...), it is needed to
1684          * emit SENSEI's to clear the interrupt line. And FDCS->reset blocks the
1685          * emission of the SENSEI's.
1686          * It is OK to emit floppy commands because we are in an interrupt
1687          * handler here, and thus we have to fear no interference of other
1688          * activity.
1689          */
1690
1691         do_print = !handler && print_unex && initialized;
1692
1693         inr = result();
1694         if (do_print)
1695                 print_result("unexpected interrupt", inr);
1696         if (inr == 0) {
1697                 int max_sensei = 4;
1698                 do {
1699                         output_byte(FD_SENSEI);
1700                         inr = result();
1701                         if (do_print)
1702                                 print_result("sensei", inr);
1703                         max_sensei--;
1704                 } while ((ST0 & 0x83) != UNIT(current_drive) &&
1705                          inr == 2 && max_sensei);
1706         }
1707         if (!handler) {
1708                 FDCS->reset = 1;
1709                 return IRQ_NONE;
1710         }
1711         schedule_bh(handler);
1712         is_alive(__func__, "normal interrupt end");
1713
1714         /* FIXME! Was it really for us? */
1715         return IRQ_HANDLED;
1716 }
1717
1718 static void recalibrate_floppy(void)
1719 {
1720         debugt(__func__, "");
1721         do_floppy = recal_interrupt;
1722         output_byte(FD_RECALIBRATE);
1723         if (output_byte(UNIT(current_drive)) < 0)
1724                 reset_fdc();
1725 }
1726
1727 /*
1728  * Must do 4 FD_SENSEIs after reset because of ``drive polling''.
1729  */
1730 static void reset_interrupt(void)
1731 {
1732         debugt(__func__, "");
1733         result();               /* get the status ready for set_fdc */
1734         if (FDCS->reset) {
1735                 pr_info("reset set in interrupt, calling %pf\n", cont->error);
1736                 cont->error();  /* a reset just after a reset. BAD! */
1737         }
1738         cont->redo();
1739 }
1740
1741 /*
1742  * reset is done by pulling bit 2 of DOR low for a while (old FDCs),
1743  * or by setting the self clearing bit 7 of STATUS (newer FDCs)
1744  */
1745 static void reset_fdc(void)
1746 {
1747         unsigned long flags;
1748
1749         do_floppy = reset_interrupt;
1750         FDCS->reset = 0;
1751         reset_fdc_info(0);
1752
1753         /* Pseudo-DMA may intercept 'reset finished' interrupt.  */
1754         /* Irrelevant for systems with true DMA (i386).          */
1755
1756         flags = claim_dma_lock();
1757         fd_disable_dma();
1758         release_dma_lock(flags);
1759
1760         if (FDCS->version >= FDC_82072A)
1761                 fd_outb(0x80 | (FDCS->dtr & 3), FD_STATUS);
1762         else {
1763                 fd_outb(FDCS->dor & ~0x04, FD_DOR);
1764                 udelay(FD_RESET_DELAY);
1765                 fd_outb(FDCS->dor, FD_DOR);
1766         }
1767 }
1768
1769 static void show_floppy(void)
1770 {
1771         int i;
1772
1773         pr_info("\n");
1774         pr_info("floppy driver state\n");
1775         pr_info("-------------------\n");
1776         pr_info("now=%lu last interrupt=%lu diff=%lu last called handler=%pf\n",
1777                 jiffies, interruptjiffies, jiffies - interruptjiffies,
1778                 lasthandler);
1779
1780         pr_info("timeout_message=%s\n", timeout_message);
1781         pr_info("last output bytes:\n");
1782         for (i = 0; i < OLOGSIZE; i++)
1783                 pr_info("%2x %2x %lu\n",
1784                         output_log[(i + output_log_pos) % OLOGSIZE].data,
1785                         output_log[(i + output_log_pos) % OLOGSIZE].status,
1786                         output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1787         pr_info("last result at %lu\n", resultjiffies);
1788         pr_info("last redo_fd_request at %lu\n", lastredo);
1789         print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1,
1790                        reply_buffer, resultsize, true);
1791
1792         pr_info("status=%x\n", fd_inb(FD_STATUS));
1793         pr_info("fdc_busy=%lu\n", fdc_busy);
1794         if (do_floppy)
1795                 pr_info("do_floppy=%pf\n", do_floppy);
1796         if (work_pending(&floppy_work))
1797                 pr_info("floppy_work.func=%pf\n", floppy_work.func);
1798         if (delayed_work_pending(&fd_timer))
1799                 pr_info("delayed work.function=%p expires=%ld\n",
1800                        fd_timer.work.func,
1801                        fd_timer.timer.expires - jiffies);
1802         if (delayed_work_pending(&fd_timeout))
1803                 pr_info("timer_function=%p expires=%ld\n",
1804                        fd_timeout.work.func,
1805                        fd_timeout.timer.expires - jiffies);
1806
1807         pr_info("cont=%p\n", cont);
1808         pr_info("current_req=%p\n", current_req);
1809         pr_info("command_status=%d\n", command_status);
1810         pr_info("\n");
1811 }
1812
1813 static void floppy_shutdown(struct work_struct *arg)
1814 {
1815         unsigned long flags;
1816
1817         if (initialized)
1818                 show_floppy();
1819         cancel_activity();
1820
1821         flags = claim_dma_lock();
1822         fd_disable_dma();
1823         release_dma_lock(flags);
1824
1825         /* avoid dma going to a random drive after shutdown */
1826
1827         if (initialized)
1828                 DPRINT("floppy timeout called\n");
1829         FDCS->reset = 1;
1830         if (cont) {
1831                 cont->done(0);
1832                 cont->redo();   /* this will recall reset when needed */
1833         } else {
1834                 pr_info("no cont in shutdown!\n");
1835                 process_fd_request();
1836         }
1837         is_alive(__func__, "");
1838 }
1839
1840 /* start motor, check media-changed condition and write protection */
1841 static int start_motor(void (*function)(void))
1842 {
1843         int mask;
1844         int data;
1845
1846         mask = 0xfc;
1847         data = UNIT(current_drive);
1848         if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1849                 if (!(FDCS->dor & (0x10 << UNIT(current_drive)))) {
1850                         set_debugt();
1851                         /* no read since this drive is running */
1852                         DRS->first_read_date = 0;
1853                         /* note motor start time if motor is not yet running */
1854                         DRS->spinup_date = jiffies;
1855                         data |= (0x10 << UNIT(current_drive));
1856                 }
1857         } else if (FDCS->dor & (0x10 << UNIT(current_drive)))
1858                 mask &= ~(0x10 << UNIT(current_drive));
1859
1860         /* starts motor and selects floppy */
1861         del_timer(motor_off_timer + current_drive);
1862         set_dor(fdc, mask, data);
1863
1864         /* wait_for_completion also schedules reset if needed. */
1865         return fd_wait_for_completion(DRS->select_date + DP->select_delay,
1866                                       (work_func_t)function);
1867 }
1868
1869 static void floppy_ready(void)
1870 {
1871         if (FDCS->reset) {
1872                 reset_fdc();
1873                 return;
1874         }
1875         if (start_motor(floppy_ready))
1876                 return;
1877         if (fdc_dtr())
1878                 return;
1879
1880         debug_dcl(DP->flags, "calling disk change from floppy_ready\n");
1881         if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1882             disk_change(current_drive) && !DP->select_delay)
1883                 twaddle();      /* this clears the dcl on certain
1884                                  * drive/controller combinations */
1885
1886 #ifdef fd_chose_dma_mode
1887         if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1888                 unsigned long flags = claim_dma_lock();
1889                 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1890                 release_dma_lock(flags);
1891         }
1892 #endif
1893
1894         if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1895                 perpendicular_mode();
1896                 fdc_specify();  /* must be done here because of hut, hlt ... */
1897                 seek_floppy();
1898         } else {
1899                 if ((raw_cmd->flags & FD_RAW_READ) ||
1900                     (raw_cmd->flags & FD_RAW_WRITE))
1901                         fdc_specify();
1902                 setup_rw_floppy();
1903         }
1904 }
1905
1906 static void floppy_start(void)
1907 {
1908         reschedule_timeout(current_reqD, "floppy start");
1909
1910         scandrives();
1911         debug_dcl(DP->flags, "setting NEWCHANGE in floppy_start\n");
1912         set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
1913         floppy_ready();
1914 }
1915
1916 /*
1917  * ========================================================================
1918  * here ends the bottom half. Exported routines are:
1919  * floppy_start, floppy_off, floppy_ready, lock_fdc, unlock_fdc, set_fdc,
1920  * start_motor, reset_fdc, reset_fdc_info, interpret_errors.
1921  * Initialization also uses output_byte, result, set_dor, floppy_interrupt
1922  * and set_dor.
1923  * ========================================================================
1924  */
1925 /*
1926  * General purpose continuations.
1927  * ==============================
1928  */
1929
1930 static void do_wakeup(void)
1931 {
1932         reschedule_timeout(MAXTIMEOUT, "do wakeup");
1933         cont = NULL;
1934         command_status += 2;
1935         wake_up(&command_done);
1936 }
1937
1938 static const struct cont_t wakeup_cont = {
1939         .interrupt      = empty,
1940         .redo           = do_wakeup,
1941         .error          = empty,
1942         .done           = (done_f)empty
1943 };
1944
1945 static const struct cont_t intr_cont = {
1946         .interrupt      = empty,
1947         .redo           = process_fd_request,
1948         .error          = empty,
1949         .done           = (done_f)empty
1950 };
1951
1952 static int wait_til_done(void (*handler)(void), bool interruptible)
1953 {
1954         int ret;
1955
1956         schedule_bh(handler);
1957
1958         if (interruptible)
1959                 wait_event_interruptible(command_done, command_status >= 2);
1960         else
1961                 wait_event(command_done, command_status >= 2);
1962
1963         if (command_status < 2) {
1964                 cancel_activity();
1965                 cont = &intr_cont;
1966                 reset_fdc();
1967                 return -EINTR;
1968         }
1969
1970         if (FDCS->reset)
1971                 command_status = FD_COMMAND_ERROR;
1972         if (command_status == FD_COMMAND_OKAY)
1973                 ret = 0;
1974         else
1975                 ret = -EIO;
1976         command_status = FD_COMMAND_NONE;
1977         return ret;
1978 }
1979
1980 static void generic_done(int result)
1981 {
1982         command_status = result;
1983         cont = &wakeup_cont;
1984 }
1985
1986 static void generic_success(void)
1987 {
1988         cont->done(1);
1989 }
1990
1991 static void generic_failure(void)
1992 {
1993         cont->done(0);
1994 }
1995
1996 static void success_and_wakeup(void)
1997 {
1998         generic_success();
1999         cont->redo();
2000 }
2001
2002 /*
2003  * formatting and rw support.
2004  * ==========================
2005  */
2006
2007 static int next_valid_format(void)
2008 {
2009         int probed_format;
2010
2011         probed_format = DRS->probed_format;
2012         while (1) {
2013                 if (probed_format >= 8 || !DP->autodetect[probed_format]) {
2014                         DRS->probed_format = 0;
2015                         return 1;
2016                 }
2017                 if (floppy_type[DP->autodetect[probed_format]].sect) {
2018                         DRS->probed_format = probed_format;
2019                         return 0;
2020                 }
2021                 probed_format++;
2022         }
2023 }
2024
2025 static void bad_flp_intr(void)
2026 {
2027         int err_count;
2028
2029         if (probing) {
2030                 DRS->probed_format++;
2031                 if (!next_valid_format())
2032                         return;
2033         }
2034         err_count = ++(*errors);
2035         INFBOUND(DRWE->badness, err_count);
2036         if (err_count > DP->max_errors.abort)
2037                 cont->done(0);
2038         if (err_count > DP->max_errors.reset)
2039                 FDCS->reset = 1;
2040         else if (err_count > DP->max_errors.recal)
2041                 DRS->track = NEED_2_RECAL;
2042 }
2043
2044 static void set_floppy(int drive)
2045 {
2046         int type = ITYPE(UDRS->fd_device);
2047
2048         if (type)
2049                 _floppy = floppy_type + type;
2050         else
2051                 _floppy = current_type[drive];
2052 }
2053
2054 /*
2055  * formatting support.
2056  * ===================
2057  */
2058 static void format_interrupt(void)
2059 {
2060         switch (interpret_errors()) {
2061         case 1:
2062                 cont->error();
2063         case 2:
2064                 break;
2065         case 0:
2066                 cont->done(1);
2067         }
2068         cont->redo();
2069 }
2070
2071 #define FM_MODE(x, y) ((y) & ~(((x)->rate & 0x80) >> 1))
2072 #define CT(x) ((x) | 0xc0)
2073
2074 static void setup_format_params(int track)
2075 {
2076         int n;
2077         int il;
2078         int count;
2079         int head_shift;
2080         int track_shift;
2081         struct fparm {
2082                 unsigned char track, head, sect, size;
2083         } *here = (struct fparm *)floppy_track_buffer;
2084
2085         raw_cmd = &default_raw_cmd;
2086         raw_cmd->track = track;
2087
2088         raw_cmd->flags = (FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2089                           FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK);
2090         raw_cmd->rate = _floppy->rate & 0x43;
2091         raw_cmd->cmd_count = NR_F;
2092         COMMAND = FM_MODE(_floppy, FD_FORMAT);
2093         DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2094         F_SIZECODE = FD_SIZECODE(_floppy);
2095         F_SECT_PER_TRACK = _floppy->sect << 2 >> F_SIZECODE;
2096         F_GAP = _floppy->fmt_gap;
2097         F_FILL = FD_FILL_BYTE;
2098
2099         raw_cmd->kernel_data = floppy_track_buffer;
2100         raw_cmd->length = 4 * F_SECT_PER_TRACK;
2101
2102         /* allow for about 30ms for data transport per track */
2103         head_shift = (F_SECT_PER_TRACK + 5) / 6;
2104
2105         /* a ``cylinder'' is two tracks plus a little stepping time */
2106         track_shift = 2 * head_shift + 3;
2107
2108         /* position of logical sector 1 on this track */
2109         n = (track_shift * format_req.track + head_shift * format_req.head)
2110             % F_SECT_PER_TRACK;
2111
2112         /* determine interleave */
2113         il = 1;
2114         if (_floppy->fmt_gap < 0x22)
2115                 il++;
2116
2117         /* initialize field */
2118         for (count = 0; count < F_SECT_PER_TRACK; ++count) {
2119                 here[count].track = format_req.track;
2120                 here[count].head = format_req.head;
2121                 here[count].sect = 0;
2122                 here[count].size = F_SIZECODE;
2123         }
2124         /* place logical sectors */
2125         for (count = 1; count <= F_SECT_PER_TRACK; ++count) {
2126                 here[n].sect = count;
2127                 n = (n + il) % F_SECT_PER_TRACK;
2128                 if (here[n].sect) {     /* sector busy, find next free sector */
2129                         ++n;
2130                         if (n >= F_SECT_PER_TRACK) {
2131                                 n -= F_SECT_PER_TRACK;
2132                                 while (here[n].sect)
2133                                         ++n;
2134                         }
2135                 }
2136         }
2137         if (_floppy->stretch & FD_SECTBASEMASK) {
2138                 for (count = 0; count < F_SECT_PER_TRACK; count++)
2139                         here[count].sect += FD_SECTBASE(_floppy) - 1;
2140         }
2141 }
2142
2143 static void redo_format(void)
2144 {
2145         buffer_track = -1;
2146         setup_format_params(format_req.track << STRETCH(_floppy));
2147         floppy_start();
2148         debugt(__func__, "queue format request");
2149 }
2150
2151 static const struct cont_t format_cont = {
2152         .interrupt      = format_interrupt,
2153         .redo           = redo_format,
2154         .error          = bad_flp_intr,
2155         .done           = generic_done
2156 };
2157
2158 static int do_format(int drive, struct format_descr *tmp_format_req)
2159 {
2160         int ret;
2161
2162         if (lock_fdc(drive, true))
2163                 return -EINTR;
2164
2165         set_floppy(drive);
2166         if (!_floppy ||
2167             _floppy->track > DP->tracks ||
2168             tmp_format_req->track >= _floppy->track ||
2169             tmp_format_req->head >= _floppy->head ||
2170             (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2171             !_floppy->fmt_gap) {
2172                 process_fd_request();
2173                 return -EINVAL;
2174         }
2175         format_req = *tmp_format_req;
2176         format_errors = 0;
2177         cont = &format_cont;
2178         errors = &format_errors;
2179         ret = wait_til_done(redo_format, true);
2180         if (ret == -EINTR)
2181                 return -EINTR;
2182         process_fd_request();
2183         return ret;
2184 }
2185
2186 /*
2187  * Buffer read/write and support
2188  * =============================
2189  */
2190
2191 static void floppy_end_request(struct request *req, int error)
2192 {
2193         unsigned int nr_sectors = current_count_sectors;
2194         unsigned int drive = (unsigned long)req->rq_disk->private_data;
2195
2196         /* current_count_sectors can be zero if transfer failed */
2197         if (error)
2198                 nr_sectors = blk_rq_cur_sectors(req);
2199         if (__blk_end_request(req, error, nr_sectors << 9))
2200                 return;
2201
2202         /* We're done with the request */
2203         floppy_off(drive);
2204         current_req = NULL;
2205 }
2206
2207 /* new request_done. Can handle physical sectors which are smaller than a
2208  * logical buffer */
2209 static void request_done(int uptodate)
2210 {
2211         struct request *req = current_req;
2212         struct request_queue *q;
2213         unsigned long flags;
2214         int block;
2215         char msg[sizeof("request done ") + sizeof(int) * 3];
2216
2217         probing = 0;
2218         snprintf(msg, sizeof(msg), "request done %d", uptodate);
2219         reschedule_timeout(MAXTIMEOUT, msg);
2220
2221         if (!req) {
2222                 pr_info("floppy.c: no request in request_done\n");
2223                 return;
2224         }
2225
2226         q = req->q;
2227
2228         if (uptodate) {
2229                 /* maintain values for invalidation on geometry
2230                  * change */
2231                 block = current_count_sectors + blk_rq_pos(req);
2232                 INFBOUND(DRS->maxblock, block);
2233                 if (block > _floppy->sect)
2234                         DRS->maxtrack = 1;
2235
2236                 /* unlock chained buffers */
2237                 spin_lock_irqsave(q->queue_lock, flags);
2238                 floppy_end_request(req, 0);
2239                 spin_unlock_irqrestore(q->queue_lock, flags);
2240         } else {
2241                 if (rq_data_dir(req) == WRITE) {
2242                         /* record write error information */
2243                         DRWE->write_errors++;
2244                         if (DRWE->write_errors == 1) {
2245                                 DRWE->first_error_sector = blk_rq_pos(req);
2246                                 DRWE->first_error_generation = DRS->generation;
2247                         }
2248                         DRWE->last_error_sector = blk_rq_pos(req);
2249                         DRWE->last_error_generation = DRS->generation;
2250                 }
2251                 spin_lock_irqsave(q->queue_lock, flags);
2252                 floppy_end_request(req, -EIO);
2253                 spin_unlock_irqrestore(q->queue_lock, flags);
2254         }
2255 }
2256
2257 /* Interrupt handler evaluating the result of the r/w operation */
2258 static void rw_interrupt(void)
2259 {
2260         int eoc;
2261         int ssize;
2262         int heads;
2263         int nr_sectors;
2264
2265         if (R_HEAD >= 2) {
2266                 /* some Toshiba floppy controllers occasionnally seem to
2267                  * return bogus interrupts after read/write operations, which
2268                  * can be recognized by a bad head number (>= 2) */
2269                 return;
2270         }
2271
2272         if (!DRS->first_read_date)
2273                 DRS->first_read_date = jiffies;
2274
2275         nr_sectors = 0;
2276         ssize = DIV_ROUND_UP(1 << SIZECODE, 4);
2277
2278         if (ST1 & ST1_EOC)
2279                 eoc = 1;
2280         else
2281                 eoc = 0;
2282
2283         if (COMMAND & 0x80)
2284                 heads = 2;
2285         else
2286                 heads = 1;
2287
2288         nr_sectors = (((R_TRACK - TRACK) * heads +
2289                        R_HEAD - HEAD) * SECT_PER_TRACK +
2290                       R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
2291
2292         if (nr_sectors / ssize >
2293             DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {
2294                 DPRINT("long rw: %x instead of %lx\n",
2295                        nr_sectors, current_count_sectors);
2296                 pr_info("rs=%d s=%d\n", R_SECTOR, SECTOR);
2297                 pr_info("rh=%d h=%d\n", R_HEAD, HEAD);
2298                 pr_info("rt=%d t=%d\n", R_TRACK, TRACK);
2299                 pr_info("heads=%d eoc=%d\n", heads, eoc);
2300                 pr_info("spt=%d st=%d ss=%d\n",
2301                         SECT_PER_TRACK, fsector_t, ssize);
2302                 pr_info("in_sector_offset=%d\n", in_sector_offset);
2303         }
2304
2305         nr_sectors -= in_sector_offset;
2306         INFBOUND(nr_sectors, 0);
2307         SUPBOUND(current_count_sectors, nr_sectors);
2308
2309         switch (interpret_errors()) {
2310         case 2:
2311                 cont->redo();
2312                 return;
2313         case 1:
2314                 if (!current_count_sectors) {
2315                         cont->error();
2316                         cont->redo();
2317                         return;
2318                 }
2319                 break;
2320         case 0:
2321                 if (!current_count_sectors) {
2322                         cont->redo();
2323                         return;
2324                 }
2325                 current_type[current_drive] = _floppy;
2326                 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2327                 break;
2328         }
2329
2330         if (probing) {
2331                 if (DP->flags & FTD_MSG)
2332                         DPRINT("Auto-detected floppy type %s in fd%d\n",
2333                                _floppy->name, current_drive);
2334                 current_type[current_drive] = _floppy;
2335                 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2336                 probing = 0;
2337         }
2338
2339         if (CT(COMMAND) != FD_READ ||
2340             raw_cmd->kernel_data == current_req->buffer) {
2341                 /* transfer directly from buffer */
2342                 cont->done(1);
2343         } else if (CT(COMMAND) == FD_READ) {
2344                 buffer_track = raw_cmd->track;
2345                 buffer_drive = current_drive;
2346                 INFBOUND(buffer_max, nr_sectors + fsector_t);
2347         }
2348         cont->redo();
2349 }
2350
2351 /* Compute maximal contiguous buffer size. */
2352 static int buffer_chain_size(void)
2353 {
2354         struct bio_vec *bv;
2355         int size;
2356         struct req_iterator iter;
2357         char *base;
2358
2359         base = bio_data(current_req->bio);
2360         size = 0;
2361
2362         rq_for_each_segment(bv, current_req, iter) {
2363                 if (page_address(bv->bv_page) + bv->bv_offset != base + size)
2364                         break;
2365
2366                 size += bv->bv_len;
2367         }
2368
2369         return size >> 9;
2370 }
2371
2372 /* Compute the maximal transfer size */
2373 static int transfer_size(int ssize, int max_sector, int max_size)
2374 {
2375         SUPBOUND(max_sector, fsector_t + max_size);
2376
2377         /* alignment */
2378         max_sector -= (max_sector % _floppy->sect) % ssize;
2379
2380         /* transfer size, beginning not aligned */
2381         current_count_sectors = max_sector - fsector_t;
2382
2383         return max_sector;
2384 }
2385
2386 /*
2387  * Move data from/to the track buffer to/from the buffer cache.
2388  */
2389 static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2390 {
2391         int remaining;          /* number of transferred 512-byte sectors */
2392         struct bio_vec *bv;
2393         char *buffer;
2394         char *dma_buffer;
2395         int size;
2396         struct req_iterator iter;
2397
2398         max_sector = transfer_size(ssize,
2399                                    min(max_sector, max_sector_2),
2400                                    blk_rq_sectors(current_req));
2401
2402         if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
2403             buffer_max > fsector_t + blk_rq_sectors(current_req))
2404                 current_count_sectors = min_t(int, buffer_max - fsector_t,
2405                                               blk_rq_sectors(current_req));
2406
2407         remaining = current_count_sectors << 9;
2408         if (remaining > blk_rq_bytes(current_req) && CT(COMMAND) == FD_WRITE) {
2409                 DPRINT("in copy buffer\n");
2410                 pr_info("current_count_sectors=%ld\n", current_count_sectors);
2411                 pr_info("remaining=%d\n", remaining >> 9);
2412                 pr_info("current_req->nr_sectors=%u\n",
2413                         blk_rq_sectors(current_req));
2414                 pr_info("current_req->current_nr_sectors=%u\n",
2415                         blk_rq_cur_sectors(current_req));
2416                 pr_info("max_sector=%d\n", max_sector);
2417                 pr_info("ssize=%d\n", ssize);
2418         }
2419
2420         buffer_max = max(max_sector, buffer_max);
2421
2422         dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2423
2424         size = blk_rq_cur_bytes(current_req);
2425
2426         rq_for_each_segment(bv, current_req, iter) {
2427                 if (!remaining)
2428                         break;
2429
2430                 size = bv->bv_len;
2431                 SUPBOUND(size, remaining);
2432
2433                 buffer = page_address(bv->bv_page) + bv->bv_offset;
2434                 if (dma_buffer + size >
2435                     floppy_track_buffer + (max_buffer_sectors << 10) ||
2436                     dma_buffer < floppy_track_buffer) {
2437                         DPRINT("buffer overrun in copy buffer %d\n",
2438                                (int)((floppy_track_buffer - dma_buffer) >> 9));
2439                         pr_info("fsector_t=%d buffer_min=%d\n",
2440                                 fsector_t, buffer_min);
2441                         pr_info("current_count_sectors=%ld\n",
2442                                 current_count_sectors);
2443                         if (CT(COMMAND) == FD_READ)
2444                                 pr_info("read\n");
2445                         if (CT(COMMAND) == FD_WRITE)
2446                                 pr_info("write\n");
2447                         break;
2448                 }
2449                 if (((unsigned long)buffer) % 512)
2450                         DPRINT("%p buffer not aligned\n", buffer);
2451
2452                 if (CT(COMMAND) == FD_READ)
2453                         memcpy(buffer, dma_buffer, size);
2454                 else
2455                         memcpy(dma_buffer, buffer, size);
2456
2457                 remaining -= size;
2458                 dma_buffer += size;
2459         }
2460         if (remaining) {
2461                 if (remaining > 0)
2462                         max_sector -= remaining >> 9;
2463                 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2464         }
2465 }
2466
2467 /* work around a bug in pseudo DMA
2468  * (on some FDCs) pseudo DMA does not stop when the CPU stops
2469  * sending data.  Hence we need a different way to signal the
2470  * transfer length:  We use SECT_PER_TRACK.  Unfortunately, this
2471  * does not work with MT, hence we can only transfer one head at
2472  * a time
2473  */
2474 static void virtualdmabug_workaround(void)
2475 {
2476         int hard_sectors;
2477         int end_sector;
2478
2479         if (CT(COMMAND) == FD_WRITE) {
2480                 COMMAND &= ~0x80;       /* switch off multiple track mode */
2481
2482                 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
2483                 end_sector = SECTOR + hard_sectors - 1;
2484                 if (end_sector > SECT_PER_TRACK) {
2485                         pr_info("too many sectors %d > %d\n",
2486                                 end_sector, SECT_PER_TRACK);
2487                         return;
2488                 }
2489                 SECT_PER_TRACK = end_sector;
2490                                         /* make sure SECT_PER_TRACK
2491                                          * points to end of transfer */
2492         }
2493 }
2494
2495 /*
2496  * Formulate a read/write request.
2497  * this routine decides where to load the data (directly to buffer, or to
2498  * tmp floppy area), how much data to load (the size of the buffer, the whole
2499  * track, or a single sector)
2500  * All floppy_track_buffer handling goes in here. If we ever add track buffer
2501  * allocation on the fly, it should be done here. No other part should need
2502  * modification.
2503  */
2504
2505 static int make_raw_rw_request(void)
2506 {
2507         int aligned_sector_t;
2508         int max_sector;
2509         int max_size;
2510         int tracksize;
2511         int ssize;
2512
2513         if (WARN(max_buffer_sectors == 0, "VFS: Block I/O scheduled on unopened device\n"))
2514                 return 0;
2515
2516         set_fdc((long)current_req->rq_disk->private_data);
2517
2518         raw_cmd = &default_raw_cmd;
2519         raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_DISK |
2520             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 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 static const struct io_region {
4342         int offset;
4343         int size;
4344 } io_regions[] = {
4345         { 2, 1 },
4346         /* address + 3 is sometimes reserved by pnp bios for motherboard */
4347         { 4, 2 },
4348         /* address + 6 is reserved, and may be taken by IDE.
4349          * Unfortunately, Adaptec doesn't know this :-(, */
4350         { 7, 1 },
4351 };
4352
4353 static void floppy_release_allocated_regions(int fdc, const struct io_region *p)
4354 {
4355         while (p != io_regions) {
4356                 p--;
4357                 release_region(FDCS->address + p->offset, p->size);
4358         }
4359 }
4360
4361 #define ARRAY_END(X) (&((X)[ARRAY_SIZE(X)]))
4362
4363 static int floppy_request_regions(int fdc)
4364 {
4365         const struct io_region *p;
4366
4367         for (p = io_regions; p < ARRAY_END(io_regions); p++) {
4368                 if (!request_region(FDCS->address + p->offset,
4369                                     p->size, "floppy")) {
4370                         DPRINT("Floppy io-port 0x%04lx in use\n",
4371                                FDCS->address + p->offset);
4372                         floppy_release_allocated_regions(fdc, p);
4373                         return -EBUSY;
4374                 }
4375         }
4376         return 0;
4377 }
4378
4379 static void floppy_release_regions(int fdc)
4380 {
4381         floppy_release_allocated_regions(fdc, ARRAY_END(io_regions));
4382 }
4383
4384 static int floppy_grab_irq_and_dma(void)
4385 {
4386         if (atomic_inc_return(&usage_count) > 1)
4387                 return 0;
4388
4389         /*
4390          * We might have scheduled a free_irq(), wait it to
4391          * drain first:
4392          */
4393         flush_workqueue(floppy_wq);
4394
4395         if (fd_request_irq()) {
4396                 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4397                        FLOPPY_IRQ);
4398                 atomic_dec(&usage_count);
4399                 return -1;
4400         }
4401         if (fd_request_dma()) {
4402                 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4403                        FLOPPY_DMA);
4404                 if (can_use_virtual_dma & 2)
4405                         use_virtual_dma = can_use_virtual_dma = 1;
4406                 if (!(can_use_virtual_dma & 1)) {
4407                         fd_free_irq();
4408                         atomic_dec(&usage_count);
4409                         return -1;
4410                 }
4411         }
4412
4413         for (fdc = 0; fdc < N_FDC; fdc++) {
4414                 if (FDCS->address != -1) {
4415                         if (floppy_request_regions(fdc))
4416                                 goto cleanup;
4417                 }
4418         }
4419         for (fdc = 0; fdc < N_FDC; fdc++) {
4420                 if (FDCS->address != -1) {
4421                         reset_fdc_info(1);
4422                         fd_outb(FDCS->dor, FD_DOR);
4423                 }
4424         }
4425         fdc = 0;
4426         set_dor(0, ~0, 8);      /* avoid immediate interrupt */
4427
4428         for (fdc = 0; fdc < N_FDC; fdc++)
4429                 if (FDCS->address != -1)
4430                         fd_outb(FDCS->dor, FD_DOR);
4431         /*
4432          * The driver will try and free resources and relies on us
4433          * to know if they were allocated or not.
4434          */
4435         fdc = 0;
4436         irqdma_allocated = 1;
4437         return 0;
4438 cleanup:
4439         fd_free_irq();
4440         fd_free_dma();
4441         while (--fdc >= 0)
4442                 floppy_release_regions(fdc);
4443         atomic_dec(&usage_count);
4444         return -1;
4445 }
4446
4447 static void floppy_release_irq_and_dma(void)
4448 {
4449         int old_fdc;
4450 #ifndef __sparc__
4451         int drive;
4452 #endif
4453         long tmpsize;
4454         unsigned long tmpaddr;
4455
4456         if (!atomic_dec_and_test(&usage_count))
4457                 return;
4458
4459         if (irqdma_allocated) {
4460                 fd_disable_dma();
4461                 fd_free_dma();
4462                 fd_free_irq();
4463                 irqdma_allocated = 0;
4464         }
4465         set_dor(0, ~0, 8);
4466 #if N_FDC > 1
4467         set_dor(1, ~8, 0);
4468 #endif
4469
4470         if (floppy_track_buffer && max_buffer_sectors) {
4471                 tmpsize = max_buffer_sectors * 1024;
4472                 tmpaddr = (unsigned long)floppy_track_buffer;
4473                 floppy_track_buffer = NULL;
4474                 max_buffer_sectors = 0;
4475                 buffer_min = buffer_max = -1;
4476                 fd_dma_mem_free(tmpaddr, tmpsize);
4477         }
4478 #ifndef __sparc__
4479         for (drive = 0; drive < N_FDC * 4; drive++)
4480                 if (timer_pending(motor_off_timer + drive))
4481                         pr_info("motor off timer %d still active\n", drive);
4482 #endif
4483
4484         if (delayed_work_pending(&fd_timeout))
4485                 pr_info("floppy timer still active:%s\n", timeout_message);
4486         if (delayed_work_pending(&fd_timer))
4487                 pr_info("auxiliary floppy timer still active\n");
4488         if (work_pending(&floppy_work))
4489                 pr_info("work still pending\n");
4490         old_fdc = fdc;
4491         for (fdc = 0; fdc < N_FDC; fdc++)
4492                 if (FDCS->address != -1)
4493                         floppy_release_regions(fdc);
4494         fdc = old_fdc;
4495 }
4496
4497 #ifdef MODULE
4498
4499 static char *floppy;
4500
4501 static void __init parse_floppy_cfg_string(char *cfg)
4502 {
4503         char *ptr;
4504
4505         while (*cfg) {
4506                 ptr = cfg;
4507                 while (*cfg && *cfg != ' ' && *cfg != '\t')
4508                         cfg++;
4509                 if (*cfg) {
4510                         *cfg = '\0';
4511                         cfg++;
4512                 }
4513                 if (*ptr)
4514                         floppy_setup(ptr);
4515         }
4516 }
4517
4518 static int __init floppy_module_init(void)
4519 {
4520         if (floppy)
4521                 parse_floppy_cfg_string(floppy);
4522         return floppy_init();
4523 }
4524 module_init(floppy_module_init);
4525
4526 static void __exit floppy_module_exit(void)
4527 {
4528         int drive;
4529
4530         blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4531         unregister_blkdev(FLOPPY_MAJOR, "fd");
4532         platform_driver_unregister(&floppy_driver);
4533
4534         for (drive = 0; drive < N_DRIVE; drive++) {
4535                 del_timer_sync(&motor_off_timer[drive]);
4536
4537                 if ((allowed_drive_mask & (1 << drive)) &&
4538                     fdc_state[FDC(drive)].version != FDC_NONE) {
4539                         del_gendisk(disks[drive]);
4540                         device_remove_file(&floppy_device[drive].dev, &dev_attr_cmos);
4541                         platform_device_unregister(&floppy_device[drive]);
4542                 }
4543                 blk_cleanup_queue(disks[drive]->queue);
4544
4545                 /*
4546                  * These disks have not called add_disk().  Don't put down
4547                  * queue reference in put_disk().
4548                  */
4549                 if (!(allowed_drive_mask & (1 << drive)) ||
4550                     fdc_state[FDC(drive)].version == FDC_NONE)
4551                         disks[drive]->queue = NULL;
4552
4553                 put_disk(disks[drive]);
4554         }
4555
4556         cancel_delayed_work_sync(&fd_timeout);
4557         cancel_delayed_work_sync(&fd_timer);
4558         destroy_workqueue(floppy_wq);
4559
4560         if (atomic_read(&usage_count))
4561                 floppy_release_irq_and_dma();
4562
4563         /* eject disk, if any */
4564         fd_eject(0);
4565 }
4566
4567 module_exit(floppy_module_exit);
4568
4569 module_param(floppy, charp, 0);
4570 module_param(FLOPPY_IRQ, int, 0);
4571 module_param(FLOPPY_DMA, int, 0);
4572 MODULE_AUTHOR("Alain L. Knaff");
4573 MODULE_SUPPORTED_DEVICE("fd");
4574 MODULE_LICENSE("GPL");
4575
4576 /* This doesn't actually get used other than for module information */
4577 static const struct pnp_device_id floppy_pnpids[] = {
4578         {"PNP0700", 0},
4579         {}
4580 };
4581
4582 MODULE_DEVICE_TABLE(pnp, floppy_pnpids);
4583
4584 #else
4585
4586 __setup("floppy=", floppy_setup);
4587 module_init(floppy_init)
4588 #endif
4589
4590 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);