/*
 *  linux/drivers/block/ide.c	Version 4.11  Jul 29, 1995
 *
 *  Copyright (C) 1994, 1995  Linus Torvalds & authors (see below)
 */

/*
 * This is the dual IDE interface driver, as evolved from hd.c.  
 * It supports up to two IDE interfaces, on one or two IRQs (usually 14 & 15).
 * There can be up to two drives per interface, as per the ATA-2 spec.
 *
 * Primary   i/f: ide0: major=3;  (hda)         minor=0, (hdb)         minor=64
 * Secondary i/f: ide1: major=22; (hdc or hd1a) minor=0, (hdd or hd1b) minor=64
 *
 *  From hd.c:
 *  |
 *  | It traverses the request-list, using interrupts to jump between functions.
 *  | As nearly all functions can be called within interrupts, we may not sleep.
 *  | Special care is recommended.  Have Fun!
 *  |
 *  | modified by Drew Eckhardt to check nr of hd's from the CMOS.
 *  |
 *  | Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
 *  | in the early extended-partition checks and added DM partitions.
 *  |
 *  | Early work on error handling by Mika Liljeberg (liljeber@cs.Helsinki.FI).
 *  |
 *  | IRQ-unmask, drive-id, multiple-mode, support for ">16 heads",
 *  | and general streamlining by Mark Lord (mlord@bnr.ca).
 *
 *  October, 1994 -- Complete line-by-line overhaul for linux 1.1.x, by:
 *
 *	Mark Lord	(mlord@bnr.ca)			(IDE Perf.Pkg)
 *	Delman Lee	(delman@mipg.upenn.edu)		("Mr. atdisk2")
 *	Petri Mattila	(ptjmatti@kruuna.helsinki.fi)	(EIDE stuff)
 *	Scott Snyder	(snyder@fnald0.fnal.gov)	(ATAPI IDE cd-rom)
 *
 *  This was a rewrite of just about everything from hd.c, though some original
 *  code is still sprinkled about.  Think of it as a major evolution, with 
 *  inspiration from lots of linux users, esp.  hamish@zot.apana.org.au
 *
 *  Version 1.0 ALPHA	initial code, primary i/f working okay
 *  Version 1.3 BETA	dual i/f on shared irq tested & working!
 *  Version 1.4 BETA	added auto probing for irq(s)
 *  Version 1.5 BETA	added ALPHA (untested) support for IDE cd-roms,
 *  ...
 *  Version 3.5		correct the bios_cyl field if it's too small
 *  (linux 1.1.76)	 (to help fdisk with brain-dead BIOSs)
 *  Version 3.6		cosmetic corrections to comments and stuff
 *  (linux 1.1.77)	reorganise probing code to make it understandable
 *			added halfway retry to probing for drive identification
 *			added "hdx=noprobe" command line option
 *			allow setting multmode even when identification fails
 *  Version 3.7		move set_geometry=1 from do_identify() to ide_init()
 *			increase DRQ_WAIT to eliminate nuisance messages
 *			wait for DRQ_STAT instead of DATA_READY during probing
 *			  (courtesy of Gary Thomas gary@efland.UU.NET)
 *  Version 3.8		fixed byte-swapping for confused Mitsumi cdrom drives
 *			update of ide-cd.c from Scott, allows blocksize=1024
 *			cdrom probe fixes, inspired by jprang@uni-duisburg.de
 *  Version 3.9		don't use LBA if lba_capacity looks funny
 *			correct the drive capacity calculations
 *			fix probing for old Seagates without HD_ALTSTATUS
 *			fix byte-ordering for some NEC cdrom drives
 *  Version 3.10	disable multiple mode by default; was causing trouble
 *  Version 3.11	fix mis-identification of old WD disks as cdroms
 *  Version 3,12	simplify logic for selecting initial mult_count
 *			  (fixes problems with buggy WD drives)
 *  Version 3.13	remove excess "multiple mode disabled" messages
 *  Version 3.14	fix ide_error() handling of BUSY_STAT
 *			fix byte-swapped cdrom strings (again.. arghh!)
 *			ignore INDEX bit when checking the ALTSTATUS reg
 *  Version 3.15	add SINGLE_THREADED flag for use with dual-CMD i/f
 *			ignore WRERR_STAT for non-write operations
 *			added VLB_SYNC support for DC-2000A & others,
 *			 (incl. some Promise chips), courtesy of Frank Gockel
 *  Version 3.16	convert VLB_32BIT and VLB_SYNC into runtime flags
 *			add ioctls to get/set VLB flags (HDIO_[SG]ET_CHIPSET)
 *			rename SINGLE_THREADED to SUPPORT_SERIALIZE,
 *			add boot flag to "serialize" operation for CMD i/f
 *			add optional support for DTC2278 interfaces,
 *			 courtesy of andy@cercle.cts.com (Dyan Wile).
 *			add boot flag to enable "dtc2278" probe
 *			add probe to avoid EATA (SCSI) interfaces,
 *			 courtesy of neuffer@goofy.zdv.uni-mainz.de.
 *  Version 4.00	tidy up verify_area() calls - heiko@colossus.escape.de
 *			add flag to ignore WRERR_STAT for some drives
 *			 courtesy of David.H.West@um.cc.umich.edu
 *			assembly syntax tweak to VLB_SYNC
 *			removeable drive support from scuba@cs.tu-berlin.de
 *			add transparent support for DiskManager-6.0x "Dynamic
 *			 Disk Overlay" (DDO), most of this in in genhd.c
 *			eliminate "multiple mode turned off" message at boot
 *  Version 4.10	fix bug in ioctl for "hdparm -c3"
 *			fix DM6:DDO support -- now works with LILO, fdisk, ...
 *			don't treat some naughty WD drives as removeable
 *  Version 4.11	updated DM6 support using info provided by OnTrack
 *
 *  To do:
 *	- add support for alternative IDE port addresses
 *	- refine the DiskManager-6.0x overlay support (special cases)
 *	- improved CMD support:  tech info is in my hands for 640B chip
 *	- special 32-bit controller-type detection & support
 *	- figure out how to support oddball "intelligent" caching cards
 *	- reverse-engineer 3/4 drive support on fancy "Promise" cards
 *	- find someone to work on IDE *tape drive* support
 */

#include <linux/config.h>
#include <linux/errno.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/hdreg.h>
#include <linux/genhd.h>
#include <linux/malloc.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/major.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/blkdev.h>
#include <asm/bitops.h>
#include <asm/irq.h>
#include <asm/segment.h>
#include <asm/system.h>

/*****************************************************************************
 * IDE driver configuration options (play with these as desired):
 */
#define REALLY_SLOW_IO			/* most systems can safely undef this */
#include <asm/io.h>

#ifdef __alpha__
# ifndef SUPPORT_VLB_SYNC
#  define SUPPORT_VLB_SYNC	0
# endif
#endif

#undef	REALLY_FAST_IO			/* define if ide ports are perfect */
#define INITIAL_MULT_COUNT	0	/* off=0; on=2,4,8,16,32, etc.. */
#ifndef SUPPORT_VLB_32BIT		/* 1 to support 32bit I/O on VLB */
#define SUPPORT_VLB_32BIT	1	/* 0 to reduce kernel size */
#endif
#ifndef SUPPORT_VLB_SYNC		/* 1 to support weird 32-bit chips */
#define SUPPORT_VLB_SYNC	1	/* 0 to reduce kernel size */
#endif
#ifndef DISK_RECOVERY_TIME		/* off=0; on=access_delay_time */
#define DISK_RECOVERY_TIME	0	/*  for hardware that needs it */
#endif
#ifndef OK_TO_RESET_CONTROLLER		/* 1 needed for good error recovery */
#define OK_TO_RESET_CONTROLLER	1	/* 0 for use with AH2372A/B interface */
#endif
#ifndef SUPPORT_TWO_INTERFACES		/* 1 to support one/two interfaces */
#define SUPPORT_TWO_INTERFACES	1	/* 0 for a smaller, faster kernel */
#endif
#ifndef OPTIMIZE_IRQS			/* 1 for slightly faster code */
#define OPTIMIZE_IRQS		1	/* 0 to reduce kernel size */
#endif
#ifndef SUPPORT_SERIALIZE		/* 1 to support CMD dual interfaces */
#define SUPPORT_SERIALIZE	1	/* 0 to reduce kernel size */
#endif
#ifndef SUPPORT_SHARING_IRQ		/* 1 to allow two IDE i/f on one IRQ */
#define SUPPORT_SHARING_IRQ	1	/* 0 to reduce kernel size */
#endif
#ifndef SUPPORT_DTC2278			/* 1 to support DTC2278 chipset */
#define SUPPORT_DTC2278		1	/* 0 to reduce kernel size */
#endif
#ifndef FANCY_STATUS_DUMPS		/* 1 for human-readable drive errors */
#define FANCY_STATUS_DUMPS	1	/* 0 to reduce kernel size */
#endif
#define PROBE_FOR_IRQS		1	/* 0 to force use of defaults below */
#define DEFAULT_IDE0_IRQ	14	/* in case irq-probe fails */
#define DEFAULT_IDE1_IRQ	15	/* in case irq-probe fails */

/* IDE_DRIVE_CMD is used to implement many features of the hdparm utility */
#define IDE_DRIVE_CMD		99	/* (magic) undef to reduce kernel size*/

/*
 *  "No user-serviceable parts" beyond this point  :)
 ******************************************************************************
 */

/*
 * Need to change these elsewhere in the kernel (someday)
 */
#ifndef IDE0_TIMER
#define IDE0_TIMER		HD_TIMER
#define IDE1_TIMER		HD_TIMER2
#endif

/*
 * Ensure that various configuration flags have compatible settings
 */
#ifdef REALLY_SLOW_IO
#undef REALLY_FAST_IO
#endif
#ifdef CONFIG_BLK_DEV_HD
#undef  SUPPORT_TWO_INTERFACES
#define SUPPORT_TWO_INTERFACES	0
#endif	/* CONFIG_BLK_DEV_HD */

#if SUPPORT_TWO_INTERFACES
#define HWIF			hwif
#define DEV_HWIF		(dev->hwif)
#if SUPPORT_SERIALIZE
#undef	SUPPORT_SHARING_IRQ
#define	SUPPORT_SHARING_IRQ	1
#endif
#else
#undef	SUPPORT_SERIALIZE
#define SUPPORT_SERIALIZE		0
#undef	OPTIMIZE_IRQS
#define OPTIMIZE_IRQS		0
#undef	SUPPORT_SHARING_IRQ
#define SUPPORT_SHARING_IRQ	0
#ifdef CONFIG_BLK_DEV_HD
#define HWIF			1
#else
#define HWIF			0
#endif	/* CONFIG_BLK_DEV_HD */
#define DEV_HWIF		HWIF
#endif	/* SUPPORT_TWO_INTERFACES */

/*
 * Definitions for accessing IDE controller registers
 */
typedef unsigned char		byte;	/* used everywhere */
#define IDE_PORT(p,hwif) ((p)^((hwif)<<7)) /* IDE0: p^0x00 , IDE1: p^0x80 */

#ifdef REALLY_FAST_IO
#define OUT_BYTE(b,p)		outb((b),IDE_PORT(p,DEV_HWIF))
#define IN_BYTE(p,hwif)		(byte)inb(IDE_PORT(p,hwif))
#else
#define OUT_BYTE(b,p)		outb_p((b),IDE_PORT(p,DEV_HWIF))
#define IN_BYTE(p,hwif)		(byte)inb_p(IDE_PORT(p,hwif))
#endif /* REALLY_FAST_IO */

#if SUPPORT_VLB_32BIT
#if SUPPORT_VLB_SYNC
#define VLB_SYNC __asm__ __volatile__ ("pusha\n movl $0x01f2,%edx\n inb %dx,%al\n inb %dx,%al\n inb %dx,%al\n popa\n")
#endif	/* SUPPORT_VLB_SYNC */
#endif	/* SUPPORT_VLB_32BIT */

#if SUPPORT_DTC2278
static uint probe_dtc2278 = 0;
#endif

