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