ide.h 47.4 KB
Newer Older
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
24 25 26
#include <asm/byteorder.h>
#include <asm/system.h>
#include <asm/io.h>
27
#include <asm/mutex.h>
L
Linus Torvalds 已提交
28

29
#if defined(CONFIG_CRIS) || defined(CONFIG_FRV)
30 31 32
# define SUPPORT_VLB_SYNC 0
#else
# define SUPPORT_VLB_SYNC 1
L
Linus Torvalds 已提交
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
#endif

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 */

#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)

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
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;
};
L
Linus Torvalds 已提交
76 77 78

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

79 80 81 82 83 84
#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)
L
Linus Torvalds 已提交
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116

#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
117

L
Linus Torvalds 已提交
118 119 120
/*
 * Timeouts for various operations:
 */
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
enum {
	/* spec allows up to 20ms */
	WAIT_DRQ	= HZ / 10,	/* 100ms */
	/* some laptops are very slow */
	WAIT_READY	= 5 * HZ,	/* 5s */
	/* should be less than 3ms (?), if all ATAPI CD is closed at boot */
	WAIT_PIDENTIFY	= 10 * HZ,	/* 10s */
	/* worst case when spinning up */
	WAIT_WORSTCASE	= 30 * HZ,	/* 30s */
	/* maximum wait for an IRQ to happen */
	WAIT_CMD	= 10 * HZ,	/* 10s */
	/* Some drives require a longer IRQ timeout. */
	WAIT_FLOPPY_CMD	= 50 * HZ,	/* 50s */
	/*
	 * Some drives (for example, Seagate STT3401A Travan) require a very
	 * long timeout, because they don't return an interrupt or clear their
	 * BSY bit until after the command completes (even retension commands).
	 */
	WAIT_TAPE_CMD	= 900 * HZ,	/* 900s */
	/* minimum sleep time */
	WAIT_MIN_SLEEP	= HZ / 50,	/* 20ms */
};
L
Linus Torvalds 已提交
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
149
#define REQ_DEVSET_EXEC		0x21
150 151
#define REQ_PARK_HEADS		0x22
#define REQ_UNPARK_HEADS	0x23
152

L
Linus Torvalds 已提交
153 154 155 156 157 158 159 160 161 162
/*
 * 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.
 */
163
enum {		ide_unknown,	ide_generic,	ide_pci,
L
Linus Torvalds 已提交
164 165
		ide_cmd640,	ide_dtc2278,	ide_ali14xx,
		ide_qd65xx,	ide_umc8672,	ide_ht6560b,
166
		ide_4drives,	ide_pmac,	ide_acorn,
167
		ide_au1xxx,	ide_palm3710
168 169 170
};

typedef u8 hwif_chipset_t;
L
Linus Torvalds 已提交
171 172 173 174 175

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

L
Linus Torvalds 已提交
181 182 183
	int		irq;			/* our irq number */
	ide_ack_intr_t	*ack_intr;		/* acknowledge interrupt */
	hwif_chipset_t  chipset;
184
	struct device	*dev, *parent;
185
	unsigned long	config;
L
Linus Torvalds 已提交
186 187
} hw_regs_t;

188
void ide_init_port_data(struct hwif_s *, unsigned int);
189
void ide_init_port_hw(struct hwif_s *, hw_regs_t *);
190

L
Linus Torvalds 已提交
191 192 193 194 195 196
static inline void ide_std_init_ports(hw_regs_t *hw,
				      unsigned long io_addr,
				      unsigned long ctl_addr)
{
	unsigned int i;

197 198
	for (i = 0; i <= 7; i++)
		hw->io_ports_array[i] = io_addr++;
L
Linus Torvalds 已提交
199

200
	hw->io_ports.ctl_addr = ctl_addr;
L
Linus Torvalds 已提交
201 202
}

203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
/* 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;
}

218 219 220
#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)
L
Linus Torvalds 已提交
221
#include <asm/ide.h>
222 223 224
#else
#include <asm-generic/ide_iops.h>
#endif
L
Linus Torvalds 已提交
225

226
#define MAX_HWIFS	10
227

L
Linus Torvalds 已提交
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
/* 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
 * reserved	: unused
 */
typedef union {
	unsigned all			: 8;
	struct {
		unsigned set_geometry	: 1;
		unsigned recalibrate	: 1;
		unsigned set_multmode	: 1;
264
		unsigned reserved	: 5;
L
Linus Torvalds 已提交
265 266 267 268 269 270 271 272 273 274 275
	} b;
} special_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;

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 308 309 310 311 312 313 314 315 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 371 372 373 374 375 376 377 378 379
enum {
	IDE_TFLAG_LBA48			= (1 << 0),
	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,
	IDE_TFLAG_OUT_DEVICE		= (1 << 14),
	IDE_TFLAG_WRITE			= (1 << 15),
	IDE_TFLAG_FLAGGED_SET_IN_FLAGS	= (1 << 16),
	IDE_TFLAG_IN_DATA		= (1 << 17),
	IDE_TFLAG_CUSTOM_HANDLER	= (1 << 18),
	IDE_TFLAG_DMA_PIO_FALLBACK	= (1 << 19),
	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,
	IDE_TFLAG_IN_FEATURE		= (1 << 1),
	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),
	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,
	/* force 16-bit I/O operations */
	IDE_TFLAG_IO_16BIT		= (1 << 30),
	/* ide_task_t was allocated using kmalloc() */
	IDE_TFLAG_DYN			= (1 << 31),
};

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 */
	};
};

typedef struct ide_task_s {
	union {
		struct ide_taskfile	tf;
		u8			tf_array[14];
	};
	u32			tf_flags;
	int			data_phase;
	struct request		*rq;		/* copy of request */
	void			*special;	/* valid_t generally */
} ide_task_t;

380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
/* 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),
	PC_FLAG_DMA_IN_PROGRESS		= (1 << 4),
	PC_FLAG_DMA_ERROR		= (1 << 5),
	PC_FLAG_WRITING			= (1 << 6),
	/* command timed out */
	PC_FLAG_TIMEDOUT		= (1 << 7),
};