#define GET_ERR(hwif)		IN_BYTE(HD_ERROR,hwif)
#define GET_STAT(hwif)		IN_BYTE(HD_STATUS,hwif)
#define OK_STAT(stat,good,bad)	(((stat)&((good)|(bad)))==(good))
#define BAD_R_STAT		(BUSY_STAT   | ERR_STAT)
#define BAD_W_STAT		(BAD_R_STAT  | WRERR_STAT)
#define BAD_STAT		(BAD_R_STAT  | DRQ_STAT)
#define DRIVE_READY		(READY_STAT  | SEEK_STAT)
#define DATA_READY		(DRIVE_READY | DRQ_STAT)

/*
 * Some more useful definitions
 */
#define BIOS_SECTORS(dev)	(dev->bios_head*dev->bios_sect*dev->bios_cyl)
#define HD_NAME		"hd"	/* the same for both i/f;  see also genhd.c */
#define PARTN_BITS	6	/* number of minor dev bits for partitions */
#define PARTN_MASK	((1<<PARTN_BITS)-1)	/* a useful bit mask */
#define MAX_DRIVES	2	/* per interface; 2 assumed by lots of code */
#define SECTOR_WORDS	(512 / 4)	/* number of 32bit words per sector */

/*
 * Timeouts for various operations:
 */
#define WAIT_DRQ	(5*HZ/100)	/* 50msec - spec allows up to 20ms */
#define WAIT_READY	(3*HZ/100)	/* 30msec - should be instantaneous */
#define WAIT_PIDENTIFY	(1*HZ)	/* 1sec   - should be less than 3ms (?) */
#define WAIT_WORSTCASE	(30*HZ)	/* 30sec  - worst case when spinning up */
#define WAIT_CMD	(10*HZ)	/* 10sec  - maximum wait for an IRQ to happen */

/*
 * Now for the data we need to maintain per-device:  ide_dev_t
 *
 * For fast indexing, sizeof(ide_dev_t) = 32 = power_of_2;
 * Everything is carefully aligned on appropriate boundaries,
 *  and several fields are placed for optimal (gcc) access.
 *
 * Ugh.  Actually, we're two bytes over (34 bytes).. gotta fix this someday.
 */
typedef enum {disk, cdrom} dev_type;

typedef union {
	unsigned all			: 8;	/* all of the bits together */
	struct {
		unsigned set_geometry	: 1;	/* respecify drive geometry */
		unsigned recalibrate	: 1;	/* seek to cyl 0      */
		unsigned set_multmode	: 1;	/* set multmode count */
		unsigned reserved	: 5;	/* unused */
		} b;
	} special_t;

typedef union {
	unsigned all			: 8;	/* all of the bits together */
	struct {
		unsigned head		: 4;	/* always zeros here */
		unsigned drive		: 1;	/* drive number */
		unsigned bit5		: 1;	/* always 1 */
		unsigned lba		: 1;	/* LBA instead of CHS */
		unsigned bit7		: 1;	/* always 1 */
	} b;
	} select_t;

typedef struct {
	byte     hwif;			/* first field gets very fast access */
	byte     unmask;		/* pretty quick access to this also */
	dev_type type		: 1;	/* disk or cdrom (or tape, floppy..) */
	unsigned present	: 1;	/* drive is physically present */
	unsigned noprobe 	: 1;	/* from:  hdx=noprobe */
	unsigned keep_settings  : 1;	/* restore settings after drive reset */
	unsigned busy		: 1;	/* mutex for ide_open, revalidate_.. */
	unsigned vlb_32bit	: 1;	/* use 32bit in/out for data */
	unsigned vlb_sync	: 1;	/* needed for some 32bit chip sets */
	unsigned be_quiet	: 1;	/* supress "multiple mode" msg at boot */
	special_t special;		/* special action flags */
	select_t  select;		/* basic drive/head select reg value */
	byte mult_count, chipset, bad_wstat;
	byte usage, mult_req, wpcom, ctl;
	byte head, sect, bios_head, bios_sect;
	unsigned short cyl, bios_cyl;
	const char *name;
	struct hd_driveid *id;
	struct wait_queue *wqueue;
	byte sect0, removeable;
	} ide_dev_t;

/*
 * Stuff prefixed by "ide_" is indexed by the IDE interface number: 0 or 1
 */
static const byte	ide_major    [2] = {IDE0_MAJOR,IDE1_MAJOR};
static byte		ide_irq      [2] = {DEFAULT_IDE0_IRQ,DEFAULT_IDE1_IRQ};
static struct hd_struct	ide_hd       [2][MAX_DRIVES<<PARTN_BITS] = {{{0,0},},};
static int		ide_sizes    [2][MAX_DRIVES<<PARTN_BITS] = {{0,},};
static int		ide_blksizes [2][MAX_DRIVES<<PARTN_BITS] = {{0,},};
static unsigned long	ide_capacity [2][MAX_DRIVES] = {{0,},};
static ide_dev_t	ide_dev      [2][MAX_DRIVES] = {{{0,},},};
static ide_dev_t	*ide_cur_dev [2] = {NULL,NULL};
static void		(*ide_handler[2])(ide_dev_t *) = {NULL,NULL};
static struct request	*ide_cur_rq  [2] = {NULL,NULL}; /* current request */
static struct request	ide_write_rq [2];  /* copy of *ide_cur_rq for WRITEs */
static const int	ide_timer    [2] = {IDE0_TIMER,IDE1_TIMER};
static const int	ide_timerbit[2] = {(1<<IDE0_TIMER),(1<<IDE1_TIMER)};
static const char	*ide_name    [2] = {"ide0", "ide1"};
static const char	*ide_devname [2][MAX_DRIVES] = /* for printk()'s */
	{{HD_NAME "a", HD_NAME "b"}, {HD_NAME "c", HD_NAME "d"}};
static const char	*unsupported = " not supported by this kernel\n";

static byte		single_threaded    = 0;
#if SUPPORT_SHARING_IRQ
static byte		sharing_single_irq = 0;	/* for two i/f on one IRQ */
static volatile byte 	current_hwif = 0;	/* for single_threaded==1 */
#endif /* SUPPORT_SHARING_IRQ */

/*
 * This structure is used to register our block device(s) with the kernel:
 */
static void ide0_geninit(void), ide1_geninit(void);
static struct gendisk	ide_gendisk  [2] =
	{{
		IDE0_MAJOR,	/* major number */	
		HD_NAME,	/* same as below; see genhd.c before changing */
		PARTN_BITS,	/* minor_shift (to extract minor number) */
		1 << PARTN_BITS,/* max_p (number of partitions per real) */
		MAX_DRIVES,	/* maximum number of real drives */
		ide0_geninit,	/* init function */
		ide_hd[0],	/* hd_struct */
		ide_sizes[0],	/* block sizes */
		0,		/* nr_real (number of drives present) */
		ide_dev[0],	/* ptr to internal data structure */
		NULL		/* next */
	},{
		IDE1_MAJOR,	/* major number */	
		HD_NAME,	/* same as above; see genhd.c before changing */
		PARTN_BITS,	/* minor_shift (to extract minor number) */
		1 << PARTN_BITS,/* max_p (number of partitions per real) */
		MAX_DRIVES,	/* maximum number of real drives */
		ide1_geninit,	/* init function */
		ide_hd[1],	/* hd_struct */
		ide_sizes[1],	/* block sizes */
		0,		/* nr_real (number of drives present) */
		ide_dev[1],	/* ptr to internal data structure */
		NULL		/* next */
	}};

/*
 * One final include file, which references some of the data/defns from above
 */
#define IDE_DRIVER	/* "parameter" for blk.h */
#include "blk.h"

/*
 * For really screwy hardware (hey, at least it *can* be used with Linux!)
 */
#if (DISK_RECOVERY_TIME > 0)
static unsigned long	ide_lastreq[] = {0,0}; /* completion time of last I/O */
#define SET_DISK_RECOVERY_TIMER  ide_lastreq[DEV_HWIF] = read_timer();
static unsigned long read_timer(void)
{
	unsigned long t, flags;
	int i;

	save_flags(flags);
	cli();
	t = jiffies * 11932;
    	outb_p(0, 0x43);
	i = inb_p(0x40);
	i |= inb(0x40) << 8;
	restore_flags(flags);
	return (t - i);
}
#else
#define SET_DISK_RECOVERY_TIMER	/* nothing */
#endif /* DISK_RECOVERY_TIME */

/*
 * The heart of the driver, referenced from lots of other routines:
 */
static void do_request (byte hwif);
#define DO_REQUEST {SET_DISK_RECOVERY_TIMER do_request(DEV_HWIF);}

/*
 * This is a macro rather than an inline to permit better gcc code.
 * Caller MUST do sti() before invoking WAIT_STAT() (for jiffies to work).
 *
 * This routine should get fixed to not hog the cpu during extra long waits..
 * That could be done by busy-waiting for the first jiffy or two, and then
 * setting a timer to wake up at half second intervals thereafter,
 * until WAIT_WORSTCASE is achieved, before timing out.
 */
#define WAIT_STAT(dev,good,bad,timeout,msg,label)			\
{									\
	byte stat;							\
	udelay(1);	/* spec allows drive 400ns to assert "BUSY" */	\
	if (GET_STAT(DEV_HWIF) & BUSY_STAT) {				\
		unsigned long timer = jiffies + timeout;		\
		do {							\
			if ((GET_STAT(DEV_HWIF) & BUSY_STAT) == 0)	\
				break;					\
		} while (timer > jiffies);				\
	}								\
	udelay(1);	/* spec allows 400ns for status to stabilize */	\
	if (!OK_STAT(stat=GET_STAT(DEV_HWIF), good, bad)) {		\
		ide_error(dev, msg " error", stat);			\
		goto label;						\
	}								\
}

/*
 * This is used for all data transfers *from* the IDE interface
 */
void input_ide_data (ide_dev_t *dev, void *buffer, uint wcount)
{
#if SUPPORT_VLB_32BIT
	if (dev->vlb_32bit) {
#if SUPPORT_VLB_SYNC
		if (dev->vlb_sync) {
			cli();
			VLB_SYNC;
			insl(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount);
			if (dev->unmask)
				sti();
		} else
#endif /* SUPPORT_VLB_SYNC */
			insl(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount);
	} else
#endif /* SUPPORT_VLB_32BIT */
		insw(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount<<1);
}

/*
 * This is used for all data transfers *to* the IDE interface
 */
void output_ide_data (ide_dev_t *dev, void *buffer, uint wcount)
{
#if SUPPORT_VLB_32BIT
	if (dev->vlb_32bit) {
#if SUPPORT_VLB_SYNC
		if (dev->vlb_sync) {
			cli();
			VLB_SYNC;
			outsl(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount);
			if (dev->unmask)
				sti();
		} else
			outsl(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount);
#endif /* SUPPORT_VLB_SYNC */
	} else
#endif /* SUPPORT_VLB_32BIT */
		outsw(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount<<1);
}

/*
 * This should get invoked on every exit path from the driver.
 */
static inline void start_ide_timer (byte hwif)
{
	if (ide_handler[HWIF] != NULL) {  	/* waiting for an irq? */
		timer_table[ide_timer[HWIF]].expires = jiffies + WAIT_CMD;
		timer_active |= ide_timerbit[HWIF];
	}
}

