ide.h 44.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10
#ifndef _IDE_H
#define _IDE_H
/*
 *  linux/include/linux/ide.h
 *
 *  Copyright (C) 1994-2002  Linus Torvalds & authors
 */

#include <linux/init.h>
#include <linux/ioport.h>
11
#include <linux/ata.h>
Linus Torvalds's avatar
Linus Torvalds committed
12 13 14 15 16 17 18
#include <linux/blkdev.h>
#include <linux/proc_fs.h>
#include <linux/interrupt.h>
#include <linux/bitops.h>
#include <linux/bio.h>
#include <linux/device.h>
#include <linux/pci.h>
19
#include <linux/completion.h>
20
#include <linux/pm.h>
21 22 23
#ifdef CONFIG_BLK_DEV_IDEACPI
#include <acpi/acpi.h>
#endif
Linus Torvalds's avatar
Linus Torvalds committed
24 25 26
#include <asm/byteorder.h>
#include <asm/system.h>
#include <asm/io.h>
27
#include <asm/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
28

29
#if defined(CONFIG_CRIS) || defined(CONFIG_FRV)
30 31 32
# define SUPPORT_VLB_SYNC 0
#else
# define SUPPORT_VLB_SYNC 1
Linus Torvalds's avatar
Linus Torvalds committed
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
#endif

/*
 * Used to indicate "no IRQ", should be a value that cannot be an IRQ
 * number.
 */
 
#define IDE_NO_IRQ		(-1)

typedef unsigned char	byte;	/* used everywhere */

/*
 * Probably not wise to fiddle with these
 */
#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 */

/*
 * state flags
 */

#define DMA_PIO_RETRY	1	/* retrying in PIO */

#define HWIF(drive)		((ide_hwif_t *)((drive)->hwif))
#define HWGROUP(drive)		((ide_hwgroup_t *)(HWIF(drive)->hwgroup))

/*
 * Definitions for accessing IDE controller registers
 */
#define IDE_NR_PORTS		(10)

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
struct ide_io_ports {
	unsigned long	data_addr;

	union {
		unsigned long error_addr;	/*   read:  error */
		unsigned long feature_addr;	/*  write: feature */
	};

	unsigned long	nsect_addr;
	unsigned long	lbal_addr;
	unsigned long	lbam_addr;
	unsigned long	lbah_addr;

	unsigned long	device_addr;

	union {
		unsigned long status_addr;	/*  read: status  */
		unsigned long command_addr;	/* write: command */
	};

	unsigned long	ctl_addr;

	unsigned long	irq_addr;
};
Linus Torvalds's avatar
Linus Torvalds committed
89 90 91

#define OK_STAT(stat,good,bad)	(((stat)&((good)|(bad)))==(good))

92 93 94 95 96 97
#define BAD_R_STAT	(ATA_BUSY | ATA_ERR)
#define BAD_W_STAT	(BAD_R_STAT | ATA_DF)
#define BAD_STAT	(BAD_R_STAT | ATA_DRQ)
#define DRIVE_READY	(ATA_DRDY | ATA_DSC)

#define BAD_CRC		(ATA_ABORTED | ATA_ICRC)
Linus Torvalds's avatar
Linus Torvalds committed
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129

#define SATA_NR_PORTS		(3)	/* 16 possible ?? */

#define SATA_STATUS_OFFSET	(0)
#define SATA_ERROR_OFFSET	(1)
#define SATA_CONTROL_OFFSET	(2)

/*
 * Our Physical Region Descriptor (PRD) table should be large enough
 * to handle the biggest I/O request we are likely to see.  Since requests
 * can have no more than 256 sectors, and since the typical blocksize is
 * two or more sectors, we could get by with a limit of 128 entries here for
 * the usual worst case.  Most requests seem to include some contiguous blocks,
 * further reducing the number of table entries required.
 *
 * The driver reverts to PIO mode for individual requests that exceed
 * this limit (possible with 512 byte blocksizes, eg. MSDOS f/s), so handling
 * 100% of all crazy scenarios here is not necessary.
 *
 * As it turns out though, we must allocate a full 4KB page for this,
 * so the two PRD tables (ide0 & ide1) will each get half of that,
 * allowing each to have about 256 entries (8 bytes each) from this.
 */
#define PRD_BYTES       8
#define PRD_ENTRIES	256

/*
 * Some more useful definitions
 */
#define PARTN_BITS	6	/* number of minor dev bits for partitions */
#define MAX_DRIVES	2	/* per interface; 2 assumed by lots of code */
#define SECTOR_SIZE	512
130

Linus Torvalds's avatar
Linus Torvalds committed
131 132 133 134 135 136 137 138 139 140 141 142
#define IDE_LARGE_SEEK(b1,b2,t)	(((b1) > (b2) + (t)) || ((b2) > (b1) + (t)))

/*
 * Timeouts for various operations:
 */
#define WAIT_DRQ	(HZ/10)		/* 100msec - spec allows up to 20ms */
#define WAIT_READY	(5*HZ)		/* 5sec - some laptops are very slow */
#define WAIT_PIDENTIFY	(10*HZ)	/* 10sec  - should be less than 3ms (?), if all ATAPI CD is closed at boot */
#define WAIT_WORSTCASE	(30*HZ)	/* 30sec  - worst case when spinning up */
#define WAIT_CMD	(10*HZ)	/* 10sec  - maximum wait for an IRQ to happen */
#define WAIT_MIN_SLEEP	(2*HZ/100)	/* 20msec - minimum sleep time */

143 144 145 146 147 148
/*
 * Op codes for special requests to be handled by ide_special_rq().
 * Values should be in the range of 0x20 to 0x3f.
 */
#define REQ_DRIVE_RESET		0x20

Linus Torvalds's avatar
Linus Torvalds committed
149 150 151 152 153 154 155 156 157 158
/*
 * Check for an interrupt and acknowledge the interrupt status
 */
struct hwif_s;
typedef int (ide_ack_intr_t)(struct hwif_s *);

/*
 * hwif_chipset_t is used to keep track of the specific hardware
 * chipset used by each IDE interface, if known.
 */
159
enum {		ide_unknown,	ide_generic,	ide_pci,
Linus Torvalds's avatar
Linus Torvalds committed
160 161 162 163
		ide_cmd640,	ide_dtc2278,	ide_ali14xx,
		ide_qd65xx,	ide_umc8672,	ide_ht6560b,
		ide_rz1000,	ide_trm290,
		ide_cmd646,	ide_cy82c693,	ide_4drives,
164
		ide_pmac,	ide_acorn,
165
		ide_au1xxx,	ide_palm3710
166 167 168
};

typedef u8 hwif_chipset_t;
Linus Torvalds's avatar
Linus Torvalds committed
169 170 171 172 173

/*
 * Structure to hold all information about the location of this port
 */
typedef struct hw_regs_s {
174 175 176 177 178
	union {
		struct ide_io_ports	io_ports;
		unsigned long		io_ports_array[IDE_NR_PORTS];
	};

Linus Torvalds's avatar
Linus Torvalds committed
179 180 181
	int		irq;			/* our irq number */
	ide_ack_intr_t	*ack_intr;		/* acknowledge interrupt */
	hwif_chipset_t  chipset;
182
	struct device	*dev, *parent;
183
	unsigned long	config;
Linus Torvalds's avatar
Linus Torvalds committed
184 185
} hw_regs_t;

186
void ide_init_port_data(struct hwif_s *, unsigned int);
187
void ide_init_port_hw(struct hwif_s *, hw_regs_t *);
188

Linus Torvalds's avatar
Linus Torvalds committed
189 190 191 192 193 194
static inline void ide_std_init_ports(hw_regs_t *hw,
				      unsigned long io_addr,
				      unsigned long ctl_addr)
{
	unsigned int i;

195 196
	for (i = 0; i <= 7; i++)
		hw->io_ports_array[i] = io_addr++;
Linus Torvalds's avatar
Linus Torvalds committed
197

198
	hw->io_ports.ctl_addr = ctl_addr;
Linus Torvalds's avatar
Linus Torvalds committed
199 200
}

201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
/* for IDE PCI controllers in legacy mode, temporary */
static inline int __ide_default_irq(unsigned long base)
{
	switch (base) {
#ifdef CONFIG_IA64
	case 0x1f0: return isa_irq_to_vector(14);
	case 0x170: return isa_irq_to_vector(15);
#else
	case 0x1f0: return 14;
	case 0x170: return 15;
#endif
	}
	return 0;
}

216 217 218
#if defined(CONFIG_ARM) || defined(CONFIG_FRV) || defined(CONFIG_M68K) || \
    defined(CONFIG_MIPS) || defined(CONFIG_MN10300) || defined(CONFIG_PARISC) \
    || defined(CONFIG_PPC) || defined(CONFIG_SPARC) || defined(CONFIG_SPARC64)
Linus Torvalds's avatar
Linus Torvalds committed
219
#include <asm/ide.h>
220 221 222
#else
#include <asm-generic/ide_iops.h>
#endif
Linus Torvalds's avatar
Linus Torvalds committed
223