/*
 * 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

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.
	 */
	u8 pc_buf[IDE_PC_BUFFER_SIZE];

	/* 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;
};

445
struct ide_devset;
L
Linus Torvalds 已提交
446 447
struct ide_driver_s;

448 449 450 451 452
#ifdef CONFIG_BLK_DEV_IDEACPI
struct ide_acpi_drive_link;
struct ide_acpi_hwif_link;
#endif

453 454 455 456 457 458 459 460 461 462 463 464 465
struct ide_drive_s;

struct ide_disk_ops {
	int		(*check)(struct ide_drive_s *, const char *);
	int		(*get_capacity)(struct ide_drive_s *);
	void		(*setup)(struct ide_drive_s *);
	void		(*flush)(struct ide_drive_s *);
	int		(*init_media)(struct ide_drive_s *, struct gendisk *);
	int		(*set_doorlock)(struct ide_drive_s *, struct gendisk *,
					int);
	ide_startstop_t	(*do_request)(struct ide_drive_s *, struct request *,
				      sector_t);
	int		(*end_request)(struct ide_drive_s *, int, int);
466 467
	int		(*ioctl)(struct ide_drive_s *, struct block_device *,
				 fmode_t, unsigned int, unsigned long);
468 469
};

470 471 472
/* ATAPI device flags */
enum {
	IDE_AFLAG_DRQ_INTERRUPT		= (1 << 0),
473 474

	/* ide-cd */
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
	/* 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),
	/* 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 */
	/* Avoid commands not supported in Clik drive */
	IDE_AFLAG_CLIK_DRIVE		= (1 << 19),
	/* Requires BH algorithm for packets */
	IDE_AFLAG_ZIP_DRIVE		= (1 << 20),
506 507
	/* Supports format progress report */
	IDE_AFLAG_SRFP			= (1 << 22),
508 509

	/* ide-tape */
510
	IDE_AFLAG_IGNORE_DSC		= (1 << 23),
511
	/* 0 When the tape position is unknown */
512
	IDE_AFLAG_ADDRESS_VALID		= (1 <<	24),
513
	/* Device already opened */
514
	IDE_AFLAG_BUSY			= (1 << 25),
515
	/* Attempt to auto-detect the current user block size */
516
	IDE_AFLAG_DETECT_BS		= (1 << 26),
517
	/* Currently on a filemark */
518
	IDE_AFLAG_FILEMARK		= (1 << 27),
519
	/* 0 = no tape is loaded, so we don't rewind after ejecting */
520
	IDE_AFLAG_MEDIUM_PRESENT	= (1 << 28),
521

522
	IDE_AFLAG_NO_AUTOCLOSE		= (1 << 29),
523 524
};

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
/* device flags */
enum {
	/* restore settings after device reset */
	IDE_DFLAG_KEEP_SETTINGS		= (1 << 0),
	/* device is using DMA for read/write */
	IDE_DFLAG_USING_DMA		= (1 << 1),
	/* okay to unmask other IRQs */
	IDE_DFLAG_UNMASK		= (1 << 2),
	/* don't attempt flushes */
	IDE_DFLAG_NOFLUSH		= (1 << 3),
	/* DSC overlap */
	IDE_DFLAG_DSC_OVERLAP		= (1 << 4),
	/* give potential excess bandwidth */
	IDE_DFLAG_NICE1			= (1 << 5),
	/* device is physically present */
	IDE_DFLAG_PRESENT		= (1 << 6),
	/* device ejected hint */
	IDE_DFLAG_DEAD			= (1 << 7),
	/* id read from device (synthetic if not set) */
	IDE_DFLAG_ID_READ		= (1 << 8),
	IDE_DFLAG_NOPROBE		= (1 << 9),
	/* need to do check_media_change() */
	IDE_DFLAG_REMOVABLE		= (1 << 10),
	/* needed for removable devices */
	IDE_DFLAG_ATTACH		= (1 << 11),
	IDE_DFLAG_FORCED_GEOM		= (1 << 12),
	/* disallow setting unmask bit */
	IDE_DFLAG_NO_UNMASK		= (1 << 13),
	/* disallow enabling 32-bit I/O */
	IDE_DFLAG_NO_IO_32BIT		= (1 << 14),
	/* for removable only: door lock/unlock works */
	IDE_DFLAG_DOORLOCKING		= (1 << 15),
	/* disallow DMA */
	IDE_DFLAG_NODMA			= (1 << 16),
	/* powermanagment told us not to do anything, so sleep nicely */
	IDE_DFLAG_BLOCKED		= (1 << 17),
	/* ide-scsi emulation */
	IDE_DFLAG_SCSI			= (1 << 18),
	/* sleeping & sleep field valid */
	IDE_DFLAG_SLEEPING		= (1 << 19),
	IDE_DFLAG_POST_RESET		= (1 << 20),
	IDE_DFLAG_UDMA33_WARNED		= (1 << 21),
	IDE_DFLAG_LBA48			= (1 << 22),
	/* status of write cache */
	IDE_DFLAG_WCACHE		= (1 << 23),
	/* used for ignoring ATA_DF */
	IDE_DFLAG_NOWERR		= (1 << 24),
572 573
	/* retrying in PIO */
	IDE_DFLAG_DMA_PIO_RETRY		= (1 << 25),
574
	IDE_DFLAG_LBA			= (1 << 26),
575 576 577
	/* don't unload heads */
	IDE_DFLAG_NO_UNLOAD		= (1 << 27),
	/* heads unloaded, please don't reset port */
578 579
	IDE_DFLAG_PARKED		= (1 << 28),
	IDE_DFLAG_MEDIA_CHANGED		= (1 << 29),
580 581
	/* write protect */
	IDE_DFLAG_WP			= (1 << 30),
582
	IDE_DFLAG_FORMAT_IN_PROGRESS	= (1 << 31),
583 584
};

585
struct ide_drive_s {
L
Linus Torvalds 已提交
586 587 588
	char		name[4];	/* drive name, such as "hda" */
        char            driver_req[10];	/* requests specific driver */

589
	struct request_queue	*queue;	/* request queue */
L
Linus Torvalds 已提交
590 591 592 593