static void do_ide_reset (ide_dev_t *dev)
{
	byte tmp;
	unsigned long timer, flags;

	save_flags(flags);
	sti();
	for (tmp = 0; tmp < MAX_DRIVES; tmp++) {
		ide_dev_t *rdev = &ide_dev[DEV_HWIF][tmp];
		rdev->special.b.set_geometry = 1;
		rdev->special.b.recalibrate  = 1;
		rdev->special.b.set_multmode = 0;
		if (OK_TO_RESET_CONTROLLER)
			rdev->mult_count = 0;
		if (!rdev->keep_settings) {
			rdev->mult_req = 0;
			rdev->unmask = 0;
		}
		if (rdev->mult_req != rdev->mult_count)
			rdev->special.b.set_multmode = 1;
	}

#if OK_TO_RESET_CONTROLLER
	cli();
	OUT_BYTE(dev->ctl|6,HD_CMD);	/* set nIEN, set SRST */
	udelay(10);			/* more than enough time */
	OUT_BYTE(dev->ctl|2,HD_CMD);	/* clear SRST */
	udelay(10);			/* more than enough time */
	sti();				/* needed for jiffies */
	for (timer = jiffies + WAIT_WORSTCASE; timer > jiffies;) {
		if ((GET_STAT(DEV_HWIF) & BUSY_STAT) == 0)
			break;
	}
	printk("%s: do_ide_reset: ", ide_name[DEV_HWIF]);
	/* ATAPI devices usually do *not* assert READY after a reset */
	if (!OK_STAT(tmp=GET_STAT(DEV_HWIF), 0, BUSY_STAT)) {
		printk("timed-out, status=0x%02x\n", tmp);
	} else  {
		if ((tmp = GET_ERR(DEV_HWIF)) == 1)
			printk("success\n");
		else {
			printk("%s: ", ide_devname[DEV_HWIF][0]);
			switch (tmp & 0x7f) {
				case 1: printk("passed");
					break;
				case 2: printk("formatter device error");
					break;
				case 3: printk("sector buffer error");
					break;
				case 4: printk("ECC circuitry error");
					break;
				case 5: printk("controlling MPU error");
					break;
				default:printk("error (0x%02x?)", tmp);
			}
			if (tmp & 0x80)
				printk("; %s: error", ide_devname[DEV_HWIF][1]);
			printk("\n");
		}
	}
#endif	/* OK_TO_RESET_CONTROLLER */
	restore_flags(flags);
}

/*
 * Clean up after success/failure of an explicit (ioctl) drive cmd
 */
static void end_drive_cmd (ide_dev_t *dev, byte stat, byte err)
{
	unsigned long flags;
	struct request *rq = ide_cur_rq[DEV_HWIF];
	byte *args = (byte *) rq->buffer;

	rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
	if (args) {
		args[0] = stat;
		args[1] = err;
		args[2] = IN_BYTE(HD_NSECTOR,DEV_HWIF);
	}
	save_flags(flags);
	cli();
	up(rq->sem);
	ide_cur_rq[DEV_HWIF] = NULL;
	restore_flags(flags);
}

/*
 * Error reporting, in human readable form (luxurious, but a memory hog).
 */
static byte dump_status (byte hwif, const char *msg, byte stat)
{
	unsigned long flags;
	byte err = 0;
	ide_dev_t *dev = ide_cur_dev[HWIF];
	const char *name = dev ? dev->name : ide_name[HWIF];

	save_flags (flags);
	sti();
	printk("%s: %s: status=0x%02x", name, msg, stat);
#if FANCY_STATUS_DUMPS
	if (dev && dev->type == disk) {
		printk(" { ");
		if (stat & BUSY_STAT)
			printk("Busy ");
		else {
			if (stat & READY_STAT)	printk("DriveReady ");
			if (stat & WRERR_STAT)	printk("WriteFault ");
			if (stat & SEEK_STAT)	printk("SeekComplete ");
			if (stat & DRQ_STAT)	printk("DataRequest ");
			if (stat & ECC_STAT)	printk("CorrectedError ");
			if (stat & INDEX_STAT)	printk("Index ");
			if (stat & ERR_STAT)	printk("Error ");
		}
		printk("}");
	}
#endif	/* FANCY_STATUS_DUMPS */
	printk("\n");
	if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
		err = GET_ERR(HWIF);
		printk("%s: %s: error=0x%02x", name, msg, err);
#if FANCY_STATUS_DUMPS
		if (dev && dev->type == disk) {
			printk(" { ");
			if (err & BBD_ERR)	printk("BadSector ");
			if (err & ECC_ERR)	printk("UncorrectableError ");
			if (err & ID_ERR)	printk("SectorIdNotFound ");
			if (err & ABRT_ERR)	printk("DriveStatusError ");
			if (err & TRK0_ERR)	printk("TrackZeroNotFound ");
			if (err & MARK_ERR)	printk("AddrMarkNotFound ");
			printk("}");
			if (err & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
				byte cur = IN_BYTE(HD_CURRENT,HWIF);
				if (cur & 0x40) {	/* using LBA? */
					printk(", LBAsect=%ld", (unsigned long)
					 ((cur&0xf)<<24)
					 |(IN_BYTE(HD_HCYL,HWIF)<<16)
					 |(IN_BYTE(HD_LCYL,HWIF)<<8)
					 | IN_BYTE(HD_SECTOR,HWIF));
				} else {
					printk(", CHS=%d/%d/%d",
					 (IN_BYTE(HD_HCYL,HWIF)<<8) +
					  IN_BYTE(HD_LCYL,HWIF),
					  cur & 0xf,
					  IN_BYTE(HD_SECTOR,HWIF));
				}
				if (ide_cur_rq[HWIF])
					printk(", sector=%ld", ide_cur_rq[HWIF]->sector);
			}
		}
#endif	/* FANCY_STATUS_DUMPS */
		printk("\n");
	}
	restore_flags (flags);
	return err;
}

/*
 * ide_error() takes action based on the error returned by the controller.
 */
#define ERROR_MAX	8	/* Max read/write errors per sector */
#define ERROR_RESET	3	/* Reset controller every 4th retry */
#define ERROR_RECAL	1	/* Recalibrate every 2nd retry */
static void ide_error (ide_dev_t *dev, const char *msg, byte stat)
{
	struct request *rq;
	byte err;

	err = dump_status(DEV_HWIF, msg, stat);
	if ((rq = ide_cur_rq[DEV_HWIF]) == NULL || dev == NULL)
		return;
#ifdef IDE_DRIVE_CMD
	if (rq->cmd == IDE_DRIVE_CMD) {	/* never retry an explicit DRIVE_CMD */
		end_drive_cmd(dev, stat, err);
		return;
	}
#endif	/* IDE_DRIVE_CMD */
	if (stat & BUSY_STAT) {		/* other bits are useless when BUSY */
		rq->errors |= ERROR_RESET;
	} else {
		if (dev->type == disk && (stat & ERR_STAT)) {
			/* err has different meaning on cdrom */
			if (err & BBD_ERR)		/* retries won't help this! */
				rq->errors = ERROR_MAX;
			else if (err & TRK0_ERR)	/* help it find track zero */
				rq->errors |= ERROR_RECAL;
		}
		if ((stat & DRQ_STAT) && rq->cmd == READ) {
			int i = dev->mult_count ? dev->mult_count<<8 : 1<<8;
			while (i-- > 0)			/* try to flush data */
				(void) IN_BYTE(HD_DATA, dev->hwif);
		}
	}
	if (GET_STAT(dev->hwif) & (BUSY_STAT|DRQ_STAT))
		rq->errors |= ERROR_RESET;	/* Mmmm.. timing problem */

	if (rq->errors >= ERROR_MAX)
		end_request(0, DEV_HWIF);
	else {
		if ((rq->errors & ERROR_RESET) == ERROR_RESET)
			do_ide_reset(dev);
		else if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
			dev->special.b.recalibrate = 1;
		++rq->errors;
	}
}

static void read_intr (ide_dev_t *dev)
{
	byte stat;
	int i;
	unsigned int msect, nsect;
	struct request *rq;

	if (!OK_STAT(stat=GET_STAT(DEV_HWIF),DATA_READY,BAD_R_STAT)) {
		sti();
		ide_error(dev, "read_intr", stat);
		DO_REQUEST;
		return;
	}
	msect = dev->mult_count;
read_next:
	rq = ide_cur_rq[DEV_HWIF];
	if (msect) {
		if ((nsect = rq->current_nr_sectors) > msect)
			nsect = msect;
		msect -= nsect;
	} else
		nsect = 1;
	input_ide_data(dev, rq->buffer, nsect * SECTOR_WORDS);
#ifdef DEBUG
	printk("%s:  read: sectors(%ld-%ld), buffer=0x%08lx, remaining=%ld\n",
		dev->name, rq->sector, rq->sector+nsect-1,
		(unsigned long) rq->buffer+(nsect<<9), rq->nr_sectors-nsect);
#endif
	rq->sector += nsect;
	rq->buffer += nsect<<9;
	rq->errors = 0;
	i = (rq->nr_sectors -= nsect);
	if ((rq->current_nr_sectors -= nsect) <= 0)
		end_request(1, DEV_HWIF);
	if (i > 0) {
		if (msect)
			goto read_next;
		ide_handler[DEV_HWIF] = &read_intr;
		return;
	}
	/* (void) GET_STAT(DEV_HWIF); */	/* hd.c did this */
	DO_REQUEST;
}

static void write_intr (ide_dev_t *dev)
{
	byte stat;
	int i;
	struct request *rq = ide_cur_rq[DEV_HWIF];

	if (OK_STAT(stat=GET_STAT(DEV_HWIF),DRIVE_READY,dev->bad_wstat)) {
#ifdef DEBUG
		printk("%s: write: sector %ld, buffer=0x%08lx, remaining=%ld\n",
			dev->name, rq->sector, (unsigned long) rq->buffer,
			rq->nr_sectors-1);
#endif
		if ((rq->nr_sectors == 1) ^ ((stat & DRQ_STAT) != 0)) {
			rq->sector++;
			rq->buffer += 512;
			rq->errors = 0;
			i = --rq->nr_sectors;
			--rq->current_nr_sectors;
			if (rq->current_nr_sectors <= 0)
				end_request(1, DEV_HWIF);
			if (i > 0) {
				ide_handler[DEV_HWIF] = &write_intr;
				output_ide_data(dev, rq->buffer, SECTOR_WORDS);
				return;
			}
			DO_REQUEST;
			return;
		}
	}
	sti();
	ide_error(dev, "write_intr", stat);
	DO_REQUEST;
}

static void multwrite (ide_dev_t *dev)
{
	struct request *rq = &ide_write_rq[DEV_HWIF];
	unsigned int mcount = dev->mult_count;

	do {
		unsigned int nsect = rq->current_nr_sectors;
		if (nsect > mcount)
			nsect = mcount;
		mcount -= nsect;

		output_ide_data(dev, rq->buffer, nsect<<7);
#ifdef DEBUG
		printk("%s: multwrite: sector %ld, buffer=0x%08lx, count=%d, remaining=%ld\n",
			dev->name, rq->sector, (unsigned long) rq->buffer,
			nsect, rq->nr_sectors - nsect);
#endif
		if ((rq->nr_sectors -= nsect) <= 0)
			break;
		if ((rq->current_nr_sectors -= nsect) == 0) {
			if ((rq->bh = rq->bh->b_reqnext) != NULL) {
				rq->current_nr_sectors = rq->bh->b_size>>9;
				rq->buffer             = rq->bh->b_data;
			} else {
				panic("%s: buffer list corrupted\n", dev->name);
				break;
			}
		} else {
			rq->buffer += nsect << 9;
		}
	} while (mcount);
}

static void multwrite_intr (ide_dev_t *dev)
{
	byte stat;
	int i;
	struct request *rq = &ide_write_rq[DEV_HWIF];

	if (OK_STAT(stat=GET_STAT(DEV_HWIF),DRIVE_READY,dev->bad_wstat)) {
		if (stat & DRQ_STAT) {
			if (rq->nr_sectors) {
				if (dev->mult_count)
					multwrite(dev);
				ide_handler[DEV_HWIF] = &multwrite_intr;
				return;
			}
		} else {
			if (!rq->nr_sectors) {	/* all done? */
				rq = ide_cur_rq[DEV_HWIF];
				for (i = rq->nr_sectors; i > 0;){
					i -= rq->current_nr_sectors;
					end_request(1, DEV_HWIF);
				}
				DO_REQUEST;
				return;
			}
		}
	}
	sti();
	ide_error(dev, "multwrite_intr", stat);
	DO_REQUEST;
}

/*
 * Issue a simple drive command
 * The drive must be selected beforehand.
 */
static inline void ide_cmd(ide_dev_t *dev, byte cmd, byte nsect,
				void (*handler)(ide_dev_t *dev))
{
	OUT_BYTE(dev->ctl,HD_CMD);
	OUT_BYTE(nsect,HD_NSECTOR);
	OUT_BYTE(cmd,HD_COMMAND);
	ide_handler[DEV_HWIF] = handler;
}