224
#define MAX_HWIFS	10
225

Linus Torvalds's avatar
Linus Torvalds committed
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
/* Currently only m68k, apus and m8xx need it */
#ifndef IDE_ARCH_ACK_INTR
# define ide_ack_intr(hwif) (1)
#endif

/* Currently only Atari needs it */
#ifndef IDE_ARCH_LOCK
# define ide_release_lock()			do {} while (0)
# define ide_get_lock(hdlr, data)		do {} while (0)
#endif /* IDE_ARCH_LOCK */

/*
 * Now for the data we need to maintain per-drive:  ide_drive_t
 */

#define ide_scsi	0x21
#define ide_disk	0x20
#define ide_optical	0x7
#define ide_cdrom	0x5
#define ide_tape	0x1
#define ide_floppy	0x0

/*
 * Special Driver Flags
 *
 * set_geometry	: respecify drive geometry
 * recalibrate	: seek to cyl 0
 * set_multmode	: set multmode count
 * set_tune	: tune interface for drive
 * serviced	: service command
 * reserved	: unused
 */
typedef union {
	unsigned all			: 8;
	struct {
		unsigned set_geometry	: 1;
		unsigned recalibrate	: 1;
		unsigned set_multmode	: 1;
		unsigned set_tune	: 1;
		unsigned serviced	: 1;
		unsigned reserved	: 3;
	} b;
} special_t;

/*
 * ATA-IDE Select Register, aka Device-Head
 *
 * head		: always zeros here
 * unit		: drive select number: 0/1
 * bit5		: always 1
 * lba		: using LBA instead of CHS
 * bit7		: always 1
 */
typedef union {
	unsigned all			: 8;
	struct {
#if defined(__LITTLE_ENDIAN_BITFIELD)
		unsigned head		: 4;
		unsigned unit		: 1;
		unsigned bit5		: 1;
		unsigned lba		: 1;
		unsigned bit7		: 1;
#elif defined(__BIG_ENDIAN_BITFIELD)
		unsigned bit7		: 1;
		unsigned lba		: 1;
		unsigned bit5		: 1;
		unsigned unit		: 1;
		unsigned head		: 4;
#else
#error "Please fix <asm/byteorder.h>"
#endif
	} b;
} select_t, ata_select_t;

/*
 * Status returned from various ide_ functions
 */
typedef enum {
	ide_stopped,	/* no drive operation was started */
	ide_started,	/* a drive operation was started, handler was set */
} ide_startstop_t;

308
struct ide_devset;
Linus Torvalds's avatar
Linus Torvalds committed
309 310
struct ide_driver_s;

311 312 313 314 315
#ifdef CONFIG_BLK_DEV_IDEACPI
struct ide_acpi_drive_link;
struct ide_acpi_hwif_link;
#endif

316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
/* ATAPI device flags */
enum {
	IDE_AFLAG_DRQ_INTERRUPT		= (1 << 0),
	IDE_AFLAG_MEDIA_CHANGED		= (1 << 1),

	/* ide-cd */
	/* Drive cannot lock the door. */
	IDE_AFLAG_NO_DOORLOCK		= (1 << 2),
	/* Drive cannot eject the disc. */
	IDE_AFLAG_NO_EJECT		= (1 << 3),
	/* Drive is a pre ATAPI 1.2 drive. */
	IDE_AFLAG_PRE_ATAPI12		= (1 << 4),
	/* TOC addresses are in BCD. */
	IDE_AFLAG_TOCADDR_AS_BCD	= (1 << 5),
	/* TOC track numbers are in BCD. */
	IDE_AFLAG_TOCTRACKS_AS_BCD	= (1 << 6),
	/*
	 * Drive does not provide data in multiples of SECTOR_SIZE
	 * when more than one interrupt is needed.
	 */
	IDE_AFLAG_LIMIT_NFRAMES		= (1 << 7),
	/* Seeking in progress. */
	IDE_AFLAG_SEEKING		= (1 << 8),
	/* Saved TOC information is current. */
	IDE_AFLAG_TOC_VALID		= (1 << 9),
	/* We think that the drive door is locked. */
	IDE_AFLAG_DOOR_LOCKED		= (1 << 10),
	/* SET_CD_SPEED command is unsupported. */
	IDE_AFLAG_NO_SPEED_SELECT	= (1 << 11),
	IDE_AFLAG_VERTOS_300_SSD	= (1 << 12),
	IDE_AFLAG_VERTOS_600_ESD	= (1 << 13),
	IDE_AFLAG_SANYO_3CD		= (1 << 14),
	IDE_AFLAG_FULL_CAPS_PAGE	= (1 << 15),
	IDE_AFLAG_PLAY_AUDIO_OK		= (1 << 16),
	IDE_AFLAG_LE_SPEED_FIELDS	= (1 << 17),

	/* ide-floppy */
	/* Format in progress */
	IDE_AFLAG_FORMAT_IN_PROGRESS	= (1 << 18),
	/* Avoid commands not supported in Clik drive */
	IDE_AFLAG_CLIK_DRIVE		= (1 << 19),
	/* Requires BH algorithm for packets */
	IDE_AFLAG_ZIP_DRIVE		= (1 << 20),

	/* ide-tape */
	IDE_AFLAG_IGNORE_DSC		= (1 << 21),
	/* 0 When the tape position is unknown */
	IDE_AFLAG_ADDRESS_VALID		= (1 <<	22),
	/* Device already opened */
	IDE_AFLAG_BUSY			= (1 << 23),
	/* Attempt to auto-detect the current user block size */
	IDE_AFLAG_DETECT_BS		= (1 << 24),
	/* Currently on a filemark */
	IDE_AFLAG_FILEMARK		= (1 << 25),
	/* 0 = no tape is loaded, so we don't rewind after ejecting */
371 372 373
	IDE_AFLAG_MEDIUM_PRESENT	= (1 << 26),

	IDE_AFLAG_NO_AUTOCLOSE		= (1 << 27),
374 375
};

376
struct ide_drive_s {
Linus Torvalds's avatar
Linus Torvalds committed
377 378 379
	char		name[4];	/* drive name, such as "hda" */
        char            driver_req[10];	/* requests specific driver */

380
	struct request_queue	*queue;	/* request queue */
Linus Torvalds's avatar
Linus Torvalds committed
381 382 383 384

	struct request		*rq;	/* current request */
	struct ide_drive_s 	*next;	/* circular list of hwgroup drives */
	void		*driver_data;	/* extra driver data */
385
	u16			*id;	/* identification info */
386
#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds's avatar
Linus Torvalds committed
387
	struct proc_dir_entry *proc;	/* /proc/ide/ directory entry */
388
	const struct ide_devset **settings; /* /proc/ide/ drive settings */
389
#endif
Linus Torvalds's avatar
Linus Torvalds committed
390 391 392 393 394 395 396 397 398 399 400 401 402 403
	struct hwif_s		*hwif;	/* actually (ide_hwif_t *) */

	unsigned long sleep;		/* sleep until this time */
	unsigned long service_start;	/* time we started last request */
	unsigned long service_time;	/* service time of last request */
	unsigned long timeout;		/* max time to wait for irq */

	special_t	special;	/* special action flags */
	select_t	select;		/* basic drive/head select reg value */

	u8	retry_pio;		/* retrying dma capable host in pio */
	u8	state;			/* retry state */
	u8	waiting_for_dma;	/* dma currently in progress */

404 405 406 407 408 409
	unsigned keep_settings	: 1;	/* restore settings after drive reset */
	unsigned using_dma	: 1;	/* disk is using dma for read/write */
	unsigned unmask		: 1;	/* okay to unmask other irqs */
	unsigned noflush	: 1;	/* don't attempt flushes */
	unsigned dsc_overlap	: 1;	/* DSC overlap */
	unsigned nice1		: 1;	/* give potential excess bandwidth */
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413 414 415 416 417 418 419
	unsigned present	: 1;	/* drive is physically present */
	unsigned dead		: 1;	/* device ejected hint */
	unsigned id_read	: 1;	/* 1=id read from disk 0 = synthetic */
	unsigned noprobe 	: 1;	/* from:  hdx=noprobe */
	unsigned removable	: 1;	/* 1 if need to do check_media_change */
	unsigned attach		: 1;	/* needed for removable devices */
	unsigned forced_geom	: 1;	/* 1 if hdx=c,h,s was given at boot */
	unsigned no_unmask	: 1;	/* disallow setting unmask bit */
	unsigned no_io_32bit	: 1;	/* disallow enabling 32bit I/O */
	unsigned doorlocking	: 1;	/* for removable only: door lock/unlock works */
420
	unsigned nodma		: 1;	/* disallow DMA */
Linus Torvalds's avatar
Linus Torvalds committed
421 422 423 424
	unsigned blocked        : 1;	/* 1=powermanagment told us not to do anything, so sleep nicely */
	unsigned scsi		: 1;	/* 0=default, 1=ide-scsi emulation */
	unsigned sleeping	: 1;	/* 1=sleeping & sleep field valid */
	unsigned post_reset	: 1;
425
	unsigned udma33_warned	: 1;
426 427 428
	unsigned addressing	: 2;	/* 0=28-bit, 1=48-bit, 2=48-bit doing 28-bit */
	unsigned wcache		: 1;	/* status of write cache */
	unsigned nowerr		: 1;	/* used for ignoring ATA_DF */
Linus Torvalds's avatar
Linus Torvalds committed
429 430 431 432

