root/drivers/block/floppy.c

DEFINITIONS

1. fallback_on_nodma_alloc
2. drive_no_geom
3. fd_eject
4. set_debugt
5. debugt
6. set_debugt
7. debugt
8. is_alive
9. __reschedule_timeout
10. reschedule_timeout
11. disk_change
12. is_selected
13. is_ready_state
14. set_dor
15. twaddle
16. reset_fdc_info
17. set_fdc
18. lock_fdc
19. unlock_fdc
20. motor_off_callback
21. floppy_off
22. scandrives
23. empty
24. floppy_work_workfn
25. schedule_bh
26. fd_timer_workfn
27. cancel_activity
28. fd_watchdog
29. main_command_interrupt
30. fd_wait_for_completion
31. setup_DMA
32. wait_til_ready
33. output_byte
34. result
35. need_more_output
36. perpendicular_mode
37. fdc_configure
38. fdc_specify
39. fdc_dtr
40. tell_sector
41. print_errors
42. interpret_errors
43. setup_rw_floppy
44. seek_interrupt
45. check_wp
46. seek_floppy
47. recal_interrupt
48. print_result
49. floppy_interrupt
50. recalibrate_floppy
51. reset_interrupt
52. reset_fdc
53. show_floppy
54. floppy_shutdown
55. start_motor
56. floppy_ready
57. floppy_start
58. do_wakeup
59. wait_til_done
60. generic_done
61. generic_success
62. generic_failure
63. success_and_wakeup
64. next_valid_format
65. bad_flp_intr
66. set_floppy
67. format_interrupt
68. setup_format_params
69. redo_format
70. do_format
71. floppy_end_request
72. request_done
73. rw_interrupt
74. buffer_chain_size
75. transfer_size
76. copy_buffer
77. virtualdmabug_workaround
78. make_raw_rw_request
79. set_next_request
80. redo_fd_request
81. process_fd_request
82. floppy_queue_rq
83. poll_drive
84. reset_intr
85. user_reset_fdc
86. fd_copyout
87. fd_copyin
88. drive_name
89. raw_cmd_done
90. raw_cmd_copyout
91. raw_cmd_free
92. raw_cmd_copyin
93. raw_cmd_ioctl
94. invalidate_drive
95. set_geometry
96. normalize_ioctl
97. get_floppy_geometry
98. fd_getgeo
99. valid_floppy_drive_params
100. fd_locked_ioctl
101. fd_ioctl
102. compat_get_prm
103. compat_setdrvprm
104. compat_getdrvprm
105. compat_getdrvstat
106. compat_getfdcstat
107. compat_werrorget
108. fd_compat_ioctl
109. config_types
110. floppy_release
111. floppy_open
112. floppy_check_events
113. floppy_rb0_cb
114. __floppy_read_block_0
115. floppy_revalidate
116. get_fdc_version
117. floppy_set_flags
118. daring
119. set_cmos
120. floppy_setup
121. floppy_cmos_show
122. floppy_device_release
123. floppy_resume
124. floppy_available
125. floppy_find
126. do_floppy_init
127. floppy_async_init
128. floppy_init
129. floppy_release_allocated_regions
130. floppy_request_regions
131. floppy_release_regions
132. floppy_grab_irq_and_dma
133. floppy_release_irq_and_dma
134. parse_floppy_cfg_string
135. floppy_module_init
136. floppy_module_exit

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