static void set_multmode_intr (ide_dev_t *dev)
{
	byte stat = GET_STAT(DEV_HWIF);

	sti();
	if (!OK_STAT(stat,READY_STAT,BAD_STAT)) {
		dev->mult_req = dev->mult_count = 0;
		dev->special.b.recalibrate = 1;
		(void) dump_status(DEV_HWIF, "set_multmode", stat);
	} else if (!dev->be_quiet) {
		if ((dev->mult_count = dev->mult_req))
			printk ("  %s: enabled %d-sector multiple mode\n",
				dev->name, dev->mult_count);
		else
			printk ("  %s: multiple mode turned off\n", dev->name);
	}
	dev->be_quiet = 0;
	DO_REQUEST;
}

static void set_geometry_intr (ide_dev_t *dev)
{
	byte stat = GET_STAT(DEV_HWIF);

	sti();
	if (!OK_STAT(stat,READY_STAT,BAD_STAT))
		ide_error(dev, "set_geometry_intr", stat);
	DO_REQUEST;
}

static void recal_intr (ide_dev_t *dev)
{
	byte stat = GET_STAT(DEV_HWIF);

	sti();
	if (!OK_STAT(stat,READY_STAT,BAD_STAT))
		ide_error(dev, "recal_intr", stat);
	DO_REQUEST;
}

static void drive_cmd_intr (ide_dev_t *dev)
{
	byte stat = GET_STAT(DEV_HWIF);

	sti();
	if (!OK_STAT(stat,READY_STAT,BAD_STAT))
		ide_error(dev, "drive_cmd", stat); /* calls end_drive_cmd() */
	else
		end_drive_cmd (dev, stat, GET_ERR(DEV_HWIF));
	DO_REQUEST;
}

static void timer_expiry (byte hwif)
{
	unsigned long flags;

	save_flags(flags);
	cli();

	if (ide_handler[HWIF] == NULL || (timer_active & ide_timerbit[HWIF])) {
		/* The drive must have responded just as the timer expired */
		sti();
		printk("%s: marginal timeout\n", ide_name[HWIF]);
	} else {
		ide_handler[HWIF] = NULL;
		disable_irq(ide_irq[HWIF]);
#if SUPPORT_SERIALIZE
		if (single_threaded && ide_irq[HWIF] != ide_irq[HWIF^1])
			disable_irq(ide_irq[HWIF^1]);
#endif /* SUPPORT_SERIALIZE */
		sti();
		ide_error(ide_cur_dev[HWIF], "timeout", GET_STAT(HWIF));
		do_request(HWIF);
#if SUPPORT_SHARING_IRQ
		if (single_threaded)	/* this line is indeed necessary */
			hwif = current_hwif;
#endif /* SUPPORT_SHARING_IRQ */
		cli();
		start_ide_timer(HWIF);
		enable_irq(ide_irq[HWIF]);
#if SUPPORT_SERIALIZE
		if (single_threaded && ide_irq[HWIF] != ide_irq[HWIF^1])
			enable_irq(ide_irq[HWIF^1]);
#endif /* SUPPORT_SERIALIZE */
	}
	restore_flags(flags);
}

static void ide0_timer_expiry (void)		/* invoked from sched.c */
{
	timer_expiry (0);
}

static void ide1_timer_expiry (void)		/* invoked from sched.c */
{
	timer_expiry (1);
}

static int do_special (ide_dev_t *dev)
{
	special_t *s = &dev->special;
#ifdef DEBUG
	printk("%s: do_special: 0x%02x\n", dev->name, s->all);
#endif
	if (s->b.set_geometry) {
		s->b.set_geometry = 0;
		if (dev->type == disk) {
			OUT_BYTE(dev->sect,HD_SECTOR);
			OUT_BYTE(dev->cyl,HD_LCYL);
			OUT_BYTE(dev->cyl>>8,HD_HCYL);
			OUT_BYTE(((dev->head-1)|dev->select.all)&0xBF,HD_CURRENT);
			ide_cmd(dev, WIN_SPECIFY, dev->sect, &set_geometry_intr);
		}
	} else if (s->b.recalibrate) {
		s->b.recalibrate = 0;
		if (dev->type == disk)
			ide_cmd(dev,WIN_RESTORE,dev->sect,&recal_intr);
	} else if (s->b.set_multmode) {
		if (dev->type == disk) {
			if (dev->id && dev->mult_req > dev->id->max_multsect)
				dev->mult_req = dev->id->max_multsect;
			ide_cmd(dev,WIN_SETMULT,dev->mult_req,&set_multmode_intr);
		} else {
			dev->mult_req = 0;
			printk("%s: multmode not supported by this device\n", dev->name);
		}
		s->b.set_multmode = 0;
	} else {
		if (s->all) {
			printk("%s: bad special flag: 0x%02x\n", dev->name, s->all);
			s->all = 0;
		}
	}
	return (ide_handler[DEV_HWIF] == NULL) ? 1 : 0;
}

#ifdef CONFIG_BLK_DEV_IDECD
static byte wait_stat (ide_dev_t *dev, byte good, byte bad, unsigned long timeout)
{
	unsigned long flags;

	save_flags(flags);
	sti();
	WAIT_STAT(dev, good, bad, timeout, "status", error);
	restore_flags(flags);
	return 0;
error:
	restore_flags(flags);
	return 1;
}

#include "ide-cd.c"
#endif	/* CONFIG_BLK_DEV_IDECD */

static inline int do_rw_disk (ide_dev_t *dev, struct request *rq, unsigned long block)
{
	OUT_BYTE(dev->ctl,HD_CMD);
	OUT_BYTE(rq->nr_sectors,HD_NSECTOR);
	if (dev->select.b.lba) {
#ifdef DEBUG
		printk("%s: %sing: LBAsect=%ld, sectors=%ld, buffer=0x%08lx\n",
			dev->name, (rq->cmd==READ)?"read":"writ", 
			block, rq->nr_sectors, (unsigned long) rq->buffer);
#endif
		OUT_BYTE(block,HD_SECTOR);
		OUT_BYTE(block>>=8,HD_LCYL);
		OUT_BYTE(block>>=8,HD_HCYL);
		OUT_BYTE(((block>>8)&0x0f)|dev->select.all,HD_CURRENT);
	} else {
		unsigned int sect,head,cyl,track;
		track = block / dev->sect;
		sect  = block % dev->sect + 1;
		OUT_BYTE(sect,HD_SECTOR);
		head  = track % dev->head;
		cyl   = track / dev->head;
		OUT_BYTE(cyl,HD_LCYL);
		OUT_BYTE(cyl>>8,HD_HCYL);
		OUT_BYTE(head|dev->select.all,HD_CURRENT);
#ifdef DEBUG
		printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lx\n",
			dev->name, (rq->cmd==READ)?"read":"writ", cyl,
			head, sect, rq->nr_sectors, (unsigned long) rq->buffer);
#endif
	}
	if (rq->cmd == READ) {
		OUT_BYTE(dev->mult_count ? WIN_MULTREAD : WIN_READ, HD_COMMAND);
		ide_handler[DEV_HWIF] = &read_intr;
		return 0;
	}
	if (rq->cmd == WRITE) {
		OUT_BYTE(dev->wpcom,HD_PRECOMP);	/* for ancient drives */
		OUT_BYTE(dev->mult_count ? WIN_MULTWRITE : WIN_WRITE, HD_COMMAND);
		WAIT_STAT(dev,DATA_READY,dev->bad_wstat,WAIT_DRQ,"DRQ",error);
		if (!dev->unmask)
			cli();
		if (dev->mult_count) {
			ide_write_rq[DEV_HWIF] = *rq; /* scratchpad */
			multwrite(dev);
			ide_handler[DEV_HWIF] = &multwrite_intr;
		} else {
			output_ide_data(dev, rq->buffer, SECTOR_WORDS);
			ide_handler[DEV_HWIF] = &write_intr;
		}
		return 0;
	}
#ifdef IDE_DRIVE_CMD
	if (rq->cmd == IDE_DRIVE_CMD) {
		byte *args = rq->buffer;
		if (args) {
			OUT_BYTE(args[2],HD_FEATURE);
			ide_cmd(dev, args[0], args[1], &drive_cmd_intr);
			printk("%s: DRIVE_CMD cmd=0x%02x sc=0x%02x fr=0x%02x\n",
			 dev->name, args[0], args[1], args[2]);
			return 0;
		} else {
#ifdef DEBUG
			printk("%s: DRIVE_CMD (null)\n", dev->name);
#endif
			end_drive_cmd(dev,GET_STAT(DEV_HWIF),GET_ERR(DEV_HWIF));
			return 1;
		}
	}
#endif	/* IDE_DRIVE_CMD */
	printk("%s: bad command: %d\n", dev->name, rq->cmd);
	end_request(0, DEV_HWIF);
error:
	return 1;
}

/*
 * The driver enables interrupts as much as possible.  In order to do this,
 * (a) the device-interrupt is always masked before entry, and
 * (b) the timeout-interrupt is always disabled before entry.
 *
 * Interrupts are still masked (by default) whenever we are exchanging
 * data/cmds with a drive, because some drives seem to have very poor
 * tolerance for latency during I/O.  For devices which don't suffer from
 * this problem (most don't), the ide_dev[][].unmask flag can be set to permit
 * other interrupts during data/cmd transfers by using the "hdparm" utility.
 */
static void do_request (byte hwif)
{
	unsigned int minor, drive;
	unsigned long block, blockend;
	struct request *rq;
	ide_dev_t *dev;
repeat:
	sti();
#if SUPPORT_SHARING_IRQ
	current_hwif = hwif;	/* used *only* when single_threaded==1 */
#endif /* SUPPORT_SHARING_IRQ */
	if ((rq = ide_cur_rq[HWIF]) == NULL) {
		rq = blk_dev[ide_major[HWIF]].current_request;
		if ((rq == NULL) || (rq->dev < 0)) {
#if SUPPORT_SHARING_IRQ
			if (single_threaded) {
				if (sharing_single_irq && (dev = ide_cur_dev[hwif])) /* disable irq */
					OUT_BYTE(dev->ctl|2,HD_CMD);
				rq = blk_dev[ide_major[hwif^=1]].current_request;
				if ((rq != NULL) && (rq->dev >= 0))
					goto repeat;
			}
#endif /* SUPPORT_SHARING_IRQ */
			return;
		}
		blk_dev[ide_major[HWIF]].current_request = rq->next;
		ide_cur_rq[HWIF] = rq;
	}
#ifdef DEBUG
	printk("%s: do_request: current=0x%08lx\n",ide_name[HWIF],(unsigned long)rq);
#endif
	minor = MINOR(rq->dev);
	drive = minor >> PARTN_BITS;
	ide_cur_dev[HWIF] = dev = &ide_dev[HWIF][drive];
	if ((MAJOR(rq->dev) != ide_major[HWIF]) || (drive >= MAX_DRIVES)) {
		printk("%s: bad device number: 0x%04x\n", ide_name[HWIF], rq->dev);
		end_request(0, HWIF);
		goto repeat;
	}
	if (rq->bh && !rq->bh->b_lock) {
		printk("%s: block not locked\n", ide_name[HWIF]);
		end_request(0, HWIF);
		goto repeat;
	}
	block    = rq->sector;
	blockend = block + rq->nr_sectors;
	if ((blockend < block) || (blockend > ide_hd[HWIF][minor].nr_sects)) {
		printk("%s: bad access: block=%ld, count=%ld\n",
			dev->name, block, rq->nr_sectors);
		end_request(0, HWIF);
		goto repeat;
	}
	block += ide_hd[HWIF][minor].start_sect + dev->sect0;
#if (DISK_RECOVERY_TIME > 0)
	while ((read_timer() - ide_lastreq[HWIF]) < DISK_RECOVERY_TIME);
#endif
	OUT_BYTE(dev->select.all,HD_CURRENT);
#ifdef CONFIG_BLK_DEV_IDECD
	WAIT_STAT(dev, (dev->type == cdrom) ? 0 : READY_STAT,
		BUSY_STAT|DRQ_STAT, WAIT_READY, "DRDY", repeat);
#else
	WAIT_STAT(dev, READY_STAT, BUSY_STAT|DRQ_STAT, WAIT_READY, "DRDY", repeat);
#endif	/* CONFIG_BLK_DEV_IDECD */
	if (!dev->special.all) {
#ifdef CONFIG_BLK_DEV_IDECD
		if (dev->type == disk) {
#endif	/* CONFIG_BLK_DEV_IDECD */
			if (do_rw_disk(dev, rq, block))
				goto repeat;
#ifdef CONFIG_BLK_DEV_IDECD
		} else {
			if (do_rw_cdrom(dev, block))
				goto repeat;
		}
#endif	/* CONFIG_BLK_DEV_IDECD */
	} else {
		if (do_special(dev))
			goto repeat;
	}
}