	struct request		*rq;	/* current request */
	struct ide_drive_s 	*next;	/* circular list of hwgroup drives */
	void		*driver_data;	/* extra driver data */
594
	u16			*id;	/* identification info */
595
#ifdef CONFIG_IDE_PROC_FS
L
Linus Torvalds 已提交
596
	struct proc_dir_entry *proc;	/* /proc/ide/ directory entry */
597
	const struct ide_proc_devset *settings; /* /proc/ide/ drive settings */
598
#endif
L
Linus Torvalds 已提交
599 600
	struct hwif_s		*hwif;	/* actually (ide_hwif_t *) */

601 602
	const struct ide_disk_ops *disk_ops;

603 604
	unsigned long dev_flags;

L
Linus Torvalds 已提交
605 606 607 608 609 610 611
	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 */

612
	u8	select;			/* basic drive/head select reg value */
L
Linus Torvalds 已提交
613 614
	u8	retry_pio;		/* retrying dma capable host in pio */
	u8	waiting_for_dma;	/* dma currently in progress */
615
	u8	dma;			/* atapi dma flag */
L
Linus Torvalds 已提交
616 617 618 619

        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 */
620
	u8	desired_speed;	/* desired transfer rate set */
L
Linus Torvalds 已提交
621 622 623 624 625 626 627
        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	io_32bit;	/* 0=16-bit, 1=32-bit, 2/3=32bit+sync */
628
	u8	bad_wstat;	/* used for ignoring ATA_DF */
L
Linus Torvalds 已提交
629 630 631 632 633
	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 */

634 635 636
	/* delay this long before sending packet command */
	u8 pc_delay;

L
Linus Torvalds 已提交
637 638
	unsigned int	bios_cyl;	/* BIOS/fdisk/LILO number of cyls */
	unsigned int	cyl;		/* "real" number of cyls */
639
	unsigned int	drive_data;	/* used by set_pio_mode/selectproc */
L
Linus Torvalds 已提交
640 641
	unsigned int	failures;	/* current failure count */
	unsigned int	max_failures;	/* maximum allowed failure count */
642
	u64		probed_capacity;/* initial reported media capacity (ide-cd only currently) */
L
Linus Torvalds 已提交
643 644 645 646 647

	u64		capacity64;	/* total number of sectors */

	int		lun;		/* logical unit */
	int		crc_count;	/* crc counter to reduce drive speed */
648 649 650

	unsigned long	debug_mask;	/* debugging levels switch */

651 652 653
#ifdef CONFIG_BLK_DEV_IDEACPI
	struct ide_acpi_drive_link *acpidata;
#endif
L
Linus Torvalds 已提交
654 655
	struct list_head list;
	struct device	gendev;
656
	struct completion gendev_rel_comp;	/* to deal with device release() */
657

658 659 660
	/* current packet command */
	struct ide_atapi_pc *pc;

661
	/* callback for packet commands */
662
	void (*pc_callback)(struct ide_drive_s *, int);
663

664 665 666 667
	void (*pc_update_buffers)(struct ide_drive_s *, struct ide_atapi_pc *);
	int  (*pc_io_buffers)(struct ide_drive_s *, struct ide_atapi_pc *,
			      unsigned int, int);

668
	unsigned long atapi_flags;
669 670 671

	struct ide_atapi_pc request_sense_pc;
	struct request request_sense_rq;
672 673 674
};

typedef struct ide_drive_s ide_drive_t;
L
Linus Torvalds 已提交
675

676 677 678 679 680 681 682
#define to_ide_device(dev)		container_of(dev, ide_drive_t, gendev)

#define to_ide_drv(obj, cont_type)	\
	container_of(obj, struct cont_type, kref)

#define ide_drv_g(disk, cont_type)	\
	container_of((disk)->private_data, struct cont_type, driver)
683

684
struct ide_port_info;
L
Linus Torvalds 已提交
685

686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
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;

705 706 707 708 709 710 711 712 713 714 715 716
/**
 * 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
717
 * @clear_irq:		clear IRQ
718 719 720 721 722 723
 *
 * @mdma_filter:	filter MDMA modes
 * @udma_filter:	filter UDMA modes
 *
 * @cable_detect:	detect cable type
 */
724
struct ide_port_ops {
725
	void	(*init_dev)(ide_drive_t *);
726 727 728 729 730 731 732 733
	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 *);
734
	void	(*clear_irq)(ide_drive_t *);
735 736 737 738 739 740 741

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

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

742 743 744 745 746 747 748 749 750 751 752
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 *);
};

753 754
struct ide_host;

L
Linus Torvalds 已提交
755 756 757 758 759 760
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 */

761 762
	struct ide_host *host;

L
Linus Torvalds 已提交
763 764
	char name[6];			/* name of interface, eg. "ide0" */

765 766
	struct ide_io_ports	io_ports;

L
Linus Torvalds 已提交
767 768 769 770 771 772 773 774
	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 */

775
	u32 host_flags;
776

777 778
	u8 pio_mask;

L
Linus Torvalds 已提交
779 780 781 782
	u8 ultra_mask;
	u8 mwdma_mask;
	u8 swdma_mask;

783 784
	u8 cbl;		/* cable type */

L
Linus Torvalds 已提交
785 786
	hwif_chipset_t chipset;	/* sub-module for tuning.. */

787 788
	struct device *dev;

789 790
	ide_ack_intr_t *ack_intr;

L
Linus Torvalds 已提交
791 792
	void (*rw_disk)(ide_drive_t *, struct request *);

793
	const struct ide_tp_ops		*tp_ops;
794
	const struct ide_port_ops	*port_ops;
795
	const struct ide_dma_ops	*dma_ops;
796

L
Linus Torvalds 已提交
797 798 799 800
	/* dma physical region descriptor table (cpu view) */
	unsigned int	*dmatable_cpu;
	/* dma physical region descriptor table (dma view) */
	dma_addr_t	dmatable_dma;
801 802 803 804 805 806

	/* maximum number of PRD table entries */
	int prd_max_nents;
	/* PRD entry size in bytes */
	int prd_ent_size;

L
Linus Torvalds 已提交
807 808 809 810 811 812 813 814 815
	/* 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;

816 817
	struct ide_task_s task;		/* current command */

L
Linus Torvalds 已提交
818 819
	unsigned int nsect;
	unsigned int nleft;
J
Jens Axboe 已提交
820
	struct scatterlist *cursg;
L
Linus Torvalds 已提交
821 822 823 824 825 826 827 828 829 830
	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 */

831 832 833
	unsigned long	extra_base;	/* extra addr for dma ports */
	unsigned	extra_ports;	/* number of extra dma ports */