        u8	quirk_list;	/* considered quirky, set for a specific host */
        u8	init_speed;	/* transfer rate set at boot */
        u8	current_speed;	/* current transfer rate set */
433
	u8	desired_speed;	/* desired transfer rate set */
Linus Torvalds's avatar
Linus Torvalds committed
434 435 436 437 438 439 440 441
        u8	dn;		/* now wide spread use */
	u8	acoustic;	/* acoustic management */
	u8	media;		/* disk, cdrom, tape, floppy, ... */
	u8	ready_stat;	/* min status value for drive ready */
	u8	mult_count;	/* current multiple sector setting */
	u8	mult_req;	/* requested multiple sector setting */
	u8	tune_req;	/* requested drive tuning setting */
	u8	io_32bit;	/* 0=16-bit, 1=32-bit, 2/3=32bit+sync */
442
	u8	bad_wstat;	/* used for ignoring ATA_DF */
Linus Torvalds's avatar
Linus Torvalds committed
443 444 445 446 447 448 449
	u8	head;		/* "real" number of heads */
	u8	sect;		/* "real" sectors per track */
	u8	bios_head;	/* BIOS/fdisk/LILO number of heads */
	u8	bios_sect;	/* BIOS/fdisk/LILO sectors per track */

	unsigned int	bios_cyl;	/* BIOS/fdisk/LILO number of cyls */
	unsigned int	cyl;		/* "real" number of cyls */
450
	unsigned int	drive_data;	/* used by set_pio_mode/selectproc */
Linus Torvalds's avatar
Linus Torvalds committed
451 452
	unsigned int	failures;	/* current failure count */
	unsigned int	max_failures;	/* maximum allowed failure count */
453
	u64		probed_capacity;/* initial reported media capacity (ide-cd only currently) */
Linus Torvalds's avatar
Linus Torvalds committed
454 455 456 457 458

	u64		capacity64;	/* total number of sectors */

	int		lun;		/* logical unit */
	int		crc_count;	/* crc counter to reduce drive speed */
459 460 461
#ifdef CONFIG_BLK_DEV_IDEACPI
	struct ide_acpi_drive_link *acpidata;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
462 463
	struct list_head list;
	struct device	gendev;
464
	struct completion gendev_rel_comp;	/* to deal with device release() */
465 466 467

	/* callback for packet commands */
	void (*pc_callback)(struct ide_drive_s *);
468 469

	unsigned long atapi_flags;
470 471 472
};

typedef struct ide_drive_s ide_drive_t;
Linus Torvalds's avatar
Linus Torvalds committed
473

474 475
#define to_ide_device(dev)container_of(dev, ide_drive_t, gendev)

476
struct ide_task_s;
477
struct ide_port_info;
Linus Torvalds's avatar
Linus Torvalds committed
478

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
struct ide_tp_ops {
	void	(*exec_command)(struct hwif_s *, u8);
	u8	(*read_status)(struct hwif_s *);
	u8	(*read_altstatus)(struct hwif_s *);
	u8	(*read_sff_dma_status)(struct hwif_s *);

	void	(*set_irq)(struct hwif_s *, int);

	void	(*tf_load)(ide_drive_t *, struct ide_task_s *);
	void	(*tf_read)(ide_drive_t *, struct ide_task_s *);

	void	(*input_data)(ide_drive_t *, struct request *, void *,
			      unsigned int);
	void	(*output_data)(ide_drive_t *, struct request *, void *,
			       unsigned int);
};

extern const struct ide_tp_ops default_tp_ops;

498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
/**
 * struct ide_port_ops - IDE port operations
 *
 * @init_dev:		host specific initialization of a device
 * @set_pio_mode:	routine to program host for PIO mode
 * @set_dma_mode:	routine to program host for DMA mode
 * @selectproc:		tweaks hardware to select drive
 * @reset_poll:		chipset polling based on hba specifics
 * @pre_reset:		chipset specific changes to default for device-hba resets
 * @resetproc:		routine to reset controller after a disk reset
 * @maskproc:		special host masking for drive selection
 * @quirkproc:		check host's drive quirk list
 *
 * @mdma_filter:	filter MDMA modes
 * @udma_filter:	filter UDMA modes
 *
 * @cable_detect:	detect cable type
 */
516
struct ide_port_ops {
517
	void	(*init_dev)(ide_drive_t *);
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
	void	(*set_pio_mode)(ide_drive_t *, const u8);
	void	(*set_dma_mode)(ide_drive_t *, const u8);
	void	(*selectproc)(ide_drive_t *);
	int	(*reset_poll)(ide_drive_t *);
	void	(*pre_reset)(ide_drive_t *);
	void	(*resetproc)(ide_drive_t *);
	void	(*maskproc)(ide_drive_t *, int);
	void	(*quirkproc)(ide_drive_t *);

	u8	(*mdma_filter)(ide_drive_t *);
	u8	(*udma_filter)(ide_drive_t *);

	u8	(*cable_detect)(struct hwif_s *);
};

533 534 535 536 537 538 539 540 541 542 543
struct ide_dma_ops {
	void	(*dma_host_set)(struct ide_drive_s *, int);
	int	(*dma_setup)(struct ide_drive_s *);
	void	(*dma_exec_cmd)(struct ide_drive_s *, u8);
	void	(*dma_start)(struct ide_drive_s *);
	int	(*dma_end)(struct ide_drive_s *);
	int	(*dma_test_irq)(struct ide_drive_s *);
	void	(*dma_lost_irq)(struct ide_drive_s *);
	void	(*dma_timeout)(struct ide_drive_s *);
};

544 545
struct ide_host;

Linus Torvalds's avatar
Linus Torvalds committed
546 547 548 549 550 551
typedef struct hwif_s {
	struct hwif_s *next;		/* for linked-list in ide_hwgroup_t */
	struct hwif_s *mate;		/* other hwif from same PCI chip */
	struct hwgroup_s *hwgroup;	/* actually (ide_hwgroup_t *) */
	struct proc_dir_entry *proc;	/* /proc/ide/ directory entry */

552 553
	struct ide_host *host;

Linus Torvalds's avatar
Linus Torvalds committed
554 555
	char name[6];			/* name of interface, eg. "ide0" */

556 557
	struct ide_io_ports	io_ports;

Linus Torvalds's avatar
Linus Torvalds committed
558 559 560 561 562 563 564 565
	unsigned long	sata_scr[SATA_NR_PORTS];

	ide_drive_t	drives[MAX_DRIVES];	/* drive info */

	u8 major;	/* our major number */
	u8 index;	/* 0 for ide0; 1 for ide1; ... */
	u8 channel;	/* for dual-port chips: 0=primary, 1=secondary */

566
	u32 host_flags;
567

568 569
	u8 pio_mask;

Linus Torvalds's avatar
Linus Torvalds committed
570 571 572 573
	u8 ultra_mask;
	u8 mwdma_mask;
	u8 swdma_mask;

574 575
	u8 cbl;		/* cable type */

Linus Torvalds's avatar
Linus Torvalds committed
576 577
	hwif_chipset_t chipset;	/* sub-module for tuning.. */

578 579
	struct device *dev;

580 581
	ide_ack_intr_t *ack_intr;

Linus Torvalds's avatar
Linus Torvalds committed
582 583
	void (*rw_disk)(ide_drive_t *, struct request *);

584
	const struct ide_tp_ops		*tp_ops;
585
	const struct ide_port_ops	*port_ops;
586
	const struct ide_dma_ops	*dma_ops;
587

588
	void (*ide_dma_clear_irq)(ide_drive_t *drive);
Linus Torvalds's avatar
Linus Torvalds committed
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604

	/* dma physical region descriptor table (cpu view) */
	unsigned int	*dmatable_cpu;
	/* dma physical region descriptor table (dma view) */
	dma_addr_t	dmatable_dma;
	/* Scatter-gather list used to build the above */
	struct scatterlist *sg_table;
	int sg_max_nents;		/* Maximum number of entries in it */
	int sg_nents;			/* Current number of entries in it */
	int sg_dma_direction;		/* dma transfer direction */

	/* data phase of the active command (currently only valid for PIO/DMA) */
	int		data_phase;

	unsigned int nsect;
	unsigned int nleft;
Jens Axboe's avatar
Jens Axboe committed
605
	struct scatterlist *cursg;
Linus Torvalds's avatar
Linus Torvalds committed
606 607 608 609 610 611 612 613 614 615
	unsigned int cursg_ofs;

	int		rqsize;		/* max sectors per request */
	int		irq;		/* our irq number */

	unsigned long	dma_base;	/* base addr for dma ports */

	unsigned long	config_data;	/* for use by chipset-specific code */
	unsigned long	select_data;	/* for use by chipset-specific code */

616 617 618
	unsigned long	extra_base;	/* extra addr for dma ports */
	unsigned	extra_ports;	/* number of extra dma ports */

Linus Torvalds's avatar
Linus Torvalds committed
619 620 621 622 623
	unsigned	present    : 1;	/* this interface exists */
	unsigned	serialized : 1;	/* serialized all channel operation */
	unsigned	sharing_irq: 1;	/* 1 = sharing irq with another hwif */
	unsigned	sg_mapped  : 1;	/* sg_table and sg_nents are ready */

624 625 626
	struct device		gendev;
	struct device		*portdev;

627
	struct completion gendev_rel_comp; /* To deal with device release() */
Linus Torvalds's avatar
Linus Torvalds committed
628 629 630 631

	void		*hwif_data;	/* extra hwif data */

	unsigned dma;
632 633 634 635

#ifdef CONFIG_BLK_DEV_IDEACPI
	struct ide_acpi_hwif_link *acpidata;
#endif
636
} ____cacheline_internodealigned_in_smp ide_hwif_t;
Linus Torvalds's avatar
Linus Torvalds committed
637

