PageRenderTime 238ms CodeModel.GetById 22ms app.highlight 183ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/block/floppy.c

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