drivers/block/floppy.c

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