L
Linus Torvalds 已提交
834 835 836
	unsigned	present    : 1;	/* this interface exists */
	unsigned	sg_mapped  : 1;	/* sg_table and sg_nents are ready */

837 838 839
	struct device		gendev;
	struct device		*portdev;

840
	struct completion gendev_rel_comp; /* To deal with device release() */
L
Linus Torvalds 已提交
841 842 843

	void		*hwif_data;	/* extra hwif data */

844 845 846
#ifdef CONFIG_BLK_DEV_IDEACPI
	struct ide_acpi_hwif_link *acpidata;
#endif
847
} ____cacheline_internodealigned_in_smp ide_hwif_t;
L
Linus Torvalds 已提交
848

849 850
#define MAX_HOST_PORTS 4

851
struct ide_host {
852
	ide_hwif_t	*ports[MAX_HOST_PORTS];
853
	unsigned int	n_ports;
854
	struct device	*dev[2];
855
	unsigned int	(*init_chipset)(struct pci_dev *);
856
	unsigned long	host_flags;
857
	void		*host_priv;
858 859
};

L
Linus Torvalds 已提交
860 861 862 863 864 865
/*
 *  internal ide interrupt handler type
 */
typedef ide_startstop_t (ide_handler_t)(ide_drive_t *);
typedef int (ide_expiry_t)(ide_drive_t *);

866
/* used by ide-cd, ide-floppy, etc. */
867
typedef void (xfer_func_t)(ide_drive_t *, struct request *rq, void *, unsigned);
868

L
Linus Torvalds 已提交
869 870 871
typedef struct hwgroup_s {
		/* irq handler, if active */
	ide_startstop_t	(*handler)(ide_drive_t *);
872

L
Linus Torvalds 已提交
873 874 875 876 877 878
		/* 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;
879

L
Linus Torvalds 已提交
880 881 882 883 884 885 886
		/* current drive */
	ide_drive_t *drive;
		/* ptr to current hwif in linked-list */
	ide_hwif_t *hwif;

		/* current request */
	struct request *rq;
887

L
Linus Torvalds 已提交
888 889 890 891 892 893
		/* failsafe timer */
	struct timer_list timer;
		/* timeout value during long polls */
	unsigned long poll_timeout;
		/* queried upon timeouts */
	int (*expiry)(ide_drive_t *);
894

895 896
	int req_gen;
	int req_gen_timer;
897 898

	spinlock_t lock;
L
Linus Torvalds 已提交
899 900
} ide_hwgroup_t;

901 902
typedef struct ide_driver_s ide_driver_t;

903
extern struct mutex ide_setting_mtx;
L
Linus Torvalds 已提交
904

905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921
/*
 * configurable drive settings
 */

#define DS_SYNC	(1 << 0)

struct ide_devset {
	int		(*get)(ide_drive_t *);
	int		(*set)(ide_drive_t *, int);
	unsigned int	flags;
};

#define __DEVSET(_flags, _get, _set) { \
	.flags	= _flags, \
	.get	= _get,	\
	.set	= _set,	\
}
922

923
#define ide_devset_get(name, field) \
924
static int get_##name(ide_drive_t *drive) \
925 926 927 928 929
{ \
	return drive->field; \
}

#define ide_devset_set(name, field) \
930
static int set_##name(ide_drive_t *drive, int arg) \
931 932 933 934 935
{ \
	drive->field = arg; \
	return 0; \
}

936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
#define ide_devset_get_flag(name, flag) \
static int get_##name(ide_drive_t *drive) \
{ \
	return !!(drive->dev_flags & flag); \
}

#define ide_devset_set_flag(name, flag) \
static int set_##name(ide_drive_t *drive, int arg) \
{ \
	if (arg) \
		drive->dev_flags |= flag; \
	else \
		drive->dev_flags &= ~flag; \
	return 0; \
}

952 953 954 955 956 957 958 959 960 961 962 963 964
#define __IDE_DEVSET(_name, _flags, _get, _set) \
const struct ide_devset ide_devset_##_name = \
	__DEVSET(_flags, _get, _set)

#define IDE_DEVSET(_name, _flags, _get, _set) \
static __IDE_DEVSET(_name, _flags, _get, _set)

#define ide_devset_rw(_name, _func) \
IDE_DEVSET(_name, 0, get_##_func, set_##_func)

#define ide_devset_w(_name, _func) \
IDE_DEVSET(_name, 0, NULL, set_##_func)

965 966 967 968 969
#define ide_ext_devset_rw(_name, _func) \
__IDE_DEVSET(_name, 0, get_##_func, set_##_func)

#define ide_ext_devset_rw_sync(_name, _func) \
__IDE_DEVSET(_name, DS_SYNC, get_##_func, set_##_func)
970 971 972 973 974 975 976 977 978 979

#define ide_decl_devset(_name) \
extern const struct ide_devset ide_devset_##_name

ide_decl_devset(io_32bit);
ide_decl_devset(keepsettings);
ide_decl_devset(pio_mode);
ide_decl_devset(unmaskirq);
ide_decl_devset(using_dma);

980
#ifdef CONFIG_IDE_PROC_FS
L
Linus Torvalds 已提交
981
/*
982
 * /proc/ide interface
L
Linus Torvalds 已提交
983 984
 */

985 986 987 988 989
#define ide_devset_rw_field(_name, _field) \
ide_devset_get(_name, _field); \
ide_devset_set(_name, _field); \
IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name)

990 991 992 993 994
#define ide_devset_rw_flag(_name, _field) \
ide_devset_get_flag(_name, _field); \
ide_devset_set_flag(_name, _field); \
IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name)

995 996 997 998 999 1000
struct ide_proc_devset {
	const char		*name;
	const struct ide_devset	*setting;
	int			min, max;
	int			(*mulf)(ide_drive_t *);
	int			(*divf)(ide_drive_t *);
1001 1002
};

1003 1004 1005 1006 1007 1008 1009
#define __IDE_PROC_DEVSET(_name, _min, _max, _mulf, _divf) { \
	.name = __stringify(_name), \
	.setting = &ide_devset_##_name, \
	.min = _min, \
	.max = _max, \
	.mulf = _mulf, \
	.divf = _divf, \
1010 1011
}

1012 1013
#define IDE_PROC_DEVSET(_name, _min, _max) \
__IDE_PROC_DEVSET(_name, _min, _max, NULL, NULL)
1014

L
Linus Torvalds 已提交
1015 1016 1017 1018 1019 1020 1021
typedef struct {
	const char	*name;
	mode_t		mode;
	read_proc_t	*read_proc;
	write_proc_t	*write_proc;
} ide_proc_entry_t;

1022 1023
void proc_ide_create(void);
void proc_ide_destroy(void);
1024
void ide_proc_register_port(ide_hwif_t *);
1025
void ide_proc_port_register_devices(ide_hwif_t *);
1026
void ide_proc_unregister_device(ide_drive_t *);
1027
void ide_proc_unregister_port(ide_hwif_t *);
1028 1029 1030
void ide_proc_register_driver(ide_drive_t *, ide_driver_t *);
void ide_proc_unregister_driver(ide_drive_t *, ide_driver_t *);

L
Linus Torvalds 已提交
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
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
1050 1051
static inline void proc_ide_create(void) { ; }
static inline void proc_ide_destroy(void) { ; }
1052
static inline void ide_proc_register_port(ide_hwif_t *hwif) { ; }
1053
static inline void ide_proc_port_register_devices(ide_hwif_t *hwif) { ; }
1054
static inline void ide_proc_unregister_device(ide_drive_t *drive) { ; }
1055
static inline void ide_proc_unregister_port(ide_hwif_t *hwif) { ; }
1056 1057
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) { ; }
L
Linus Torvalds 已提交
1058 1059 1060
#define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) return 0;
#endif