638 639 640
struct ide_host {
	ide_hwif_t	*ports[MAX_HWIFS];
	unsigned int	n_ports;
641
	struct device	*dev[2];
642
	unsigned int	(*init_chipset)(struct pci_dev *);
643
	unsigned long	host_flags;
644
	void		*host_priv;
645 646
};

Linus Torvalds's avatar
Linus Torvalds committed
647 648 649 650 651 652
/*
 *  internal ide interrupt handler type
 */
typedef ide_startstop_t (ide_handler_t)(ide_drive_t *);
typedef int (ide_expiry_t)(ide_drive_t *);

653
/* used by ide-cd, ide-floppy, etc. */
654
typedef void (xfer_func_t)(ide_drive_t *, struct request *rq, void *, unsigned);
655

Linus Torvalds's avatar
Linus Torvalds committed
656 657 658
typedef struct hwgroup_s {
		/* irq handler, if active */
	ide_startstop_t	(*handler)(ide_drive_t *);
659

Linus Torvalds's avatar
Linus Torvalds committed
660 661 662 663 664 665
		/* BOOL: protects all fields below */
	volatile int busy;
		/* BOOL: wake us up on timer expiry */
	unsigned int sleeping	: 1;
		/* BOOL: polling active & poll_timeout field valid */
	unsigned int polling	: 1;
666

Linus Torvalds's avatar
Linus Torvalds committed
667 668 669 670 671 672 673
		/* current drive */
	ide_drive_t *drive;
		/* ptr to current hwif in linked-list */
	ide_hwif_t *hwif;

		/* current request */
	struct request *rq;
674

Linus Torvalds's avatar
Linus Torvalds committed
675 676 677 678 679 680
		/* failsafe timer */
	struct timer_list timer;
		/* timeout value during long polls */
	unsigned long poll_timeout;
		/* queried upon timeouts */
	int (*expiry)(ide_drive_t *);
681

682 683
	int req_gen;
	int req_gen_timer;
Linus Torvalds's avatar
Linus Torvalds committed
684 685
} ide_hwgroup_t;

686 687
typedef struct ide_driver_s ide_driver_t;

688
extern struct mutex ide_setting_mtx;
Linus Torvalds's avatar
Linus Torvalds committed
689

690
int get_io_32bit(ide_drive_t *);
691
int set_io_32bit(ide_drive_t *, int);
692
int get_ksettings(ide_drive_t *);
693
int set_ksettings(ide_drive_t *, int);
694
int set_pio_mode(ide_drive_t *, int);
695
int get_unmaskirq(ide_drive_t *);
696
int set_unmaskirq(ide_drive_t *, int);
697
int get_using_dma(ide_drive_t *);
698 699
int set_using_dma(ide_drive_t *, int);

700 701 702 703 704 705 706 707 708 709 710 711 712
#define ide_devset_get(name, field) \
int get_##name(ide_drive_t *drive) \
{ \
	return drive->field; \
}

#define ide_devset_set(name, field) \
int set_##name(ide_drive_t *drive, int arg) \
{ \
	drive->field = arg; \
	return 0; \
}

713 714 715 716 717 718 719
/* ATAPI packet command flags */
enum {
	/* set when an error is considered normal - no retry (ide-tape) */
	PC_FLAG_ABORT			= (1 << 0),
	PC_FLAG_SUPPRESS_ERROR		= (1 << 1),
	PC_FLAG_WAIT_FOR_DSC		= (1 << 2),
	PC_FLAG_DMA_OK			= (1 << 3),
720 721 722
	PC_FLAG_DMA_IN_PROGRESS		= (1 << 4),
	PC_FLAG_DMA_ERROR		= (1 << 5),
	PC_FLAG_WRITING			= (1 << 6),
723
	/* command timed out */
724
	PC_FLAG_TIMEDOUT		= (1 << 7),
725 726
};

727 728 729 730 731 732
/*
 * With each packet command, we allocate a buffer of IDE_PC_BUFFER_SIZE bytes.
 * This is used for several packet commands (not for READ/WRITE commands).
 */
#define IDE_PC_BUFFER_SIZE	256

733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
struct ide_atapi_pc {
	/* actual packet bytes */
	u8 c[12];
	/* incremented on each retry */
	int retries;
	int error;

	/* bytes to transfer */
	int req_xfer;
	/* bytes actually transferred */
	int xferred;

	/* data buffer */
	u8 *buf;
	/* current buffer position */
	u8 *cur_pos;
	int buf_size;
	/* missing/available data on the current buffer */
	int b_count;

	/* the corresponding request */
	struct request *rq;

	unsigned long flags;

	/*
	 * those are more or less driver-specific and some of them are subject
	 * to change/removal later.
	 */
762
	u8 pc_buf[IDE_PC_BUFFER_SIZE];
763

764 765 766 767 768 769 770 771 772 773 774 775 776 777
	/* idetape only */
	struct idetape_bh *bh;
	char *b_data;

	/* idescsi only for now */
	struct scatterlist *sg;
	unsigned int sg_cnt;

	struct scsi_cmnd *scsi_cmd;
	void (*done) (struct scsi_cmnd *);

	unsigned long timeout;
};

778
#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds's avatar
Linus Torvalds committed
779 780 781 782
/*
 * configurable drive settings
 */

783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
#define S_READ		(1 << 0)
#define S_WRITE		(1 << 1)
#define S_RW		(S_READ | S_WRITE)
#define S_NOLOCK	(1 << 2)

struct ide_devset {
	const char	*name;
	unsigned int	flags;
	int		min, max;
	int		(*get)(ide_drive_t *);
	int		(*set)(ide_drive_t *, int);
	int		(*mulf)(ide_drive_t *);
	int		(*divf)(ide_drive_t *);
};

#define __DEVSET(_name, _flags, _min, _max, _get, _set, _mulf, _divf) { \
	.name	= __stringify(_name), \
	.flags	= _flags, \
	.min	= _min, \
	.max	= _max, \
	.get	= _get, \
	.set	= _set, \
	.mulf	= _mulf, \
	.divf	= _divf, \
}

#define __IDE_DEVSET(_name, _flags, _min, _max, _get, _set, _mulf, _divf) \
static const struct ide_devset ide_devset_##_name = \
	__DEVSET(_name, _flags, _min, _max, _get, _set, _mulf, _divf)

#define IDE_DEVSET(_name, _flags, _min, _max, _get, _set) \
__IDE_DEVSET(_name, _flags, _min, _max, _get, _set, NULL, NULL)