/*
 * This is a macro rather than an inline function to
 * prevent gcc from over-optimizing accesses to current_hwif,
 * which may have a different value on exit from do_request().
 */
#define DO_IDE_REQUEST(hwif)			\
{						\
	if (ide_handler[hwif] == NULL) {	\
		disable_irq(ide_irq[hwif]);	\
		if (single_threaded && ide_irq[hwif] != ide_irq[hwif^1]) \
			disable_irq(ide_irq[hwif^1]); \
		do_request(hwif);		\
		cli();				\
		start_ide_timer(hwif);		\
		enable_irq(ide_irq[hwif]);	\
		if (single_threaded && ide_irq[hwif] != ide_irq[hwif^1]) \
			enable_irq(ide_irq[hwif^1]); \
	}					\
}

#if SUPPORT_TWO_INTERFACES
static void do_ide0_request (void)	/* invoked with cli() */
{
	DO_IDE_REQUEST(0);
}

static void do_ide1_request (void)	/* invoked with cli() */
{
	DO_IDE_REQUEST(1);
}
#else
#define do_ide1_request	do_ide0_request
static void do_ide0_request (void)	/* invoked with cli() */
{
	DO_IDE_REQUEST(HWIF);
}
#endif	/* SUPPORT_TWO_INTERFACES */

#if SUPPORT_SHARING_IRQ
static void do_shared_request (void)	/* invoked with cli() */
{
	DO_IDE_REQUEST(current_hwif);
}
#endif /* SUPPORT_SHARING_IRQ */

/*
 * There's nothing really useful we can do with an unexpected interrupt,
 * other than reading the status register (to clear it), and logging it.
 * There should be no way that an irq can happen before we're ready for it,
 * so we needn't worry much about losing an "important" interrupt here.
 *
 * On laptops (and "green" PCs), an unexpected interrupt occurs whenever the
 * drive enters "idle", "standby", or "sleep" mode, so if the status looks
 * "good", we just ignore the interrupt completely.
 */
static void unexpected_intr (byte hwif)
{
	byte stat;

	if (!OK_STAT(stat=GET_STAT(HWIF), DRIVE_READY, BAD_STAT))
		(void) dump_status(HWIF, "unexpected_intr", stat);
	outb_p(2,IDE_PORT(HD_CMD,hwif));	/* disable device irq */
#if SUPPORT_SHARING_IRQ
	if (single_threaded && ide_irq[hwif] == ide_irq[hwif^1]) {
		if (!OK_STAT(stat=GET_STAT(hwif^1), DRIVE_READY, BAD_STAT))
			(void) dump_status(hwif^1, "unexpected_intr", stat);
		outb_p(2,IDE_PORT(HD_CMD,hwif^1));	/* disable device irq */
	}
#endif /* SUPPORT_SHARING_IRQ */
}

/*
 * This is a macro rather than an inline function to
 * prevent gcc from over-optimizing accesses to current_hwif,
 * which may have a different value on exit from handler().
 */
#define IDE_INTR(hwif)					\
{							\
	ide_dev_t *dev;					\
	void (*handler)(ide_dev_t *);			\
							\
	timer_active &= ~ide_timerbit[hwif];		\
	if ((handler = ide_handler[hwif]) != NULL) {	\
		ide_handler[hwif] = NULL;		\
		dev = ide_cur_dev[hwif];		\
		if (dev->unmask)			\
			sti();				\
		handler(dev);				\
	} else						\
		unexpected_intr(hwif);			\
	cli();						\
}

#if SUPPORT_SERIALIZE
/* entry point for all interrupts when single_threaded==1 */
static void ide_seq_intr (int irq, struct pt_regs *regs)
{
	byte hwif = (irq != ide_irq[0]);
	IDE_INTR(HWIF);
	start_ide_timer(current_hwif);
}
#endif /* SUPPORT_SERIALIZE */

#if OPTIMIZE_IRQS

/* entry point for all interrupts on ide0 when single_threaded==0 */
static void ide0_intr (int irq, struct pt_regs *regs)
{
	IDE_INTR(0);
	start_ide_timer(0);
}

/* entry point for all interrupts on ide1 when single_threaded==0 */
static void ide1_intr (int irq, struct pt_regs *regs)
{
	IDE_INTR(1);
	start_ide_timer(1);
}

#else	/* OPTIMIZE_IRQS */

#define ide0_intr	ide_intr
#define ide1_intr	ide_intr

/* entry point for all interrupts when single_threaded==0 */
static void ide_intr (int irq, struct pt_regs *regs)
{
#if SUPPORT_TWO_INTERFACES
	byte hwif = (irq != ide_irq[0]);
#endif	/* SUPPORT_TWO_INTERFACES */
	IDE_INTR(HWIF);
	start_ide_timer(HWIF);
}

#endif	/* OPTIMIZE_IRQS */

#if SUPPORT_SHARING_IRQ
/* entry point for all interrupts on ide0/ide1 when sharing_single_irq==1 */
static void ide_shared_intr (int irq, struct pt_regs * regs)
{
	IDE_INTR(current_hwif);
	start_ide_timer(current_hwif);
}
#endif /* SUPPORT_SHARING_IRQ */

static ide_dev_t *get_info_ptr (int i_rdev)
{
	unsigned int drive = DEVICE_NR(i_rdev);
	ide_dev_t *dev;

	if (drive < MAX_DRIVES) {
		switch (MAJOR(i_rdev)) {
#ifndef CONFIG_BLK_DEV_HD
			case IDE0_MAJOR:	dev = &ide_dev[0][drive];
						if (dev->present) return dev;
						break;
#endif /* CONFIG_BLK_DEV_HD */
			case IDE1_MAJOR:	dev = &ide_dev[1][drive];
						if (dev->present) return dev;
						break;
		}
	}
	return NULL;
}

static int ide_open(struct inode * inode, struct file * filp)
{
	ide_dev_t *dev;
	unsigned long flags;

	if ((dev = get_info_ptr(inode->i_rdev)) == NULL)
		return -ENODEV;
	save_flags(flags);
	cli();
	while (dev->busy)
		sleep_on(&dev->wqueue);
	dev->usage++;
	restore_flags(flags);
#ifdef CONFIG_BLK_DEV_IDECD
	if (dev->type == cdrom)
		return cdrom_open (inode, filp, dev);
#endif	/* CONFIG_BLK_DEV_IDECD */
	if (dev->removeable)	/* for disks */
		check_disk_change(inode->i_rdev);
	return 0;
}

/*
 * Releasing a block device means we sync() it, so that it can safely
 * be forgotten about...
 */
static void ide_release(struct inode * inode, struct file * file)
{
	ide_dev_t *dev;

	if ((dev = get_info_ptr(inode->i_rdev)) != NULL) {
		sync_dev(inode->i_rdev);
		dev->usage--;
#ifdef CONFIG_BLK_DEV_IDECD
		if (dev->type == cdrom)
			cdrom_release (inode, file, dev);
#endif	/* CONFIG_BLK_DEV_IDECD */
	}
}

/*
 * This routine is called to flush all partitions and partition tables
 * for a changed disk, and then re-read the new partition table.
 * If we are revalidating a disk because of a media change, then we
 * enter with usage == 0.  If we are using an ioctl, we automatically have
 * usage == 1 (we need an open channel to use an ioctl :-), so this
 * is our limit.
 */
static int revalidate_disk(dev_t  i_rdev)
{
	unsigned int i, major, start, drive = DEVICE_NR(i_rdev);
	ide_dev_t *dev;
	struct gendisk *gd;
	long flags;

	if ((dev = get_info_ptr(i_rdev)) == NULL)
		return -ENODEV;

	save_flags(flags);
	cli();
	if (dev->busy || (dev->usage > 1)) {
		restore_flags(flags);
		return -EBUSY;
	};
	dev->busy = 1;
	restore_flags(flags);

	gd    = &ide_gendisk[DEV_HWIF];
	major = ide_major[DEV_HWIF] << 8;
	start = drive << PARTN_BITS;

	for (i = 0; i < (1<<PARTN_BITS); i++) {
		unsigned int minor = start + i;
		sync_dev           (major | minor);
		invalidate_inodes  (major | minor);
		invalidate_buffers (major | minor);
		gd->part[minor].start_sect = 0;
		gd->part[minor].nr_sects   = 0;
	};

	gd->part[start].nr_sects = ide_capacity[DEV_HWIF][drive];
	resetup_one_dev(gd, drive);

	dev->busy = 0;
	wake_up(&dev->wqueue);
	return 0;
}

#ifdef IDE_DRIVE_CMD
/*
 * This function issues a specific IDE drive command onto the
 * tail of the request queue, and waits for it to be completed.
 * If arg is NULL, it goes through all the motions,
 * but without actually sending a command to the drive.
 */
static int do_drive_cmd(int dev, char *args)
{
	unsigned long flags;
	unsigned int major = MAJOR(dev);
	struct request rq, *cur_rq;
	struct blk_dev_struct *bdev;
	struct semaphore sem = MUTEX_LOCKED;

	/* build up a special request, and add it to the queue */
	rq.buffer = args;
	rq.cmd = IDE_DRIVE_CMD;
	rq.errors = 0;
	rq.sector = 0;
	rq.nr_sectors = 0;
	rq.current_nr_sectors = 0;
	rq.sem = &sem;
	rq.bh = NULL;
	rq.bhtail = NULL;
	rq.next = NULL;
	rq.dev = dev;
	bdev = &blk_dev[major];

	save_flags(flags);
	cli();
	cur_rq = bdev->current_request;
	if (cur_rq == NULL) {			/* empty request list? */
		bdev->current_request = &rq;	/* service ours immediately */
		bdev->request_fn();
	} else {
		while (cur_rq->next != NULL)	/* find end of request list */
			cur_rq = cur_rq->next;
		cur_rq->next = &rq;		/* add rq to the end */
	}

	down(&sem);				/* wait for it to be serviced */
	restore_flags(flags);
	return rq.errors ? -EIO : 0;		/* return -EIO if errors */
}
#endif	/* IDE_DRIVE_CMD */

static int write_fs_long (unsigned long useraddr, long value)
{
	int err;

	if (NULL == (long *)useraddr)
		return -EINVAL;
	if ((err = verify_area(VERIFY_WRITE, (long *)useraddr, sizeof(long))))
		return err;
	put_user((unsigned)value, (long *) useraddr);
	return 0;
}