1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
enum {
	/* enter/exit functions */
	IDE_DBG_FUNC =			(1 << 0),
	/* sense key/asc handling */
	IDE_DBG_SENSE =			(1 << 1),
	/* packet commands handling */
	IDE_DBG_PC =			(1 << 2),
	/* request handling */
	IDE_DBG_RQ =			(1 << 3),
	/* driver probing/setup */
	IDE_DBG_PROBE =			(1 << 4),
};

/* DRV_NAME has to be defined in the driver before using the macro below */
#define __ide_debug_log(lvl, fmt, args...)			\
{								\
	if (unlikely(drive->debug_mask & lvl))			\
		printk(KERN_INFO DRV_NAME ": " fmt, ## args);	\
}

L
Linus Torvalds 已提交
1081
/*
1082
 * Power Management state machine (rq->pm->pm_step).
L
Linus Torvalds 已提交
1083
 *
1084
 * For each step, the core calls ide_start_power_step() first.
L
Linus Torvalds 已提交
1085 1086 1087 1088 1089
 * 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.
1090
 * Typically, ide_start_power_step() will issue a taskfile request with
L
Linus Torvalds 已提交
1091 1092
 * do_rw_taskfile().
 *
1093
 * Upon reception of the interrupt, the core will call ide_complete_power_step()
L
Linus Torvalds 已提交
1094 1095
 * 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
1096 1097
 * ide_start_power_step() for the new step value, unless step have been
 * set to IDE_PM_COMPLETED.
L
Linus Torvalds 已提交
1098 1099
 */
enum {
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
	IDE_PM_START_SUSPEND,
	IDE_PM_FLUSH_CACHE	= IDE_PM_START_SUSPEND,
	IDE_PM_STANDBY,

	IDE_PM_START_RESUME,
	IDE_PM_RESTORE_PIO	= IDE_PM_START_RESUME,
	IDE_PM_IDLE,
	IDE_PM_RESTORE_DMA,

	IDE_PM_COMPLETED,
L
Linus Torvalds 已提交
1110 1111
};

1112 1113 1114 1115 1116 1117 1118 1119
int generic_ide_suspend(struct device *, pm_message_t);
int generic_ide_resume(struct device *);

void ide_complete_power_step(ide_drive_t *, struct request *);
ide_startstop_t ide_start_power_step(ide_drive_t *, struct request *);
void ide_complete_pm_request(ide_drive_t *, struct request *);
void ide_check_pm_state(ide_drive_t *, struct request *);

L
Linus Torvalds 已提交
1120 1121
/*
 * Subdrivers support.
1122 1123 1124
 *
 * 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
L
Linus Torvalds 已提交
1125
 */
1126
struct ide_driver_s {
L
Linus Torvalds 已提交
1127 1128 1129 1130 1131
	const char			*version;
	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;
1132 1133
	int		(*probe)(ide_drive_t *);
	void		(*remove)(ide_drive_t *);
L
Lee Trager 已提交
1134
	void		(*resume)(ide_drive_t *);
1135
	void		(*shutdown)(ide_drive_t *);
1136
#ifdef CONFIG_IDE_PROC_FS
1137 1138
	ide_proc_entry_t *		(*proc_entries)(ide_drive_t *);
	const struct ide_proc_devset *	(*proc_devsets)(ide_drive_t *);
1139 1140
#endif
};
L
Linus Torvalds 已提交
1141

1142 1143
#define to_ide_driver(drv) container_of(drv, ide_driver_t, gen_driver)

1144 1145 1146
int ide_device_get(ide_drive_t *);
void ide_device_put(ide_drive_t *);

1147 1148 1149
struct ide_ioctl_devset {
	unsigned int	get_ioctl;
	unsigned int	set_ioctl;
1150
	const struct ide_devset *setting;
1151 1152 1153 1154 1155
};

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

1156
int generic_ide_ioctl(ide_drive_t *, struct block_device *, unsigned, unsigned long);
L
Linus Torvalds 已提交
1157

1158 1159 1160
extern int ide_vlb_clk;
extern int ide_pci_clk;

L
Linus Torvalds 已提交
1161
extern int ide_end_request (ide_drive_t *drive, int uptodate, int nrsecs);
1162 1163
int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
			     int uptodate, int nr_sectors);
L
Linus Torvalds 已提交
1164 1165 1166

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

1167 1168
void ide_execute_command(ide_drive_t *, u8, ide_handler_t *, unsigned int,
			 ide_expiry_t *);
L
Linus Torvalds 已提交
1169

1170 1171
void ide_execute_pkt_cmd(ide_drive_t *);

1172 1173
void ide_pad_transfer(ide_drive_t *, int, int);

L
Linus Torvalds 已提交
1174 1175 1176 1177
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);

1178
void ide_fix_driveid(u16 *);
1179

