PageRenderTime 141ms CodeModel.GetById 25ms app.highlight 97ms RepoModel.GetById 2ms 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

Large files files are truncated, but you can click here to view the full 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

Large files files are truncated, but you can click here to view the full file