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