L
Linus Torvalds 已提交
1180 1181
extern void ide_fixstring(u8 *, const int, const int);

1182 1183
int ide_busy_sleep(ide_hwif_t *, unsigned long, int);

1184
int ide_wait_stat(ide_startstop_t *, ide_drive_t *, u8, u8, unsigned long);
L
Linus Torvalds 已提交
1185 1186 1187

extern ide_startstop_t ide_do_reset (ide_drive_t *);

1188 1189 1190
extern int ide_devset_execute(ide_drive_t *drive,
			      const struct ide_devset *setting, int arg);

1191
extern void ide_do_drive_cmd(ide_drive_t *, struct request *);
L
Linus Torvalds 已提交
1192 1193 1194

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

1195
void ide_tf_dump(const char *, struct ide_taskfile *);
L
Linus Torvalds 已提交
1196

1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
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);

1210 1211
int ide_io_buffers(ide_drive_t *, struct ide_atapi_pc *, unsigned int, int);

L
Linus Torvalds 已提交
1212
extern void SELECT_DRIVE(ide_drive_t *);
1213
void SELECT_MASK(ide_drive_t *, int);
L
Linus Torvalds 已提交
1214

1215
u8 ide_read_error(ide_drive_t *);
1216
void ide_read_bcount_and_ireason(ide_drive_t *, u16 *, u8 *);
1217

L
Linus Torvalds 已提交
1218 1219
extern int drive_is_ready(ide_drive_t *);

1220 1221
void ide_pktcmd_tf_load(ide_drive_t *, u32, u16, u8);

1222 1223
int ide_check_atapi_device(ide_drive_t *, const char *);

1224 1225
void ide_init_pc(struct ide_atapi_pc *);

1226 1227 1228 1229 1230 1231 1232
/* Disk head parking */
extern wait_queue_head_t ide_park_wq;
ssize_t ide_park_show(struct device *dev, struct device_attribute *attr,
		      char *buf);
ssize_t ide_park_store(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t len);

1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
/*
 * Special requests for ide-tape block device strategy routine.
 *
 * In order to service a character device command, we add special requests to
 * the tail of our block device request queue and wait for their completion.
 */
enum {
	REQ_IDETAPE_PC1		= (1 << 0), /* packet command (first stage) */
	REQ_IDETAPE_PC2		= (1 << 1), /* packet command (second stage) */
	REQ_IDETAPE_READ	= (1 << 2),
	REQ_IDETAPE_WRITE	= (1 << 3),
};

1246
int ide_queue_pc_tail(ide_drive_t *, struct gendisk *, struct ide_atapi_pc *);
1247

1248
int ide_do_test_unit_ready(ide_drive_t *, struct gendisk *);
1249
int ide_do_start_stop(ide_drive_t *, struct gendisk *, int);
1250
int ide_set_media_lock(ide_drive_t *, struct gendisk *, int);
1251 1252
void ide_create_request_sense_cmd(ide_drive_t *, struct ide_atapi_pc *);
void ide_retry_pc(ide_drive_t *, struct gendisk *);
1253

1254 1255 1256 1257 1258 1259 1260
static inline unsigned long ide_scsi_get_timeout(struct ide_atapi_pc *pc)
{
	return max_t(unsigned long, WAIT_CMD, pc->timeout - jiffies);
}

int ide_scsi_expiry(ide_drive_t *);

1261
ide_startstop_t ide_issue_pc(ide_drive_t *, unsigned int, ide_expiry_t *);
1262

1263
ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
L
Linus Torvalds 已提交
1264

T
Tejun Heo 已提交
1265 1266
void task_end_request(ide_drive_t *, struct request *, u8);

1267
int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *, u16);
1268 1269
int ide_no_data_taskfile(ide_drive_t *, ide_task_t *);

L
Linus Torvalds 已提交
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281
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 void ide_timer_expiry(unsigned long);
1282
extern irqreturn_t ide_intr(int irq, void *dev_id);
1283
extern void do_ide_request(struct request_queue *);
L
Linus Torvalds 已提交
1284 1285 1286

void ide_init_disk(struct gendisk *, ide_drive_t *);

1287
#ifdef CONFIG_IDEPCI_PCIBUS_ORDER
1288 1289
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)
1290 1291 1292 1293
#else
#define ide_pci_register_driver(d) pci_register_driver(d)
#endif

1294 1295 1296 1297 1298 1299 1300
static inline int ide_pci_is_in_compatibility_mode(struct pci_dev *dev)
{
	if ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE && (dev->class & 5) != 5)
		return 1;
	return 0;
}

1301
void ide_pci_setup_ports(struct pci_dev *, const struct ide_port_info *, int,
1302
			 hw_regs_t *, hw_regs_t **);
1303
void ide_setup_pci_noise(struct pci_dev *, const struct ide_port_info *);
L
Linus Torvalds 已提交
1304

1305
#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
1306 1307
int ide_pci_set_master(struct pci_dev *, const char *);
unsigned long ide_pci_dma_base(ide_hwif_t *, const struct ide_port_info *);
1308
int ide_pci_check_simplex(ide_hwif_t *, const struct ide_port_info *);
1309
int ide_hwif_setup_dma(ide_hwif_t *, const struct ide_port_info *);
1310
#else
1311 1312 1313 1314 1315
static inline int ide_hwif_setup_dma(ide_hwif_t *hwif,
				     const struct ide_port_info *d)
{
	return -EINVAL;
}
1316 1317
#endif

L
Linus Torvalds 已提交
1318 1319 1320 1321 1322 1323 1324 1325
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. */
1326
	IDE_HFLAG_ISA_PORTS		= (1 << 0),
1327
	/* single port device */
1328
	IDE_HFLAG_SINGLE		= (1 << 1),
1329 1330
	/* don't use legacy PIO blacklist */
	IDE_HFLAG_PIO_NO_BLACKLIST	= (1 << 2),
1331 1332
	/* set for the second port of QD65xx */
	IDE_HFLAG_QD_2ND_PORT		= (1 << 3),
1333 1334 1335 1336 1337 1338
	/* 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),
1339 1340 1341 1342 1343
	/*
	 * 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),
1344 1345 1346 1347
	/* 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),
1348 1349
	/* trust BIOS for programming chipset/device for DMA */
	IDE_HFLAG_TRUST_BIOS_FOR_DMA	= (1 << 10),