static int ide_ioctl (struct inode *inode, struct file *file,
			unsigned int cmd, unsigned long arg)
{
	struct hd_geometry *loc = (struct hd_geometry *) arg;
	int err;
	ide_dev_t *dev;
	unsigned long flags;

	if (!inode || !inode->i_rdev)
		return -EINVAL;
	if ((dev = get_info_ptr(inode->i_rdev)) == NULL)
		return -ENODEV;
	switch (cmd) {
		case HDIO_GETGEO:
			if (!loc || dev->type != disk) return -EINVAL;
			err = verify_area(VERIFY_WRITE, loc, sizeof(*loc));
			if (err) return err;
			put_user(dev->bios_head,
				(char *) &loc->heads);
			put_user(dev->bios_sect,
				(char *) &loc->sectors);
			put_user(dev->bios_cyl,
				(short *) &loc->cylinders);
			put_user((unsigned)ide_hd[DEV_HWIF][MINOR(inode->i_rdev)].start_sect,
				(long *) &loc->start);
			return 0;

		case BLKFLSBUF:
			if(!suser()) return -EACCES;
			fsync_dev(inode->i_rdev);
			invalidate_buffers(inode->i_rdev);
			return 0;

		case BLKRASET:
			if(!suser()) return -EACCES;
			if(arg > 0xff) return -EINVAL;
			read_ahead[MAJOR(inode->i_rdev)] = arg;
			return 0;

		case BLKRAGET:
			return write_fs_long(arg, read_ahead[MAJOR(inode->i_rdev)]);

         	case BLKGETSIZE:   /* Return device size */
			return write_fs_long(arg, ide_hd[DEV_HWIF][MINOR(inode->i_rdev)].nr_sects);
		case BLKRRPART: /* Re-read partition tables */
			return revalidate_disk(inode->i_rdev);

                case HDIO_GET_KEEPSETTINGS:
			return write_fs_long(arg, dev->keep_settings);

                case HDIO_GET_UNMASKINTR:
			return write_fs_long(arg, dev->unmask);

                case HDIO_GET_CHIPSET:
			return write_fs_long(arg, dev->chipset);

                case HDIO_GET_MULTCOUNT:
			return write_fs_long(arg, dev->mult_count);

		case HDIO_GET_IDENTITY:
			if (!arg || (MINOR(inode->i_rdev) & PARTN_MASK))
				return -EINVAL;
			if (dev->id == NULL)
				return -ENOMSG;
			err = verify_area(VERIFY_WRITE, (char *)arg, sizeof(*dev->id));
			if (err) return err;
			memcpy_tofs((char *)arg, (char *)dev->id, sizeof(*dev->id));
			return 0;

			case HDIO_GET_NOWERR:
			return write_fs_long(arg, dev->bad_wstat == BAD_R_STAT);

		case HDIO_SET_KEEPSETTINGS:
		case HDIO_SET_UNMASKINTR:
		case HDIO_SET_NOWERR:
			if (arg > 1)
				return -EINVAL;
		case HDIO_SET_CHIPSET:
			if (!suser())
				return -EACCES;
			if ((MINOR(inode->i_rdev) & PARTN_MASK))
				return -EINVAL;
			save_flags(flags);
			cli();
			switch (cmd) {
				case HDIO_SET_KEEPSETTINGS:
					dev->keep_settings = arg;
					break;
				case HDIO_SET_UNMASKINTR:
					dev->unmask = arg;
					break;
				case HDIO_SET_NOWERR:
					dev->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
					break;
				case HDIO_SET_CHIPSET:
					dev->chipset   = arg;
					dev->vlb_sync  = (arg & 2) >> 1;
					dev->vlb_32bit = (arg & 1);
					break;
			}
			restore_flags(flags);
			return 0;

		case HDIO_SET_MULTCOUNT:
			if (!suser()) return -EACCES;
			if (MINOR(inode->i_rdev) & PARTN_MASK)
				return -EINVAL;
			if ((dev->id != NULL) && (arg > dev->id->max_multsect))
				return -EINVAL;
			save_flags(flags);
			cli();
			if (dev->special.b.set_multmode) {
				restore_flags(flags);
				return -EBUSY;
			}
			dev->mult_req = arg;
			dev->special.b.set_multmode = 1;
			restore_flags(flags);
#ifndef IDE_DRIVE_CMD
			return 0;
#else
			do_drive_cmd (inode->i_rdev, NULL);
			return (dev->mult_count == arg) ? 0 : -EIO;

		case HDIO_DRIVE_CMD:
		{
			unsigned long args;

			if (NULL == (long *) arg)
				err = do_drive_cmd(inode->i_rdev,NULL);
			else {
				if (!(err = verify_area(VERIFY_READ,(long *)arg,sizeof(long))))
				{
					args = get_user((long *)arg);
					if (!(err = verify_area(VERIFY_WRITE,(long *)arg,sizeof(long)))) {
						err = do_drive_cmd(inode->i_rdev,(char *)&args);
						put_user(args,(long *)arg);
					}
				}
			}
			return err;
		}
#endif /* IDE_DRIVE_CMD */

		RO_IOCTLS(inode->i_rdev, arg);

		default:
#ifdef CONFIG_BLK_DEV_IDECD
			if (dev->type == cdrom)
				return ide_cdrom_ioctl(dev, inode, file, cmd, arg);
#endif /* CONFIG_BLK_DEV_IDECD */
			return -EPERM;
	}
}

static int ide_check_media_change (dev_t full_dev)
{
	ide_dev_t *dev;

	if ((dev = get_info_ptr(full_dev)) == NULL)
		return -ENODEV;
#ifdef CONFIG_BLK_DEV_IDECD
	if (dev->type == cdrom)
		return cdrom_check_media_change (dev);
#endif	/* CONFIG_BLK_DEV_IDECD */
	if (dev->removeable) /* for disks */
		return 1;	/* always assume it was changed */
	return 0;
}


static void fixstring (byte *s, int bytecount, int byteswap)
{
	byte *p, *end = &s[bytecount &= ~1];	/* bytecount must be even */

	if (byteswap) {
		/* convert from big-endian to little-endian */
		for (p = end ; p != s;) {
			unsigned short *pp = (unsigned short *) (p -= 2);
			*pp = (*pp >> 8) | (*pp << 8);
		}
	}
	p = s;

	/* strip leading blanks */
	while (s != end && *s == ' ')
		++s;

	/* compress internal blanks and strip trailing blanks */
	while (s != end && *s) {
		if (*s++ != ' ' || (s != end && *s && *s != ' '))
			*p++ = *(s-1);
	}

	/* wipe out trailing garbage */
	while (p != end)
		*p++ = '\0';
}

static int lba_capacity_is_ok (struct hd_driveid *id)
/*
 * Returns:	1 if lba_capacity looks sensible
 *		0 otherwise
 */
{
	unsigned long lba_sects   = id->lba_capacity;
	unsigned long chs_sects   = id->cyls * id->heads * id->sectors;
	unsigned long _10_percent = chs_sects / 10;

	/* perform a rough sanity check on lba_sects:  within 10% is "okay" */
	if ((lba_sects - chs_sects) < _10_percent)
		return 1;	/* lba_capacity is good */

	/* some drives have the word order reversed */
	lba_sects = (lba_sects << 16) | (lba_sects >> 16);
	if ((lba_sects - chs_sects) < _10_percent) {
		id->lba_capacity = lba_sects;	/* fix it */
		return 1;	/* lba_capacity is (now) good */
	}
	return 0;	/* lba_capacity value is bad */
}

static unsigned long probe_mem_start;	/* used by drive/irq probing routines */

static void do_identify (ide_dev_t *dev, byte cmd)
{
	int bswap;
	struct hd_driveid *id;
	unsigned long capacity, check;

	id = dev->id = (struct hd_driveid *) probe_mem_start; /* kmalloc() */
	probe_mem_start += 512;
	input_ide_data(dev, id, SECTOR_WORDS);	/* read 512 bytes of id info */
	sti();

	/*
	 * EATA SCSI controllers do a hardware ATA emulation:  ignore them
	 */
	if ((id->model[0] == 'P' && id->model[1] == 'M')
	 || (id->model[0] == 'S' && id->model[1] == 'K')) {
		printk("%s: EATA SCSI HBA %.10s\n", dev->name, id->model);
		dev->present = 0;
		return;
	}

	/*
	 *  WIN_IDENTIFY returns little-endian info,
	 *  WIN_PIDENTIFY *usually* returns little-endian info.
	 */
	bswap = 1;
	if (cmd == WIN_PIDENTIFY) {
		if ((id->model[0] == 'N' && id->model[1] == 'E')
		 || (id->model[0] == 'F' && id->model[1] == 'X')
		 || (id->model[0] == 'P' && id->model[1] == 'i'))
			bswap = 0;	/* NEC, Pioneer and *some* Mitsumi units */
	}				/* Vertos drives may still be weird */
	fixstring (id->model,     sizeof(id->model),     bswap);
	fixstring (id->fw_rev,    sizeof(id->fw_rev),    bswap);
	fixstring (id->serial_no, sizeof(id->serial_no), bswap);

	/*
	 * Check for an ATAPI device
	 */
	if (cmd == WIN_PIDENTIFY) {
#ifdef CONFIG_BLK_DEV_IDECD
		byte type = (id->config >> 8) & 0x0f;
#endif	/* CONFIG_BLK_DEV_IDECD */
		printk("%s: %s, ATAPI,", dev->name, id->model);
#ifdef CONFIG_BLK_DEV_IDECD
		if (type == 0 || type == 5)
			printk(" CDROM drive\n");
		else
			printk(" UNKNOWN device\n");
		dev->type = cdrom;	/* until we do it "correctly" above */
		dev->present = 1;
		dev->removeable = 1;
#else
		printk(unsupported);
#endif	/* CONFIG_BLK_DEV_IDECD */
		return;
	}

	/* check for removeable disks (eg. SYQUEST), ignore 'WD' drives */
	if (id->config & (1<<7)) {	/* removeable disk ? */
		if (id->model[0] != 'W' || id->model[1] != 'D')
			dev->removeable = 1;
	}

	dev->type = disk;
	/* Extract geometry if we did not already have one for the drive */
	if (!dev->present) {
		dev->present = 1;
		dev->cyl     = dev->bios_cyl  = id->cyls;
		dev->head    = dev->bios_head = id->heads;
		dev->sect    = dev->bios_sect = id->sectors; 
	}
	/* Handle logical geometry translation by the drive */
	if ((id->field_valid & 1) && id->cur_cyls && id->cur_heads
	 && (id->cur_heads <= 16) && id->cur_sectors)
	{
		/*
		 * Extract the physical drive geometry for our use.
		 * Note that we purposely do *not* update the bios info.
		 * This way, programs that use it (like fdisk) will 
		 * still have the same logical view as the BIOS does,
		 * which keeps the partition table from being screwed.
		 *
		 * An exception to this is the cylinder count,
		 * which we reexamine later on to correct for 1024 limitations.
		 */
		dev->cyl  = id->cur_cyls;
		dev->head = id->cur_heads;
		dev->sect = id->cur_sectors;
		capacity  = dev->cyl * dev->head * dev->sect;

		/* check for word-swapped "capacity" field in id information */
		check = (id->cur_capacity0 << 16) | id->cur_capacity1;
		if (check == capacity) {	/* was it swapped? */
			/* yes, bring it into little-endian order: */
			id->cur_capacity0 = (capacity >>  0) & 0xffff;
			id->cur_capacity1 = (capacity >> 16) & 0xffff;
		}
	}
	/* Use physical geometry if what we have still makes no sense */
	if ((!dev->head || dev->head > 16) && id->heads && id->heads <= 16) {
		dev->cyl  = id->cyls;
		dev->head = id->heads;
		dev->sect = id->sectors; 
	}
	/* Correct the number of cyls if the bios value is too small */
	if (dev->sect == dev->bios_sect && dev->head == dev->bios_head) {
		if (dev->cyl > dev->bios_cyl)
			dev->bios_cyl = dev->cyl;
	}
	/* Determine capacity, and use LBA if the drive properly supports it */
	if ((id->capability & 2) && lba_capacity_is_ok(id)) {
		dev->select.b.lba = 1;
		capacity = id->lba_capacity;
	} else {
		capacity = dev->cyl * dev->head * dev->sect;
	}

	ide_capacity[DEV_HWIF][dev->select.b.drive] = capacity;
	printk ("%s: %.40s, %ldMB w/%dKB Cache, %sCHS=%d/%d/%d",
	 dev->name, id->model, capacity/2048L, id->buf_size/2,
	 dev->select.b.lba ? "LBA, " : "",
	 dev->bios_cyl, dev->bios_head, dev->bios_sect);

	dev->mult_count = 0;
	if (id->max_multsect) {
		dev->mult_req = INITIAL_MULT_COUNT;
		if (dev->mult_req > id->max_multsect)
			dev->mult_req = id->max_multsect;
		if (dev->mult_req || ((id->multsect_valid & 1) && id->multsect)) {
			dev->special.b.set_multmode = 1;
			dev->be_quiet = 1;
		}
		printk(", MaxMult=%d", id->max_multsect);
	}
	printk("\n");
}

/*
 * Delay for *at least* 10ms.  As we don't know how much time is left
 * until the next tick occurs, we wait an extra tick to be safe.
 */
static void delay_10ms (void)
{
	unsigned long timer = jiffies + (HZ + 99)/100 + 1;
	while (timer > jiffies);
}