#define ide_devset_rw_nolock(_name, _min, _max, _func) \
IDE_DEVSET(_name, S_RW | S_NOLOCK, _min, _max, get_##_func, set_##_func)

#define ide_devset_w_nolock(_name, _min, _max, _func) \
IDE_DEVSET(_name, S_WRITE | S_NOLOCK, _min, _max, NULL, set_##_func)

#define ide_devset_rw(_name, _min, _max, _field) \
static ide_devset_get(_name, _field); \
static ide_devset_set(_name, _field); \
IDE_DEVSET(_name, S_RW, _min, _max, get_##_name, set_##_name)

#define ide_devset_r(_name, _min, _max, _field) \
ide_devset_get(_name, _field) \
IDE_DEVSET(_name, S_READ, _min, _max, get_##_name, NULL)
Linus Torvalds's avatar
Linus Torvalds committed
830 831 832 833 834 835 836 837 838 839 840

/*
 * /proc/ide interface
 */
typedef struct {
	const char	*name;
	mode_t		mode;
	read_proc_t	*read_proc;
	write_proc_t	*write_proc;
} ide_proc_entry_t;

841 842
void proc_ide_create(void);
void proc_ide_destroy(void);
843
void ide_proc_register_port(ide_hwif_t *);
844
void ide_proc_port_register_devices(ide_hwif_t *);
845
void ide_proc_unregister_device(ide_drive_t *);
846
void ide_proc_unregister_port(ide_hwif_t *);
847 848 849
void ide_proc_register_driver(ide_drive_t *, ide_driver_t *);
void ide_proc_unregister_driver(ide_drive_t *, ide_driver_t *);

Linus Torvalds's avatar
Linus Torvalds committed
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
read_proc_t proc_ide_read_capacity;
read_proc_t proc_ide_read_geometry;

/*
 * Standard exit stuff:
 */
#define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) \
{					\
	len -= off;			\
	if (len < count) {		\
		*eof = 1;		\
		if (len <= 0)		\
			return 0;	\
	} else				\
		len = count;		\
	*start = page + off;		\
	return len;			\
}
#else
869 870
static inline void proc_ide_create(void) { ; }
static inline void proc_ide_destroy(void) { ; }
871
static inline void ide_proc_register_port(ide_hwif_t *hwif) { ; }
872
static inline void ide_proc_port_register_devices(ide_hwif_t *hwif) { ; }
873
static inline void ide_proc_unregister_device(ide_drive_t *drive) { ; }
874
static inline void ide_proc_unregister_port(ide_hwif_t *hwif) { ; }
875 876
static inline void ide_proc_register_driver(ide_drive_t *drive, ide_driver_t *driver) { ; }
static inline void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver) { ; }
Linus Torvalds's avatar
Linus Torvalds committed
877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
#define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) return 0;
#endif

/*
 * Power Management step value (rq->pm->pm_step).
 *
 * The step value starts at 0 (ide_pm_state_start_suspend) for a
 * suspend operation or 1000 (ide_pm_state_start_resume) for a
 * resume operation.
 *
 * For each step, the core calls the subdriver start_power_step() first.
 * This can return:
 *	- ide_stopped :	In this case, the core calls us back again unless
 *			step have been set to ide_power_state_completed.
 *	- ide_started :	In this case, the channel is left busy until an
 *			async event (interrupt) occurs.
 * Typically, start_power_step() will issue a taskfile request with
 * do_rw_taskfile().
 *
 * Upon reception of the interrupt, the core will call complete_power_step()
 * with the error code if any. This routine should update the step value
 * and return. It should not start a new request. The core will call
 * start_power_step for the new step value, unless step have been set to
 * ide_power_state_completed.
 *
 * Subdrivers are expected to define their own additional power
 * steps from 1..999 for suspend and from 1001..1999 for resume,
 * other values are reserved for future use.
 */

enum {
	ide_pm_state_completed		= -1,
	ide_pm_state_start_suspend	= 0,
	ide_pm_state_start_resume	= 1000,
};

/*
 * Subdrivers support.
915 916 917
 *
 * The gendriver.owner field should be set to the module owner of this driver.
 * The gendriver.name field should be set to the name of this driver
Linus Torvalds's avatar
Linus Torvalds committed
918
 */
919
struct ide_driver_s {
Linus Torvalds's avatar
Linus Torvalds committed
920 921 922 923 924 925
	const char			*version;
	u8				media;
	ide_startstop_t	(*do_request)(ide_drive_t *, struct request *, sector_t);
	int		(*end_request)(ide_drive_t *, int, int);
	ide_startstop_t	(*error)(ide_drive_t *, struct request *rq, u8, u8);
	struct device_driver	gen_driver;
926 927
	int		(*probe)(ide_drive_t *);
	void		(*remove)(ide_drive_t *);
Lee Trager's avatar
Lee Trager committed
928
	void		(*resume)(ide_drive_t *);
929
	void		(*shutdown)(ide_drive_t *);
930 931
#ifdef CONFIG_IDE_PROC_FS
	ide_proc_entry_t	*proc;
932
	const struct ide_devset	**settings;
933 934
#endif
};
Linus Torvalds's avatar
Linus Torvalds committed
935

936 937
#define to_ide_driver(drv) container_of(drv, ide_driver_t, gen_driver)

938 939 940
int ide_device_get(ide_drive_t *);
void ide_device_put(ide_drive_t *);

941 942 943 944 945 946 947 948 949 950 951 952 953
struct ide_ioctl_devset {
	unsigned int	get_ioctl;
	unsigned int	set_ioctl;

	int		(*get)(ide_drive_t *);
	int		(*set)(ide_drive_t *, int);
};

int ide_setting_ioctl(ide_drive_t *, struct block_device *, unsigned int,
		      unsigned long, const struct ide_ioctl_devset *);

int generic_ide_ioctl(ide_drive_t *, struct file *, struct block_device *,
		      unsigned, unsigned long);
Linus Torvalds's avatar
Linus Torvalds committed
954

955 956 957
extern int ide_vlb_clk;
extern int ide_pci_clk;

Linus Torvalds's avatar
Linus Torvalds committed
958
extern int ide_end_request (ide_drive_t *drive, int uptodate, int nrsecs);
959 960
int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
			     int uptodate, int nr_sectors);
Linus Torvalds's avatar
Linus Torvalds committed
961 962 963

extern void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry);

964 965
void ide_execute_command(ide_drive_t *, u8, ide_handler_t *, unsigned int,
			 ide_expiry_t *);
Linus Torvalds's avatar
Linus Torvalds committed
966

967 968
void ide_execute_pkt_cmd(ide_drive_t *);

969 970
void ide_pad_transfer(ide_drive_t *, int, int);

Linus Torvalds's avatar
Linus Torvalds committed
971 972 973 974
ide_startstop_t __ide_error(ide_drive_t *, struct request *, u8, u8);

ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, byte stat);

975
void ide_fix_driveid(u16 *);
976

Linus Torvalds's avatar
Linus Torvalds committed
977 978
extern void ide_fixstring(u8 *, const int, const int);

979 980
int ide_busy_sleep(ide_hwif_t *, unsigned long, int);

981
int ide_wait_stat(ide_startstop_t *, ide_drive_t *, u8, u8, unsigned long);
Linus Torvalds's avatar
Linus Torvalds committed
982 983 984

extern ide_startstop_t ide_do_reset (ide_drive_t *);

985
extern void ide_do_drive_cmd(ide_drive_t *, struct request *);
Linus Torvalds's avatar
Linus Torvalds committed
986 987 988

extern void ide_end_drive_cmd(ide_drive_t *, u8, u8);

989 990
enum {
	IDE_TFLAG_LBA48			= (1 << 0),
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
	IDE_TFLAG_FLAGGED		= (1 << 2),
	IDE_TFLAG_OUT_DATA		= (1 << 3),
	IDE_TFLAG_OUT_HOB_FEATURE	= (1 << 4),
	IDE_TFLAG_OUT_HOB_NSECT		= (1 << 5),
	IDE_TFLAG_OUT_HOB_LBAL		= (1 << 6),
	IDE_TFLAG_OUT_HOB_LBAM		= (1 << 7),
	IDE_TFLAG_OUT_HOB_LBAH		= (1 << 8),
	IDE_TFLAG_OUT_HOB		= IDE_TFLAG_OUT_HOB_FEATURE |
					  IDE_TFLAG_OUT_HOB_NSECT |
					  IDE_TFLAG_OUT_HOB_LBAL |
					  IDE_TFLAG_OUT_HOB_LBAM |
					  IDE_TFLAG_OUT_HOB_LBAH,
	IDE_TFLAG_OUT_FEATURE		= (1 << 9),
	IDE_TFLAG_OUT_NSECT		= (1 << 10),
	IDE_TFLAG_OUT_LBAL		= (1 << 11),
	IDE_TFLAG_OUT_LBAM		= (1 << 12),
	IDE_TFLAG_OUT_LBAH		= (1 << 13),
	IDE_TFLAG_OUT_TF		= IDE_TFLAG_OUT_FEATURE |
					  IDE_TFLAG_OUT_NSECT |
					  IDE_TFLAG_OUT_LBAL |
					  IDE_TFLAG_OUT_LBAM |
					  IDE_TFLAG_OUT_LBAH,
1013
	IDE_TFLAG_OUT_DEVICE		= (1 << 14),
1014
	IDE_TFLAG_WRITE			= (1 << 15),
1015 1016
	IDE_TFLAG_FLAGGED_SET_IN_FLAGS	= (1 << 16),
	IDE_TFLAG_IN_DATA		= (1 << 17),
1017
	IDE_TFLAG_CUSTOM_HANDLER	= (1 << 18),
1018
	IDE_TFLAG_DMA_PIO_FALLBACK	= (1 << 19),
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
	IDE_TFLAG_IN_HOB_FEATURE	= (1 << 20),
	IDE_TFLAG_IN_HOB_NSECT		= (1 << 21),
	IDE_TFLAG_IN_HOB_LBAL		= (1 << 22),
	IDE_TFLAG_IN_HOB_LBAM		= (1 << 23),
	IDE_TFLAG_IN_HOB_LBAH		= (1 << 24),
	IDE_TFLAG_IN_HOB_LBA		= IDE_TFLAG_IN_HOB_LBAL |
					  IDE_TFLAG_IN_HOB_LBAM |
					  IDE_TFLAG_IN_HOB_LBAH,
	IDE_TFLAG_IN_HOB		= IDE_TFLAG_IN_HOB_FEATURE |
					  IDE_TFLAG_IN_HOB_NSECT |
					  IDE_TFLAG_IN_HOB_LBA,
1030
	IDE_TFLAG_IN_FEATURE		= (1 << 1),
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
	IDE_TFLAG_IN_NSECT		= (1 << 25),
	IDE_TFLAG_IN_LBAL		= (1 << 26),
	IDE_TFLAG_IN_LBAM		= (1 << 27),
	IDE_TFLAG_IN_LBAH		= (1 << 28),
	IDE_TFLAG_IN_LBA		= IDE_TFLAG_IN_LBAL |
					  IDE_TFLAG_IN_LBAM |
					  IDE_TFLAG_IN_LBAH,
	IDE_TFLAG_IN_TF			= IDE_TFLAG_IN_NSECT |
					  IDE_TFLAG_IN_LBA,
	IDE_TFLAG_IN_DEVICE		= (1 << 29),
1041 1042 1043 1044 1045 1046
	IDE_TFLAG_HOB			= IDE_TFLAG_OUT_HOB |
					  IDE_TFLAG_IN_HOB,
	IDE_TFLAG_TF			= IDE_TFLAG_OUT_TF |
					  IDE_TFLAG_IN_TF,
	IDE_TFLAG_DEVICE		= IDE_TFLAG_OUT_DEVICE |
					  IDE_TFLAG_IN_DEVICE,
1047 1048
	/* force 16-bit I/O operations */
	IDE_TFLAG_IO_16BIT		= (1 << 30),
1049 1050
	/* ide_task_t was allocated using kmalloc() */
	IDE_TFLAG_DYN			= (1 << 31),
1051 1052
};