1350 1351
	/* host is CS5510/CS5520 */
	IDE_HFLAG_CS5520		= (1 << 11),
1352 1353
	/* ATAPI DMA is unsupported */
	IDE_HFLAG_NO_ATAPI_DMA		= (1 << 12),
1354 1355
	/* set if host is a "non-bootable" controller */
	IDE_HFLAG_NON_BOOTABLE		= (1 << 13),
1356 1357 1358 1359
	/* 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),
1360 1361
	/* host uses MMIO */
	IDE_HFLAG_MMIO			= (1 << 16),
1362 1363 1364 1365
	/* no LBA48 */
	IDE_HFLAG_NO_LBA48		= (1 << 17),
	/* no LBA48 DMA */
	IDE_HFLAG_NO_LBA48_DMA		= (1 << 18),
1366 1367
	/* data FIFO is cleared by an error */
	IDE_HFLAG_ERROR_STOPS_FIFO	= (1 << 19),
1368 1369
	/* serialize ports */
	IDE_HFLAG_SERIALIZE		= (1 << 20),
1370 1371
	/* use legacy IRQs */
	IDE_HFLAG_LEGACY_IRQS		= (1 << 21),
1372 1373
	/* force use of legacy IRQs */
	IDE_HFLAG_FORCE_LEGACY_IRQS	= (1 << 22),
1374 1375
	/* host is TRM290 */
	IDE_HFLAG_TRM290		= (1 << 23),
1376 1377 1378 1379
	/* use 32-bit I/O ops */
	IDE_HFLAG_IO_32BIT		= (1 << 24),
	/* unmask IRQs */
	IDE_HFLAG_UNMASK_IRQS		= (1 << 25),
1380
	IDE_HFLAG_BROKEN_ALTSTATUS	= (1 << 26),
1381 1382
	/* serialize ports if DMA is possible (for sl82c105) */
	IDE_HFLAG_SERIALIZE_DMA		= (1 << 27),
1383 1384
	/* force host out of "simplex" mode */
	IDE_HFLAG_CLEAR_SIMPLEX		= (1 << 28),
1385 1386
	/* DSC overlap is unsupported */
	IDE_HFLAG_NO_DSC		= (1 << 29),
1387 1388 1389 1390
	/* never use 32-bit I/O ops */
	IDE_HFLAG_NO_IO_32BIT		= (1 << 30),
	/* never unmask IRQs */
	IDE_HFLAG_NO_UNMASK_IRQS	= (1 << 31),
L
Linus Torvalds 已提交
1391 1392
};

1393 1394
#ifdef CONFIG_BLK_DEV_OFFBOARD
# define IDE_HFLAG_OFF_BOARD	0
1395 1396
#else
# define IDE_HFLAG_OFF_BOARD	IDE_HFLAG_NON_BOOTABLE
1397 1398
#endif

1399
struct ide_port_info {
L
Linus Torvalds 已提交
1400
	char			*name;
1401
	unsigned int		(*init_chipset)(struct pci_dev *);
L
Linus Torvalds 已提交
1402 1403
	void			(*init_iops)(ide_hwif_t *);
	void                    (*init_hwif)(ide_hwif_t *);
1404 1405
	int			(*init_dma)(ide_hwif_t *,
					    const struct ide_port_info *);
1406

1407
	const struct ide_tp_ops		*tp_ops;
1408
	const struct ide_port_ops	*port_ops;
1409
	const struct ide_dma_ops	*dma_ops;
1410

L
Linus Torvalds 已提交
1411
	ide_pci_enablebit_t	enablebits[2];
1412
	hwif_chipset_t		chipset;
1413 1414 1415

	u16			max_sectors;	/* if < than the default one */

1416
	u32			host_flags;
1417
	u8			pio_mask;
1418 1419
	u8			swdma_mask;
	u8			mwdma_mask;
1420
	u8			udma_mask;
1421
};
L
Linus Torvalds 已提交
1422

1423 1424 1425
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 *);
1426
void ide_pci_remove(struct pci_dev *);
L
Linus Torvalds 已提交
1427

1428 1429 1430 1431 1432 1433 1434 1435
#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

L
Linus Torvalds 已提交
1436 1437 1438 1439 1440 1441
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

1442 1443 1444 1445 1446
struct drive_list_entry {
	const char *id_model;
	const char *id_firmware;
};

1447
int ide_in_drive_list(u16 *, const struct drive_list_entry *);
1448 1449

#ifdef CONFIG_BLK_DEV_IDEDMA
1450
int ide_dma_good_drive(ide_drive_t *);
L
Linus Torvalds 已提交
1451
int __ide_dma_bad_drive(ide_drive_t *);
1452
int ide_id_dma_bug(ide_drive_t *);
1453 1454 1455 1456 1457 1458 1459 1460

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);
}

1461
void ide_dma_off_quietly(ide_drive_t *);
1462
void ide_dma_off(ide_drive_t *);
1463
void ide_dma_on(ide_drive_t *);
1464
int ide_set_dma(ide_drive_t *);
1465
void ide_check_dma_crc(ide_drive_t *);
L
Linus Torvalds 已提交
1466 1467
ide_startstop_t ide_dma_intr(ide_drive_t *);

1468 1469 1470
int ide_allocate_dma_engine(ide_hwif_t *);
void ide_release_dma_engine(ide_hwif_t *);

1471 1472 1473
int ide_build_sglist(ide_drive_t *, struct request *);
void ide_destroy_dmatable(ide_drive_t *);

1474
#ifdef CONFIG_BLK_DEV_IDEDMA_SFF
1475
int config_drive_for_dma(ide_drive_t *);
L
Linus Torvalds 已提交
1476
extern int ide_build_dmatable(ide_drive_t *, struct request *);
1477
void ide_dma_host_set(ide_drive_t *, int);
L
Linus Torvalds 已提交
1478
extern int ide_dma_setup(ide_drive_t *);
1479
void ide_dma_exec_cmd(ide_drive_t *, u8);
L
Linus Torvalds 已提交
1480
extern void ide_dma_start(ide_drive_t *);
1481
int ide_dma_end(ide_drive_t *);
1482
int ide_dma_test_irq(ide_drive_t *);
1483
extern const struct ide_dma_ops sff_dma_ops;
1484 1485
#else
static inline int config_drive_for_dma(ide_drive_t *drive) { return 0; }
1486
#endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
L
Linus Torvalds 已提交
1487