static int try_to_identify (ide_dev_t *dev, byte cmd)
/*
 * Returns:	0  device was identified
 *		1  device timed-out (no response to identify request)
 *		2  device aborted the command (refused to identify itself)
 */
{
	int hd_status, rc;
	unsigned long timeout;
#if PROBE_FOR_IRQS
	int irqs = 0;
	static byte irq_probed[2] = {0,0};
#endif	/* PROBE_FOR_IRQS */

	OUT_BYTE(dev->ctl|2,HD_CMD);		/* disable device irq */
#if PROBE_FOR_IRQS
	if (!irq_probed[DEV_HWIF]) {		/* already probed for IRQ? */
		probe_irq_off(probe_irq_on());	/* clear dangling irqs */
		irqs = probe_irq_on();		/* start monitoring irqs */
		OUT_BYTE(dev->ctl,HD_CMD);	/* enable device irq */
	}
#endif	/* PROBE_FOR_IRQS */
	delay_10ms();				/* take a deep breath */
	if ((IN_BYTE(HD_ALTSTATUS,DEV_HWIF) ^ IN_BYTE(HD_STATUS,DEV_HWIF)) & ~INDEX_STAT) {
		hd_status = HD_STATUS;		/* an ancient Seagate drive */
		printk("%s: probing with STATUS instead of ALTSTATUS\n", dev->name);
	} else
		hd_status = HD_ALTSTATUS;	/* use non-intrusive polling */
	OUT_BYTE(cmd,HD_COMMAND);		/* ask drive for ID */
	timeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
	timeout += jiffies;
	do {
		if (jiffies > timeout) {
#if PROBE_FOR_IRQS
			if (!irq_probed[DEV_HWIF])
				(void) probe_irq_off(irqs);
#endif	/* PROBE_FOR_IRQS */
			return 1;	/* drive timed-out */
		}
		delay_10ms();		/* give drive a breather */
	} while (IN_BYTE(hd_status,DEV_HWIF) & BUSY_STAT);
	delay_10ms();		/* wait for IRQ and DRQ_STAT */
	if (OK_STAT(GET_STAT(DEV_HWIF),DRQ_STAT,BAD_R_STAT)) {
		cli();			/* some systems need this */
		do_identify(dev, cmd);	/* drive returned ID */
		rc = 0;			/* success */
	} else
		rc = 2;			/* drive refused ID */
#if PROBE_FOR_IRQS
	if (!irq_probed[DEV_HWIF]) {
		irqs = probe_irq_off(irqs);	/* get irq number */
		if (irqs > 0) {
			irq_probed[DEV_HWIF] = 1;
			ide_irq[DEV_HWIF] = irqs;
		} else				/* Mmmm.. multiple IRQs */
			printk("%s: IRQ probe failed (%d)\n", dev->name, irqs);
	}
#endif	/* PROBE_FOR_IRQS */
	return rc;
}

/*
 * This routine has the difficult job of finding a drive if it exists,
 * without getting hung up if it doesn't exist, without trampling on
 * ethernet cards, and without leaving any IRQs dangling to haunt us later.
 *
 * If a drive is "known" to exist (from CMOS or kernel parameters),
 * but does not respond right away, the probe will "hang in there"
 * for the maximum wait time (about 30 seconds), otherwise it will
 * exit much more quickly.
 */
static int do_probe (ide_dev_t *dev, byte cmd)
/*
 * Returns:	0  device was identified
 *		1  device timed-out (no response to identify request)
 *		2  device aborted the command (refused to identify itself)
 *		3  bad status from device (possible for ATAPI drives)
 *		4  probe was not attempted
 */
{
	int rc;

#ifdef CONFIG_BLK_DEV_IDECD
	if (dev->present) {	/* avoid waiting for inappropriate probes */
		if ((dev->type == disk) ^ (cmd == WIN_IDENTIFY))
			return 4;
	}
#endif	/* CONFIG_BLK_DEV_IDECD */
#if DEBUG
	printk("probing for %s: present=%d, type=%s, probetype=%s\n",
		dev->name, dev->present, dev->type ? "cdrom":"disk",
		(cmd == WIN_IDENTIFY) ? "ATA" : "ATAPI");
#endif
	OUT_BYTE(dev->select.all,HD_CURRENT);	/* select target drive */
	delay_10ms();				/* wait for BUSY_STAT */
	if (IN_BYTE(HD_CURRENT,DEV_HWIF) != dev->select.all && !dev->present) {
		OUT_BYTE(0xa0,HD_CURRENT);	/* exit with drive0 selected */
		return 3;    /* no i/f present: avoid killing ethernet cards */
	}

	if (OK_STAT(GET_STAT(DEV_HWIF),READY_STAT,BUSY_STAT)
	 || dev->present || cmd == WIN_PIDENTIFY)
	{
		if ((rc = try_to_identify(dev, cmd)))  /* send cmd and wait */
			rc = try_to_identify(dev, cmd);	/* failed: try again */
		if (rc == 1)
			printk("%s: no response (status = 0x%02x)\n",
			 dev->name, GET_STAT(DEV_HWIF));
		OUT_BYTE(dev->ctl|2,HD_CMD);	/* disable device irq */
		delay_10ms();
		(void) GET_STAT(DEV_HWIF);	/* ensure drive irq is clear */
	} else {
		rc = 3;				/* not present or maybe ATAPI */
	}
	if (dev->select.b.drive == 1) {
		OUT_BYTE(0xa0,HD_CURRENT);	/* exit with drive0 selected */
		delay_10ms();
		OUT_BYTE(dev->ctl|2,HD_CMD);	/* disable device irq */
		delay_10ms();
		(void) GET_STAT(DEV_HWIF);	/* ensure drive irq is clear */
	}
	return rc;
}

static byte probe_for_drive (ide_dev_t *dev)
/*
 * Returns:	0  no device was found
 *		1  device was found (note: dev->present might still be 0)
 */
{
	if (dev->noprobe)			/* skip probing? */
		return dev->present;
	if (do_probe(dev, WIN_IDENTIFY) >= 2) {	/* if !(success || timed-out) */
#ifdef CONFIG_BLK_DEV_IDECD
		(void) do_probe(dev, WIN_PIDENTIFY); /* look for ATAPI device */
#endif	/* CONFIG_BLK_DEV_IDECD */
	}
	if (!dev->present)
		return 0;			/* drive not found */
	if (dev->id == NULL) {			/* identification failed? */
		if (dev->type == disk) {
			printk ("%s: non-IDE device, CHS=%d/%d/%d\n",
			 dev->name, dev->cyl, dev->head, dev->sect);
		}
#ifdef CONFIG_BLK_DEV_IDECD
		else if (dev->type == cdrom) {
			printk("%s: ATAPI cdrom (?)\n", dev->name);
		}
#endif	/* CONFIG_BLK_DEV_IDECD */
		else {
			dev->present = 0;	/* nuke it */
			return 1;		/* drive was found */
		}
	}
#ifdef CONFIG_BLK_DEV_IDECD
	if (dev->type == cdrom)
		cdrom_setup(dev);
#endif	/* CONFIG_BLK_DEV_IDECD */
	if (dev->type == disk && !dev->select.b.lba) {
		if (!dev->head || dev->head > 16) {
			printk("%s: cannot handle disk with %d physical heads\n",
			 dev->name, dev->head);
			dev->present = 0;
		}
	}
	return 1;	/* drive was found */
}

static void probe_for_drives (byte hwif)
{
	ide_dev_t *devs = &ide_dev[HWIF][0];	/* for convenience */

	if (check_region(IDE_PORT(HD_DATA,HWIF),8)
	 || check_region(IDE_PORT(HD_CMD,HWIF),1))
	{
		if (devs[0].present || devs[1].present)
			printk("ERROR: ");
		printk("%s: port(s) already in use\n", ide_name[HWIF]);
		devs[0].present = 0;
		devs[1].present = 0;
	} else {
		unsigned long flags;
		save_flags(flags);
		sti();	/* needed for jiffies and irq probing */

		/* second drive should only exist if first drive was found */
		if (probe_for_drive(&devs[0]) || devs[1].present)
			(void) probe_for_drive(&devs[1]);
#if PROBE_FOR_IRQS
		(void) probe_irq_off(probe_irq_on()); /* clear dangling irqs */
#endif	/* PROBE_FOR_IRQS */
		if (devs[0].present || devs[1].present) {
			request_region(IDE_PORT(HD_DATA,HWIF),8,ide_name[HWIF]);
			request_region(IDE_PORT(HD_CMD,HWIF),1,ide_name[HWIF]);
		}
		restore_flags(flags);
	}
}

static int next_drive = 0;	/* used by the ide_setup() routines below */

void ide_setup(char *str, int *ints)
{
	ide_dev_t *dev;
	const char *p[] = {"cyls","heads","sects","wpcom","irq"};
	int i, hwif, drive = next_drive++;
#ifdef CONFIG_BLK_DEV_HD
	extern void hd_setup(char *, int *);

	if (drive < 2) {
		hd_setup (str, ints);
		return;
	}
#endif /* CONFIG_BLK_DEV_HD */
	hwif = (drive > 1);
	printk("%s: ", ide_name[hwif]);
	if (drive > 3) {
		printk("too many drives defined\n");
		return;
	}
	drive = drive & 1;
	printk("%s: ", ide_devname[hwif][drive]);
	if (!SUPPORT_TWO_INTERFACES && hwif != HWIF) {
		printk(unsupported);
		return;
	}
	dev = &ide_dev[hwif][drive];
	if (dev->present)
		printk("(redefined) ");
	if (ints[0] == 0) {
#if SUPPORT_DTC2278
		if (!strcmp(str,"dtc2278")) {
			printk("%s\n",str);
			probe_dtc2278 = 1;	/* try to init DTC-2278 at boot */
			return;
		}
#endif /* SUPPORT_DTC2278 */
#if SUPPORT_SERIALIZE
		if (!strcmp(str,"serialize")) {
			printk("%s\n",str);
			single_threaded = 1;	/* serialize all drive access */
			return;
		}
#endif /* SUPPORT_SERIALIZE */
		if (!strcmp(str,"noprobe")) {
			printk("%s\n",str);
			dev->noprobe = 1;	/* don't probe for this drive */
			return;
		}
		if (!strcmp(str,"nowerr")) {
			printk("%s\n",str);
			dev->bad_wstat = BAD_R_STAT; /* ignore WRERR_STAT */
			return;
		}
#ifdef CONFIG_BLK_DEV_IDECD
		if (!strcmp(str,"cdrom")) {
			printk("cdrom\n");
			dev->present = 1;	/* force autoprobe to find it */
			dev->type = cdrom;
			return;
		}
#endif	/* CONFIG_BLK_DEV_IDECD */
	}
	if (ints[0] < 3 || ints[0] > 5) {
		printk("bad parms, expected: cyls,heads,sects[,wpcom[,irq]]\n");
	} else {
		for (i=0; i++ < ints[0];)
			printk("%s=%d%c",p[i-1],ints[i],i<ints[0]?',':'\n');
		dev->type    = disk;
		dev->cyl     = dev->bios_cyl  = ints[1];
		dev->head    = dev->bios_head = ints[2];
		dev->ctl     = (ints[2] > 8 ? 8 : 0);
		dev->sect    = dev->bios_sect = ints[3];
		dev->wpcom   = (ints[0] >= 4) ? ints[4] : 0;
		if (ints[0] >= 5)
			ide_irq[HWIF] = ints[5];
		ide_capacity[HWIF][drive] = BIOS_SECTORS(dev);
		dev->present = 1;
	}
}

void hda_setup(char *str, int *ints)
{
	next_drive = 0;
	ide_setup (str, ints);
}

void hdb_setup(char *str, int *ints)
{
	next_drive = 1;
	ide_setup (str, ints);
}

void hdc_setup(char *str, int *ints)
{
	next_drive = 2;
	ide_setup (str, ints);
}

void hdd_setup(char *str, int *ints)
{
	next_drive = 3;
	ide_setup (str, ints);
}