1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
struct ide_taskfile {
	u8	hob_data;	/*  0: high data byte (for TASKFILE IOCTL) */

	u8	hob_feature;	/*  1-5: additional data to support LBA48 */
	u8	hob_nsect;
	u8	hob_lbal;
	u8	hob_lbam;
	u8	hob_lbah;

	u8	data;		/*  6: low data byte (for TASKFILE IOCTL) */

	union {			/*  7: */
		u8 error;	/*   read:  error */
		u8 feature;	/*  write: feature */
	};

	u8	nsect;		/*  8: number of sectors */
	u8	lbal;		/*  9: LBA low */
	u8	lbam;		/* 10: LBA mid */
	u8	lbah;		/* 11: LBA high */

	u8	device;		/* 12: device select */

	union {			/* 13: */
		u8 status;	/*  read: status  */
		u8 command;	/* write: command */
	};
};

Linus Torvalds's avatar
Linus Torvalds committed
1082
typedef struct ide_task_s {
1083 1084 1085 1086
	union {
		struct ide_taskfile	tf;
		u8			tf_array[14];
	};
1087
	u32			tf_flags;
Linus Torvalds's avatar
Linus Torvalds committed
1088 1089 1090 1091 1092
	int			data_phase;
	struct request		*rq;		/* copy of request */
	void			*special;	/* valid_t generally */
} ide_task_t;

1093
void ide_tf_dump(const char *, struct ide_taskfile *);
Linus Torvalds's avatar
Linus Torvalds committed
1094

1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
void ide_exec_command(ide_hwif_t *, u8);
u8 ide_read_status(ide_hwif_t *);
u8 ide_read_altstatus(ide_hwif_t *);
u8 ide_read_sff_dma_status(ide_hwif_t *);

void ide_set_irq(ide_hwif_t *, int);

void ide_tf_load(ide_drive_t *, ide_task_t *);
void ide_tf_read(ide_drive_t *, ide_task_t *);

void ide_input_data(ide_drive_t *, struct request *, void *, unsigned int);
void ide_output_data(ide_drive_t *, struct request *, void *, unsigned int);

1108 1109
int ide_io_buffers(ide_drive_t *, struct ide_atapi_pc *, unsigned int, int);

Linus Torvalds's avatar
Linus Torvalds committed
1110
extern void SELECT_DRIVE(ide_drive_t *);
1111
void SELECT_MASK(ide_drive_t *, int);
Linus Torvalds's avatar
Linus Torvalds committed
1112

1113
u8 ide_read_error(ide_drive_t *);
1114
void ide_read_bcount_and_ireason(ide_drive_t *, u16 *, u8 *);
1115

Linus Torvalds's avatar
Linus Torvalds committed
1116 1117
extern int drive_is_ready(ide_drive_t *);

1118 1119
void ide_pktcmd_tf_load(ide_drive_t *, u32, u16, u8);

1120 1121
int ide_check_atapi_device(ide_drive_t *, const char *);

1122 1123
void ide_init_pc(struct ide_atapi_pc *);

1124 1125 1126 1127
ide_startstop_t ide_pc_intr(ide_drive_t *drive, struct ide_atapi_pc *pc,
	ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry,
	void (*update_buffers)(ide_drive_t *, struct ide_atapi_pc *),
	void (*retry_pc)(ide_drive_t *), void (*dsc_handle)(ide_drive_t *),
1128
	int (*io_buffers)(ide_drive_t *, struct ide_atapi_pc *, unsigned int,
1129
			   int));
1130 1131
ide_startstop_t ide_transfer_pc(ide_drive_t *, struct ide_atapi_pc *,
				ide_handler_t *, unsigned int, ide_expiry_t *);
1132 1133
ide_startstop_t ide_issue_pc(ide_drive_t *, struct ide_atapi_pc *,
			     ide_handler_t *, unsigned int, ide_expiry_t *);
1134

1135
ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
Linus Torvalds's avatar
Linus Torvalds committed
1136

Tejun Heo's avatar
Tejun Heo committed
1137 1138
void task_end_request(ide_drive_t *, struct request *, u8);

1139
int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *, u16);
1140 1141
int ide_no_data_taskfile(ide_drive_t *, ide_task_t *);

Linus Torvalds's avatar
Linus Torvalds committed
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
int ide_taskfile_ioctl(ide_drive_t *, unsigned int, unsigned long);

extern int ide_driveid_update(ide_drive_t *);
extern int ide_config_drive_speed(ide_drive_t *, u8);
extern u8 eighty_ninty_three (ide_drive_t *);
extern int taskfile_lib_get_identify(ide_drive_t *drive, u8 *);

extern int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout);

extern void ide_stall_queue(ide_drive_t *drive, unsigned long timeout);

extern int ide_spin_wait_hwgroup(ide_drive_t *);
extern void ide_timer_expiry(unsigned long);
1155
extern irqreturn_t ide_intr(int irq, void *dev_id);
1156
extern void do_ide_request(struct request_queue *);
Linus Torvalds's avatar
Linus Torvalds committed
1157 1158 1159

void ide_init_disk(struct gendisk *, ide_drive_t *);

1160
#ifdef CONFIG_IDEPCI_PCIBUS_ORDER
1161 1162
extern int __ide_pci_register_driver(struct pci_driver *driver, struct module *owner, const char *mod_name);
#define ide_pci_register_driver(d) __ide_pci_register_driver(d, THIS_MODULE, KBUILD_MODNAME)
1163 1164 1165 1166
#else
#define ide_pci_register_driver(d) pci_register_driver(d)
#endif

1167
void ide_pci_setup_ports(struct pci_dev *, const struct ide_port_info *, int,
1168
			 hw_regs_t *, hw_regs_t **);
1169
void ide_setup_pci_noise(struct pci_dev *, const struct ide_port_info *);
Linus Torvalds's avatar
Linus Torvalds committed
1170

1171
#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
1172 1173
int ide_pci_set_master(struct pci_dev *, const char *);
unsigned long ide_pci_dma_base(ide_hwif_t *, const struct ide_port_info *);
1174
int ide_pci_check_simplex(ide_hwif_t *, const struct ide_port_info *);
1175
int ide_hwif_setup_dma(ide_hwif_t *, const struct ide_port_info *);
1176
#else
1177 1178 1179 1180 1181
static inline int ide_hwif_setup_dma(ide_hwif_t *hwif,
				     const struct ide_port_info *d)
{
	return -EINVAL;
}
1182 1183
#endif

Linus Torvalds's avatar
Linus Torvalds committed
1184 1185 1186 1187 1188 1189 1190 1191
typedef struct ide_pci_enablebit_s {
	u8	reg;	/* byte pci reg holding the enable-bit */
	u8	mask;	/* mask to isolate the enable-bit */
	u8	val;	/* value of masked reg when "enabled" */
} ide_pci_enablebit_t;