1488
void ide_dma_lost_irq(ide_drive_t *);
1489
void ide_dma_timeout(ide_drive_t *);
1490

L
Linus Torvalds 已提交
1491
#else
1492
static inline int ide_id_dma_bug(ide_drive_t *drive) { return 0; }
1493
static inline u8 ide_find_dma_mode(ide_drive_t *drive, u8 speed) { return 0; }
1494
static inline u8 ide_max_dma_mode(ide_drive_t *drive) { return 0; }
1495
static inline void ide_dma_off_quietly(ide_drive_t *drive) { ; }
1496
static inline void ide_dma_off(ide_drive_t *drive) { ; }
1497
static inline void ide_dma_on(ide_drive_t *drive) { ; }
L
Linus Torvalds 已提交
1498
static inline void ide_dma_verbose(ide_drive_t *drive) { ; }
1499
static inline int ide_set_dma(ide_drive_t *drive) { return 1; }
1500
static inline void ide_check_dma_crc(ide_drive_t *drive) { ; }
1501
static inline void ide_release_dma_engine(ide_hwif_t *hwif) { ; }
1502
#endif /* CONFIG_BLK_DEV_IDEDMA */
L
Linus Torvalds 已提交
1503

1504 1505 1506 1507 1508
#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);
1509
void ide_acpi_port_init_devices(ide_hwif_t *);
1510
extern void ide_acpi_set_state(ide_hwif_t *hwif, int on);
1511 1512 1513 1514 1515
#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) { ; }
1516
static inline void ide_acpi_port_init_devices(ide_hwif_t *hwif) { ; }
1517
static inline void ide_acpi_set_state(ide_hwif_t *hwif, int on) {}
1518 1519
#endif

1520
void ide_remove_port_from_hwgroup(ide_hwif_t *);
1521
void ide_unregister(ide_hwif_t *);
L
Linus Torvalds 已提交
1522 1523 1524 1525

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

1526
void ide_undecoded_slave(ide_drive_t *);
L
Linus Torvalds 已提交
1527

1528
void ide_port_apply_params(ide_hwif_t *);
1529
int ide_sysfs_register_port(ide_hwif_t *);
1530

1531
struct ide_host *ide_host_alloc(const struct ide_port_info *, hw_regs_t **);
1532
void ide_host_free(struct ide_host *);
1533 1534
int ide_host_register(struct ide_host *, const struct ide_port_info *,
		      hw_regs_t **);
1535 1536
int ide_host_add(const struct ide_port_info *, hw_regs_t **,
		 struct ide_host **);
1537
void ide_host_remove(struct ide_host *);
1538
int ide_legacy_device_add(const struct ide_port_info *, unsigned long);
1539 1540
void ide_port_unregister_devices(ide_hwif_t *);
void ide_port_scan(ide_hwif_t *);
L
Linus Torvalds 已提交
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551

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;
}

1552
const char *ide_xfer_verbose(u8 mode);
L
Linus Torvalds 已提交
1553 1554 1555
extern void ide_toggle_bounce(ide_drive_t *drive, int on);
extern int ide_set_xfer_rate(ide_drive_t *drive, u8 rate);

1556
u64 ide_get_lba_addr(struct ide_taskfile *, int);
L
Linus Torvalds 已提交
1557 1558
u8 ide_dump_status(ide_drive_t *, const char *, u8);

1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
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,
};

1587
struct ide_timing *ide_timing_find_mode(u8);
1588
u16 ide_pio_cycle_time(ide_drive_t *, u8);
1589 1590 1591 1592
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);

1593 1594
int ide_scan_pio_blacklist(char *);

1595
u8 ide_get_best_pio_mode(ide_drive_t *, u8, u8);
L
Linus Torvalds 已提交
1596

1597 1598 1599
int ide_set_pio_mode(ide_drive_t *, u8);
int ide_set_dma_mode(ide_drive_t *, u8);

1600 1601 1602 1603 1604 1605
void ide_set_pio(ide_drive_t *, u8);

static inline void ide_set_max_pio(ide_drive_t *drive)
{
	ide_set_pio(drive, 255);
}
L
Linus Torvalds 已提交
1606 1607

extern spinlock_t ide_lock;
1608
extern struct mutex ide_cfg_mtx;
L
Linus Torvalds 已提交
1609 1610 1611
/*
 * Structure locking:
 *
1612 1613
 * ide_cfg_mtx and hwgroup->lock together protect changes to
 * ide_hwif_t->next
L
Linus Torvalds 已提交
1614 1615
 * ide_drive_t->next
 *
1616 1617 1618
 * ide_hwgroup_t->busy: hwgroup->lock
 * ide_hwgroup_t->hwif: hwgroup->lock
 * ide_hwif_t->{hwgroup,mate}: constant, no locking
L
Linus Torvalds 已提交
1619 1620 1621
 * ide_drive_t->hwif: constant, no locking
 */

1622
#define local_irq_set(flags)	do { local_save_flags((flags)); local_irq_enable_in_hardirq(); } while (0)
L
Linus Torvalds 已提交
1623

1624 1625 1626
char *ide_media_string(ide_drive_t *);

extern struct device_attribute ide_dev_attrs[];
L
Linus Torvalds 已提交
1627
extern struct bus_type ide_bus_type;
1628
extern struct class *ide_port_class;
L
Linus Torvalds 已提交
1629

1630 1631 1632 1633 1634
static inline void ide_dump_identify(u8 *id)
{
	print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 2, id, 512, 0);
}

1635 1636
static inline int hwif_to_node(ide_hwif_t *hwif)
{
1637
	return hwif->dev ? dev_to_node(hwif->dev) : -1;
1638 1639
}

1640
static inline ide_drive_t *ide_get_pair_dev(ide_drive_t *drive)
1641
{
1642
	ide_drive_t *peer = &drive->hwif->drives[(drive->dn ^ 1) & 1];
1643

1644
	return (peer->dev_flags & IDE_DFLAG_PRESENT) ? peer : NULL;
1645
}
L
Linus Torvalds 已提交
1646
#endif /* _IDE_H */
新手
引导
客服 返回
顶部