int ide_xlate_1024 (dev_t full_dev, int need_offset, const char *msg)
{
	ide_dev_t *dev;
	byte head_vals[] = {4, 8, 16, 32, 64, 128, 255, 0}, *heads = head_vals;
	unsigned long capacity;

	if ((dev = get_info_ptr(full_dev)) == NULL && dev->id == NULL)
		return 0;

	dev->cyl  = dev->bios_cyl   = dev->id->cyls;
	dev->head = dev->bios_head  = dev->id->heads;
	dev->sect = dev->bios_sect  = dev->id->sectors; 
	dev->special.b.set_geometry = 1;

	capacity = dev->bios_cyl * dev->bios_head * dev->bios_sect / 63;
	dev->bios_sect = 63;
	do {
		dev->bios_head = *heads;
		dev->bios_cyl = capacity / dev->bios_head;
	} while (dev->bios_cyl >= 1024 && *++heads);
	if (need_offset) {
		dev->sect0 = 63;
		capacity -= 1;
		dev->bios_cyl = capacity / dev->bios_head;
	}
	capacity = dev->bios_cyl * dev->bios_head * dev->bios_sect;
	ide_capacity[DEV_HWIF][dev->select.b.drive] = capacity;
	ide_hd[DEV_HWIF][MINOR(full_dev)].nr_sects  = capacity;
	printk("%s [+%d,%d/%d/%d]", msg, dev->sect0, dev->bios_cyl, dev->bios_head, dev->bios_sect);
	return 1;
}

#ifndef CONFIG_BLK_DEV_HD
/*
 * We query CMOS about hard disks : it could be that we have a SCSI/ESDI/etc
 * controller that is BIOS compatible with ST-506, and thus showing up in our
 * BIOS table, but not register compatible, and therefore not present in CMOS.
 *
 * Furthermore, we will assume that our ST-506 drives <if any> are the primary
 * drives in the system -- the ones reflected as drive 1 or 2.  The first
 * drive is stored in the high nibble of CMOS byte 0x12, the second in the low
 * nibble.  This will be either a 4 bit drive type or 0xf indicating use byte
 * 0x19 for an 8 bit type, drive 1, 0x1a for drive 2 in CMOS.  A non-zero value 
 * means we have an AT controller hard disk for that drive.
 */
static void probe_cmos_for_drives (void)
{
#ifdef __i386__
	extern struct drive_info_struct drive_info;
	byte drive, cmos_disks, *BIOS = (byte *) &drive_info;

	outb_p(0x12,0x70);		/* specify CMOS address 0x12 */
	cmos_disks = inb_p(0x71);	/* read the data from 0x12 */
	/* Extract drive geometry from CMOS+BIOS if not already setup */
	for (drive = 0; drive < MAX_DRIVES; drive++) {
		ide_dev_t *dev = &ide_dev[0][drive];
		if ((cmos_disks & (0xf0 >> (drive*4))) && !dev->present) {
			dev->cyl     = dev->bios_cyl  = *(unsigned short *)BIOS;
			dev->head    = dev->bios_head = * (BIOS+2);
			dev->sect    = dev->bios_sect = * (BIOS+14);
			dev->wpcom   = (*(unsigned short *)(BIOS+5))>>2;
			dev->ctl     = *(BIOS+8);
			dev->wpcom   = 0;
			dev->type    = disk;
			dev->present = 1;
			ide_capacity[0][drive] = BIOS_SECTORS(dev);
		}
		BIOS += 16;
	}
#endif
}
#endif	/* CONFIG_BLK_DEV_HD */

static void init_ide_data (byte hwif)
{
	int drive;

	for (drive = 0; drive < (MAX_DRIVES<<PARTN_BITS); drive++)
		ide_blksizes[hwif][drive] = 1024;
	blksize_size[ide_major[hwif]] = ide_blksizes[hwif];

	/* Initialize non-geometry fields -- ide_setup() runs before we do */
	for (drive = 0; drive < MAX_DRIVES; drive++) {
		ide_dev_t *dev = &ide_dev[hwif][drive];
		dev->select.all			= (drive<<4)|0xa0;
		dev->hwif			= hwif;
		dev->unmask			= 0;
		dev->busy			= 0;
		dev->mult_count			= 0; /* set by do_identify() */
		dev->mult_req			= 0; /* set by do_identify() */
		dev->usage			= 0;
		dev->vlb_32bit			= 0;
		dev->vlb_sync			= 0;
		dev->id				= NULL;
		dev->ctl			= 0x08;
		dev->wqueue			= NULL;
		dev->special.all		= 0;
		dev->special.b.recalibrate	= 1;
		dev->special.b.set_geometry	= 1;
		dev->keep_settings		= 0;
		dev->sect0			= 0;
		dev->removeable			= 0;
		ide_hd[hwif][drive<<PARTN_BITS].start_sect = 0;
		dev->name = ide_devname[hwif][drive];
		if (!dev->bad_wstat)
			dev->bad_wstat = BAD_W_STAT;
	}
}

/*
 * This is the harddisk IRQ description. The SA_INTERRUPT in sa_flags
 * means we enter the IRQ-handler with interrupts disabled: this is bad for
 * interrupt latency, but anything else has led to problems on some
 * machines.  We enable interrupts as much as we can safely do in most places.
 */
static byte setup_irq (byte hwif)
{
	static byte rc = 0;
	unsigned long flags;
	const char *msg = "", *primary_secondary[] = {"primary", "secondary"};
	void (*handler)(int, struct pt_regs *) = HWIF ? &ide1_intr : &ide0_intr;

#if SUPPORT_SHARING_IRQ
	if (sharing_single_irq) {
		if (HWIF != 0 && !rc) {	/* IRQ already allocated? */
			msg = " (shared with ide0)";
			goto done;
		}
		handler = &ide_shared_intr;
	}
#if SUPPORT_SERIALIZE
	else if (single_threaded) {
		handler = &ide_seq_intr;
		if (HWIF != 0)
			msg = " (single-threaded with ide0)";
	}
#endif /* SUPPORT_SERIALIZE */
#endif /* SUPPORT_SHARING_IRQ */
	save_flags(flags);
	cli();
	if ((rc = request_irq(ide_irq[HWIF],handler,SA_INTERRUPT,ide_name[HWIF])))
		msg = ":  FAILED! unable to allocate IRQ";
	restore_flags(flags);
#if SUPPORT_SHARING_IRQ
done:
#endif /* SUPPORT_SHARING_IRQ */
	printk("%s: %s interface on irq %d%s\n",
	 ide_name[HWIF], primary_secondary[HWIF], ide_irq[HWIF], msg);
	return rc;
}

static void ide_geninit(byte hwif)
{
	static int drive;
	
	for (drive = 0; drive < MAX_DRIVES; drive++) {
		ide_dev_t *dev = &ide_dev[HWIF][drive];
		if (dev->present) {
			ide_hd[HWIF][drive<<PARTN_BITS].nr_sects = ide_capacity[HWIF][drive];
			/* Skip partition check for cdroms. */
			if (dev->type == cdrom)
				ide_hd[HWIF][drive<<PARTN_BITS].start_sect = -1;
		}
	}
}

static void ide0_geninit(void)
{
	ide_geninit(0);
}

static void ide1_geninit(void)
{
	ide_geninit(1);
}

static struct file_operations ide_fops = {
	NULL,			/* lseek - default */
	block_read,		/* read - general block-dev read */
	block_write,		/* write - general block-dev write */
	NULL,			/* readdir - bad */
	NULL,			/* select */
	ide_ioctl,		/* ioctl */
	NULL,			/* mmap */
	ide_open,		/* open */
	ide_release,		/* release */
	block_fsync		/* fsync */
	,NULL,			/* fasync */
	ide_check_media_change,	/* check_media_change */
	revalidate_disk		/* revalidate */
};


#if SUPPORT_DTC2278
/*
 * From: andy@cercle.cts.com (Dyan Wile)
 *
 * Below is a patch for DTC-2278 - alike software-programmable controllers
 * The code enables the secondary IDE controller and the PIO4 (3?) timings on
 * the primary (EIDE). You may probably have to enable the 32-bit support to
 * get the full speed. You better get the disk interrupts disabled ( hdparm -u0 
 * /dev/hd.. ) for the drives connected to the EIDE interface. (I get my 
 * filesystem  corrupted with -u 1, but under heavy disk load only :-)  
 */

static void sub22 (char b, char c)
{
	int i;

	for(i = 0; i < 3; i++) {
		__inb(0x3f6);
		outb_p(b,0xb0);
		__inb(0x3f6);
		outb_p(c,0xb4);
		__inb(0x3f6);
		if(__inb(0xb4) == c) {
			outb_p(7,0xb0);
			__inb(0x3f6);
			return;	/* success */
		}
	}
}

static void try_to_init_dtc2278 (void)
{
/* This (presumably) enables PIO mode4 (3?) on the first interface */
	cli();
	sub22(1,0xc3);
	sub22(0,0xa0);
	sti();

/* This enables the second interface */

	outb_p(4,0xb0);
	__inb(0x3f6);
	outb_p(0x20,0xb4);
	__inb(0x3f6);
}
#endif /* SUPPORT_DTC2278 */

/*
 * This is gets invoked once during initialization, to set *everything* up
 */
unsigned long ide_init (unsigned long mem_start, unsigned long mem_end)
{
	byte hwif;

#if SUPPORT_DTC2278
	if (probe_dtc2278)
		try_to_init_dtc2278();
#endif /* SUPPORT_DTC2278 */
	/* single_threaded = 0; */	/* zero by default, override at boot */
	for (hwif = 0; hwif < 2; hwif++) {
		init_ide_data (hwif);
		if (SUPPORT_TWO_INTERFACES || hwif == HWIF) {
			if (hwif == 0)
#ifdef CONFIG_BLK_DEV_HD
				continue;
#else
				probe_cmos_for_drives ();
#endif /* CONFIG_BLK_DEV_HD */
			probe_mem_start = (mem_start + 3uL) & ~3uL;
			probe_for_drives (hwif);
			mem_start = probe_mem_start;
		}
	}

	/* At this point, all methods of drive detection have completed */
	ide_gendisk[0].nr_real = ide_dev[0][0].present + ide_dev[0][1].present;
	ide_gendisk[1].nr_real = ide_dev[1][0].present + ide_dev[1][1].present;
	if (ide_gendisk[1].nr_real && (ide_irq[0] == ide_irq[1])) {
		if (!ide_gendisk[0].nr_real) {
			ide_irq[0] = 0;	/* needed by ide_intr() */
		} else {
#if SUPPORT_SHARING_IRQ
			sharing_single_irq = 1;
			single_threaded = 1;
#else /* SUPPORT_SHARING_IRQ */
			printk("%s: ide irq-sharing%s", ide_name[1], unsupported);
			return mem_start;
#endif /* SUPPORT_SHARING_IRQ */
		}
	}
#ifdef CONFIG_BLK_DEV_HD
#if SUPPORT_SHARING_IRQ
	if (ide_irq[1] == 14 || sharing_single_irq) {
#else
	if (ide_irq[1] == 14) {
#endif /* SUPPORT_SHARING_IRQ */
		printk("%s: irq-sharing not possible with old harddisk driver (hd.c)\n", ide_name[1]);
		return mem_start;
	}
#endif /* CONFIG_BLK_DEV_HD */

	for (hwif = 2; hwif-- > 0;) {
		if (ide_gendisk[hwif].nr_real != 0 && !setup_irq(hwif)) {
			const char *name = ide_name[HWIF];
			unsigned int major = ide_major[HWIF];
			if (register_blkdev(major, name, &ide_fops)) {
				printk("%s: unable to get major number %d\n", name, major);
			} else {
				timer_table[ide_timer[HWIF]].fn
					= HWIF ? ide1_timer_expiry : ide0_timer_expiry;
#if SUPPORT_SHARING_IRQ
				if (single_threaded)
					blk_dev[major].request_fn = &do_shared_request;
				else
#endif /* SUPPORT_SHARING_IRQ */
				blk_dev[major].request_fn =
				 HWIF ? &do_ide1_request : &do_ide0_request;
				read_ahead[major] = 8;	/* (4kB) */
				ide_gendisk[HWIF].next = gendisk_head;
				gendisk_head = &ide_gendisk[HWIF];
			}
		}
	}
	return mem_start;
}