enum {
	/* Uses ISA control ports not PCI ones. */
1192
	IDE_HFLAG_ISA_PORTS		= (1 << 0),
1193
	/* single port device */
1194
	IDE_HFLAG_SINGLE		= (1 << 1),
1195 1196
	/* don't use legacy PIO blacklist */
	IDE_HFLAG_PIO_NO_BLACKLIST	= (1 << 2),
1197 1198
	/* set for the second port of QD65xx */
	IDE_HFLAG_QD_2ND_PORT		= (1 << 3),
1199 1200 1201 1202 1203 1204
	/* use PIO8/9 for prefetch off/on */
	IDE_HFLAG_ABUSE_PREFETCH	= (1 << 4),
	/* use PIO6/7 for fast-devsel off/on */
	IDE_HFLAG_ABUSE_FAST_DEVSEL	= (1 << 5),
	/* use 100-102 and 200-202 PIO values to set DMA modes */
	IDE_HFLAG_ABUSE_DMA_MODES	= (1 << 6),
1205 1206 1207 1208 1209
	/*
	 * keep DMA setting when programming PIO mode, may be used only
	 * for hosts which have separate PIO and DMA timings (ie. PMAC)
	 */
	IDE_HFLAG_SET_PIO_MODE_KEEP_DMA	= (1 << 7),
1210 1211 1212 1213
	/* program host for the transfer mode after programming device */
	IDE_HFLAG_POST_SET_MODE		= (1 << 8),
	/* don't program host/device for the transfer mode ("smart" hosts) */
	IDE_HFLAG_NO_SET_MODE		= (1 << 9),
1214 1215
	/* trust BIOS for programming chipset/device for DMA */
	IDE_HFLAG_TRUST_BIOS_FOR_DMA	= (1 << 10),
1216 1217
	/* host is CS5510/CS5520 */
	IDE_HFLAG_CS5520		= (1 << 11),
1218 1219
	/* ATAPI DMA is unsupported */
	IDE_HFLAG_NO_ATAPI_DMA		= (1 << 12),
1220 1221
	/* set if host is a "non-bootable" controller */
	IDE_HFLAG_NON_BOOTABLE		= (1 << 13),
1222 1223 1224 1225
	/* host doesn't support DMA */
	IDE_HFLAG_NO_DMA		= (1 << 14),
	/* check if host is PCI IDE device before allowing DMA */
	IDE_HFLAG_NO_AUTODMA		= (1 << 15),
1226 1227
	/* host uses MMIO */
	IDE_HFLAG_MMIO			= (1 << 16),
1228 1229 1230 1231
	/* no LBA48 */
	IDE_HFLAG_NO_LBA48		= (1 << 17),
	/* no LBA48 DMA */
	IDE_HFLAG_NO_LBA48_DMA		= (1 << 18),
1232 1233
	/* data FIFO is cleared by an error */
	IDE_HFLAG_ERROR_STOPS_FIFO	= (1 << 19),
1234 1235
	/* serialize ports */
	IDE_HFLAG_SERIALIZE		= (1 << 20),
1236 1237
	/* use legacy IRQs */
	IDE_HFLAG_LEGACY_IRQS		= (1 << 21),
1238 1239
	/* force use of legacy IRQs */
	IDE_HFLAG_FORCE_LEGACY_IRQS	= (1 << 22),
1240 1241
	/* limit LBA48 requests to 256 sectors */
	IDE_HFLAG_RQSIZE_256		= (1 << 23),
1242 1243 1244 1245
	/* use 32-bit I/O ops */
	IDE_HFLAG_IO_32BIT		= (1 << 24),
	/* unmask IRQs */
	IDE_HFLAG_UNMASK_IRQS		= (1 << 25),
1246 1247
	/* serialize ports if DMA is possible (for sl82c105) */
	IDE_HFLAG_SERIALIZE_DMA		= (1 << 27),
1248 1249
	/* force host out of "simplex" mode */
	IDE_HFLAG_CLEAR_SIMPLEX		= (1 << 28),
1250 1251
	/* DSC overlap is unsupported */
	IDE_HFLAG_NO_DSC		= (1 << 29),
1252 1253 1254 1255
	/* never use 32-bit I/O ops */
	IDE_HFLAG_NO_IO_32BIT		= (1 << 30),
	/* never unmask IRQs */
	IDE_HFLAG_NO_UNMASK_IRQS	= (1 << 31),
Linus Torvalds's avatar
Linus Torvalds committed
1256 1257
};

1258 1259
#ifdef CONFIG_BLK_DEV_OFFBOARD
# define IDE_HFLAG_OFF_BOARD	0
1260 1261
#else
# define IDE_HFLAG_OFF_BOARD	IDE_HFLAG_NON_BOOTABLE
1262 1263
#endif

1264
struct ide_port_info {
Linus Torvalds's avatar
Linus Torvalds committed
1265
	char			*name;
1266
	unsigned int		(*init_chipset)(struct pci_dev *);
Linus Torvalds's avatar
Linus Torvalds committed
1267 1268
	void			(*init_iops)(ide_hwif_t *);
	void                    (*init_hwif)(ide_hwif_t *);
1269 1270
	int			(*init_dma)(ide_hwif_t *,
					    const struct ide_port_info *);
1271

1272
	const struct ide_tp_ops		*tp_ops;
1273
	const struct ide_port_ops	*port_ops;
1274
	const struct ide_dma_ops	*dma_ops;
1275

Linus Torvalds's avatar
Linus Torvalds committed
1276
	ide_pci_enablebit_t	enablebits[2];
1277
	hwif_chipset_t		chipset;
1278
	u32			host_flags;
1279
	u8			pio_mask;
1280 1281
	u8			swdma_mask;
	u8			mwdma_mask;
1282
	u8			udma_mask;
1283
};
Linus Torvalds's avatar
Linus Torvalds committed
1284

1285 1286 1287
int ide_pci_init_one(struct pci_dev *, const struct ide_port_info *, void *);
int ide_pci_init_two(struct pci_dev *, struct pci_dev *,
		     const struct ide_port_info *, void *);
1288
void ide_pci_remove(struct pci_dev *);
Linus Torvalds's avatar
Linus Torvalds committed
1289

1290 1291 1292 1293 1294 1295 1296 1297
#ifdef CONFIG_PM
int ide_pci_suspend(struct pci_dev *, pm_message_t);
int ide_pci_resume(struct pci_dev *);
#else
#define ide_pci_suspend NULL
#define ide_pci_resume NULL
#endif

Linus Torvalds's avatar
Linus Torvalds committed
1298 1299 1300 1301 1302 1303
void ide_map_sg(ide_drive_t *, struct request *);
void ide_init_sg_cmd(ide_drive_t *, struct request *);

#define BAD_DMA_DRIVE		0
#define GOOD_DMA_DRIVE		1

1304 1305 1306 1307 1308
struct drive_list_entry {
	const char *id_model;
	const char *id_firmware;
};

1309
int ide_in_drive_list(u16 *, const struct drive_list_entry *);
1310 1311

#ifdef CONFIG_BLK_DEV_IDEDMA
Linus Torvalds's avatar
Linus Torvalds committed
1312
int __ide_dma_bad_drive(ide_drive_t *);
1313
int ide_id_dma_bug(ide_drive_t *);
1314 1315 1316 1317 1318 1319 1320 1321

u8 ide_find_dma_mode(ide_drive_t *, u8);

static inline u8 ide_max_dma_mode(ide_drive_t *drive)
{
	return ide_find_dma_mode(drive, XFER_UDMA_6);
}

1322
void ide_dma_off_quietly(ide_drive_t *);
1323
void ide_dma_off(ide_drive_t *);
1324
void ide_dma_on(ide_drive_t *);
1325
int ide_set_dma(ide_drive_t *);
1326
void ide_check_dma_crc(ide_drive_t *);
Linus Torvalds's avatar
Linus Torvalds committed
1327 1328
ide_startstop_t ide_dma_intr(ide_drive_t *);

1329 1330 1331
int ide_build_sglist(ide_drive_t *, struct request *);
void ide_destroy_dmatable(ide_drive_t *);

1332
#ifdef CONFIG_BLK_DEV_IDEDMA_SFF
Linus Torvalds's avatar
Linus Torvalds committed
1333
extern int ide_build_dmatable(ide_drive_t *, struct request *);
1334 1335
int ide_allocate_dma_engine(ide_hwif_t *);
void ide_release_dma_engine(ide_hwif_t *);
Linus Torvalds's avatar
Linus Torvalds committed
1336

1337
void ide_dma_host_set(ide_drive_t *, int);
Linus Torvalds's avatar
Linus Torvalds committed
1338
extern int ide_dma_setup(ide_drive_t *);
1339
void ide_dma_exec_cmd(ide_drive_t *, u8);
Linus Torvalds's avatar
Linus Torvalds committed
1340 1341
extern void ide_dma_start(ide_drive_t *);
extern int __ide_dma_end(ide_drive_t *);
1342
int ide_dma_test_irq(ide_drive_t *);
1343
extern void ide_dma_lost_irq(ide_drive_t *);
1344
extern void ide_dma_timeout(ide_drive_t *);
1345
extern const struct ide_dma_ops sff_dma_ops;
1346
#endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
Linus Torvalds's avatar
Linus Torvalds committed
1347 1348

#else
1349
static inline int ide_id_dma_bug(ide_drive_t *drive) { return 0; }
1350
static inline u8 ide_find_dma_mode(ide_drive_t *drive, u8 speed) { return 0; }
1351
static inline u8 ide_max_dma_mode(ide_drive_t *drive) { return 0; }
1352
static inline void ide_dma_off_quietly(ide_drive_t *drive) { ; }
1353
static inline void ide_dma_off(ide_drive_t *drive) { ; }
1354
static inline void ide_dma_on(ide_drive_t *drive) { ; }
Linus Torvalds's avatar
Linus Torvalds committed
1355
static inline void ide_dma_verbose(ide_drive_t *drive) { ; }
1356
static inline int ide_set_dma(ide_drive_t *drive) { return 1; }
1357
static inline void ide_check_dma_crc(ide_drive_t *drive) { ; }
Linus Torvalds's avatar
Linus Torvalds committed
1358 1359
#endif /* CONFIG_BLK_DEV_IDEDMA */

1360
#ifndef CONFIG_BLK_DEV_IDEDMA_SFF
1361
static inline void ide_release_dma_engine(ide_hwif_t *hwif) { ; }
Linus Torvalds's avatar
Linus Torvalds committed
1362 1363
#endif

1364 1365 1366 1367 1368
#ifdef CONFIG_BLK_DEV_IDEACPI
extern int ide_acpi_exec_tfs(ide_drive_t *drive);
extern void ide_acpi_get_timing(ide_hwif_t *hwif);
extern void ide_acpi_push_timing(ide_hwif_t *hwif);
extern void ide_acpi_init(ide_hwif_t *hwif);
1369
void ide_acpi_port_init_devices(ide_hwif_t *);
1370
extern void ide_acpi_set_state(ide_hwif_t *hwif, int on);
1371 1372 1373 1374 1375
#else
static inline int ide_acpi_exec_tfs(ide_drive_t *drive) { return 0; }
static inline void ide_acpi_get_timing(ide_hwif_t *hwif) { ; }
static inline void ide_acpi_push_timing(ide_hwif_t *hwif) { ; }
static inline void ide_acpi_init(ide_hwif_t *hwif) { ; }
1376
static inline void ide_acpi_port_init_devices(ide_hwif_t *hwif) { ; }
1377
static inline void ide_acpi_set_state(ide_hwif_t *hwif, int on) {}
1378 1379
#endif

1380
void ide_remove_port_from_hwgroup(ide_hwif_t *);
1381
void ide_unregister(ide_hwif_t *);
Linus Torvalds's avatar
Linus Torvalds committed
1382 1383 1384 1385

void ide_register_region(struct gendisk *);
void ide_unregister_region(struct gendisk *);

1386
void ide_undecoded_slave(ide_drive_t *);
Linus Torvalds's avatar
Linus Torvalds committed
1387

1388 1389
void ide_port_apply_params(ide_hwif_t *);

1390 1391
struct ide_host *ide_host_alloc_all(const struct ide_port_info *, hw_regs_t **);
struct ide_host *ide_host_alloc(const struct ide_port_info *, hw_regs_t **);
1392
void ide_host_free(struct ide_host *);
1393 1394
int ide_host_register(struct ide_host *, const struct ide_port_info *,
		      hw_regs_t **);
1395 1396
int ide_host_add(const struct ide_port_info *, hw_regs_t **,
		 struct ide_host **);
1397
void ide_host_remove(struct ide_host *);
1398
int ide_legacy_device_add(const struct ide_port_info *, unsigned long);
1399 1400
void ide_port_unregister_devices(ide_hwif_t *);
void ide_port_scan(ide_hwif_t *);
Linus Torvalds's avatar
Linus Torvalds committed
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411

static inline void *ide_get_hwifdata (ide_hwif_t * hwif)
{
	return hwif->hwif_data;
}

static inline void ide_set_hwifdata (ide_hwif_t * hwif, void *data)
{
	hwif->hwif_data = data;
}

1412
const char *ide_xfer_verbose(u8 mode);
Linus Torvalds's avatar
Linus Torvalds committed
1413 1414 1415
extern void ide_toggle_bounce(ide_drive_t *drive, int on);
extern int ide_set_xfer_rate(ide_drive_t *drive, u8 rate);

1416
u64 ide_get_lba_addr(struct ide_taskfile *, int);
Linus Torvalds's avatar
Linus Torvalds committed
1417 1418
u8 ide_dump_status(ide_drive_t *, const char *, u8);

1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
struct ide_timing {
	u8  mode;
	u8  setup;	/* t1 */
	u16 act8b;	/* t2 for 8-bit io */
	u16 rec8b;	/* t2i for 8-bit io */
	u16 cyc8b;	/* t0 for 8-bit io */
	u16 active;	/* t2 or tD */
	u16 recover;	/* t2i or tK */
	u16 cycle;	/* t0 */
	u16 udma;	/* t2CYCTYP/2 */
};

enum {
	IDE_TIMING_SETUP	= (1 << 0),
	IDE_TIMING_ACT8B	= (1 << 1),
	IDE_TIMING_REC8B	= (1 << 2),
	IDE_TIMING_CYC8B	= (1 << 3),
	IDE_TIMING_8BIT		= IDE_TIMING_ACT8B | IDE_TIMING_REC8B |
				  IDE_TIMING_CYC8B,
	IDE_TIMING_ACTIVE	= (1 << 4),
	IDE_TIMING_RECOVER	= (1 << 5),
	IDE_TIMING_CYCLE	= (1 << 6),
	IDE_TIMING_UDMA		= (1 << 7),
	IDE_TIMING_ALL		= IDE_TIMING_SETUP | IDE_TIMING_8BIT |
				  IDE_TIMING_ACTIVE | IDE_TIMING_RECOVER |
				  IDE_TIMING_CYCLE | IDE_TIMING_UDMA,
};

1447
struct ide_timing *ide_timing_find_mode(u8);
1448
u16 ide_pio_cycle_time(ide_drive_t *, u8);
1449 1450 1451 1452
void ide_timing_merge(struct ide_timing *, struct ide_timing *,
		      struct ide_timing *, unsigned int);
int ide_timing_compute(ide_drive_t *, u8, struct ide_timing *, int, int);

1453 1454
int ide_scan_pio_blacklist(char *);

1455
u8 ide_get_best_pio_mode(ide_drive_t *, u8, u8);
Linus Torvalds's avatar
Linus Torvalds committed
1456

1457 1458 1459
int ide_set_pio_mode(ide_drive_t *, u8);
int ide_set_dma_mode(ide_drive_t *, u8);

1460 1461 1462 1463 1464 1465
void ide_set_pio(ide_drive_t *, u8);

static inline void ide_set_max_pio(ide_drive_t *drive)
{
	ide_set_pio(drive, 255);
}
Linus Torvalds's avatar
Linus Torvalds committed
1466 1467

extern spinlock_t ide_lock;
1468
extern struct mutex ide_cfg_mtx;
Linus Torvalds's avatar
Linus Torvalds committed
1469 1470 1471
/*
 * Structure locking:
 *
1472
 * ide_cfg_mtx and ide_lock together protect changes to
Linus Torvalds's avatar
Linus Torvalds committed
1473 1474 1475 1476 1477 1478 1479 1480 1481
 * ide_hwif_t->{next,hwgroup}
 * ide_drive_t->next
 *
 * ide_hwgroup_t->busy: ide_lock
 * ide_hwgroup_t->hwif: ide_lock
 * ide_hwif_t->mate: constant, no locking
 * ide_drive_t->hwif: constant, no locking
 */

1482
#define local_irq_set(flags)	do { local_save_flags((flags)); local_irq_enable_in_hardirq(); } while (0)
Linus Torvalds's avatar
Linus Torvalds committed
1483 1484

extern struct bus_type ide_bus_type;
1485
extern struct class *ide_port_class;
Linus Torvalds's avatar
Linus Torvalds committed
1486

1487 1488 1489 1490 1491
static inline void ide_dump_identify(u8 *id)
{
	print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 2, id, 512, 0);
}

1492 1493
static inline int hwif_to_node(ide_hwif_t *hwif)
{
1494
	return hwif->dev ? dev_to_node(hwif->dev) : -1;
1495 1496
}

1497
static inline ide_drive_t *ide_get_pair_dev(ide_drive_t *drive)
1498
{
1499
	ide_drive_t *peer = &drive->hwif->drives[(drive->dn ^ 1) & 1];
1500

1501
	return peer->present ? peer : NULL;
1502
}
Linus Torvalds's avatar
Linus Torvalds committed
1503
#endif /* _IDE_H */