cregit-Linux how code gets into the kernel

Release 4.12 include/linux/ide.h

Directory: include/linux
#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>
#include <linux/ata.h>
#include <linux/blkdev.h>
#include <linux/proc_fs.h>
#include <linux/interrupt.h>
#include <linux/bitops.h>
#include <linux/bio.h>
#include <linux/pci.h>
#include <linux/completion.h>
#include <linux/pm.h>
#include <linux/mutex.h>
/* for request_sense */
#include <linux/cdrom.h>
#include <scsi/scsi_cmnd.h>
#include <asm/byteorder.h>
#include <asm/io.h>

#if defined(CONFIG_CRIS) || defined(CONFIG_FRV) || defined(CONFIG_MN10300)

# define SUPPORT_VLB_SYNC 0
#else

# define SUPPORT_VLB_SYNC 1
#endif

/*
 * Probably not wise to fiddle with these
 */

#define IDE_DEFAULT_MAX_FAILURES	1

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

struct device;

/* values for ide_request.type */

enum ata_priv_type {
	
ATA_PRIV_MISC,
	
ATA_PRIV_TASKFILE,
	
ATA_PRIV_PC,
	
ATA_PRIV_SENSE,		/* sense request */
	
ATA_PRIV_PM_SUSPEND,	/* suspend request */
	
ATA_PRIV_PM_RESUME,	/* resume request */
};


struct ide_request {
	
struct scsi_request sreq;
	
u8 sense[SCSI_SENSE_BUFFERSIZE];
	
u8 type;
};




static inline struct ide_request *ide_req(struct request *rq)
{
	return blk_mq_rq_to_pdu(rq);
}


Contributors
PersonTokensPropCommitsCommitProp
Christoph Hellwig20100.00%1100.00%


Total20100.00%1100.00%






static inline bool ata_misc_request(struct request *rq)
{
	return blk_rq_is_private(rq) && ide_req(rq)->type == ATA_PRIV_MISC;
}


Contributors
PersonTokensPropCommitsCommitProp
Christoph Hellwig27100.00%2100.00%


Total27100.00%2100.00%






static inline bool ata_taskfile_request(struct request *rq)
{
	return blk_rq_is_private(rq) && ide_req(rq)->type == ATA_PRIV_TASKFILE;
}


Contributors
PersonTokensPropCommitsCommitProp
Christoph Hellwig27100.00%2100.00%


Total27100.00%2100.00%






static inline bool ata_pc_request(struct request *rq)
{
	return blk_rq_is_private(rq) && ide_req(rq)->type == ATA_PRIV_PC;
}


Contributors
PersonTokensPropCommitsCommitProp
Christoph Hellwig27100.00%2100.00%


Total27100.00%2100.00%






static inline bool ata_sense_request(struct request *rq)
{
	return blk_rq_is_private(rq) && ide_req(rq)->type == ATA_PRIV_SENSE;
}


Contributors
PersonTokensPropCommitsCommitProp
Christoph Hellwig27100.00%2100.00%


Total27100.00%2100.00%






static inline bool ata_pm_request(struct request *rq)
{
	return blk_rq_is_private(rq) &&
		(ide_req(rq)->type == ATA_PRIV_PM_SUSPEND ||
		 ide_req(rq)->type == ATA_PRIV_PM_RESUME);
}


Contributors
PersonTokensPropCommitsCommitProp
Christoph Hellwig38100.00%2100.00%


Total38100.00%2100.00%



/* Error codes returned in result to the higher part of the driver. */
enum {
	
IDE_DRV_ERROR_GENERAL	= 101,
	
IDE_DRV_ERROR_FILEMARK	= 102,
	
IDE_DRV_ERROR_EOD	= 103,
};

/*
 * Definitions for accessing IDE controller registers
 */

#define IDE_NR_PORTS		(10)


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


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


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


#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

/*
 * Timeouts for various operations:
 */
enum {
	/* spec allows up to 20ms, but CF cards and SSD drives need more */
	
WAIT_DRQ	= 1 * HZ,	/* 1s */
	/* 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 */
};

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

#define REQ_DEVSET_EXEC		0x21

#define REQ_PARK_HEADS		0x22

#define REQ_UNPARK_HEADS	0x23

/*
 * hwif_chipset_t is used to keep track of the specific hardware
 * chipset used by each IDE interface, if known.
 */



enum {		ide_unknown,	ide_generic,	ide_pci,
		


ide_cmd640,	ide_dtc2278,	ide_ali14xx,
		


ide_qd65xx,	ide_umc8672,	ide_ht6560b,
		


ide_4drives,	ide_pmac,	ide_acorn,
		

ide_au1xxx,	ide_palm3710
};


typedef u8 hwif_chipset_t;

/*
 * Structure to hold all information about the location of this port
 */

struct ide_hw {
	union {
		
struct ide_io_ports	io_ports;
		
unsigned long		io_ports_array[IDE_NR_PORTS];
	};

	
int		irq;			/* our irq number */
	

struct device	*dev, *parent;
	
unsigned long	config;
};




static inline void ide_std_init_ports(struct ide_hw *hw,
				      unsigned long io_addr,
				      unsigned long ctl_addr)
{
	unsigned int i;

	for (i = 0; i <= 7; i++)
		hw->io_ports_array[i] = io_addr++;

	hw->io_ports.ctl_addr = ctl_addr;
}


Contributors
PersonTokensPropCommitsCommitProp
Bartlomiej Zolnierkiewicz55100.00%3100.00%


Total55100.00%3100.00%




#define MAX_HWIFS	10

/*
 * 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
 */
enum {
	
IDE_SFLAG_SET_GEOMETRY		= (1 << 0),
	
IDE_SFLAG_RECALIBRATE		= (1 << 1),
	
IDE_SFLAG_SET_MULTMODE		= (1 << 2),
};

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

enum {
	
IDE_VALID_ERROR 		= (1 << 1),
	
IDE_VALID_FEATURE		= IDE_VALID_ERROR,
	
IDE_VALID_NSECT 		= (1 << 2),
	
IDE_VALID_LBAL			= (1 << 3),
	
IDE_VALID_LBAM			= (1 << 4),
	
IDE_VALID_LBAH			= (1 << 5),
	
IDE_VALID_DEVICE		= (1 << 6),
	
IDE_VALID_LBA			= IDE_VALID_LBAL |
					  IDE_VALID_LBAM |
					  IDE_VALID_LBAH,
	
IDE_VALID_OUT_TF		= IDE_VALID_FEATURE |
					  IDE_VALID_NSECT |
					  IDE_VALID_LBA,
	
IDE_VALID_IN_TF 		= IDE_VALID_NSECT |
					  IDE_VALID_LBA,
	
IDE_VALID_OUT_HOB		= IDE_VALID_OUT_TF,
	
IDE_VALID_IN_HOB		= IDE_VALID_ERROR |
					  IDE_VALID_NSECT |
					  IDE_VALID_LBA,
};

enum {
	
IDE_TFLAG_LBA48			= (1 << 0),
	
IDE_TFLAG_WRITE			= (1 << 1),
	
IDE_TFLAG_CUSTOM_HANDLER	= (1 << 2),
	
IDE_TFLAG_DMA_PIO_FALLBACK	= (1 << 3),
	/* force 16-bit I/O operations */
	
IDE_TFLAG_IO_16BIT		= (1 << 4),
	/* struct ide_cmd was allocated using kmalloc() */
	
IDE_TFLAG_DYN			= (1 << 5),
	
IDE_TFLAG_FS			= (1 << 6),
	
IDE_TFLAG_MULTI_PIO		= (1 << 7),
	
IDE_TFLAG_SET_XFER		= (1 << 8),
};

enum {
	
IDE_FTFLAG_FLAGGED		= (1 << 0),
	
IDE_FTFLAG_SET_IN_FLAGS		= (1 << 1),
	
IDE_FTFLAG_OUT_DATA		= (1 << 2),
	
IDE_FTFLAG_IN_DATA		= (1 << 3),
};


struct ide_taskfile {
	
u8	data;		/* 0: data byte (for TASKFILE ioctl) */
	union {			/* 1: */
		
u8 error;	/*  read: error */
		
u8 feature;	/* write: feature */
	};
	
u8	nsect;		/* 2: number of sectors */
	
u8	lbal;		/* 3: LBA low */
	
u8	lbam;		/* 4: LBA mid */
	
u8	lbah;		/* 5: LBA high */
	
u8	device;		/* 6: device select */
	union {			/* 7: */
		
u8 status;	/*  read: status */
		
u8 command;	/* write: command */
	};
};


struct ide_cmd {
	
struct ide_taskfile	tf;
	
struct ide_taskfile	hob;
	struct {
		struct {
			
u8		tf;
			
u8		hob;
		

} out, in;
	
} valid;

	
u16			tf_flags;
	
u8			ftf_flags;	/* for TASKFILE ioctl */
	
int			protocol;

	
int			sg_nents;	  /* number of sg entries */
	
int			orig_sg_nents;
	
int			sg_dma_direction; /* DMA transfer direction */

	
unsigned int		nbytes;
	
unsigned int		nleft;
	
unsigned int		last_xfer_len;

	
struct scatterlist	*cursg;
	
unsigned int		cursg_ofs;

	
struct request		*rq;		/* copy of request */
};

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


#define ATAPI_WAIT_PC		(60 * HZ)


struct ide_atapi_pc {
	/* actual packet bytes */
	
u8 c[12];
	/* incremented on each retry */
	
int retries;
	
int error;

	/* bytes to transfer */
	
int req_xfer;

	/* 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.
         */
	
unsigned long timeout;
};

struct ide_devset;
struct ide_driver;

#ifdef CONFIG_BLK_DEV_IDEACPI
struct ide_acpi_drive_link;
struct ide_acpi_hwif_link;
#endif

struct ide_drive_s;


struct ide_disk_ops {
	
int		(*check)(struct ide_drive_s *, const char *);
	
int		(*get_capacity)(struct ide_drive_s *);
	
void		(*unlock_native_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		(*ioctl)(struct ide_drive_s *, struct block_device *,
				 fmode_t, unsigned int, unsigned long);
};

/* ATAPI device flags */
enum {
	
IDE_AFLAG_DRQ_INTERRUPT		= (1 << 0),

	/* ide-cd */
	/* Drive cannot eject the disc. */
	
IDE_AFLAG_NO_EJECT		= (1 << 1),
	/* Drive is a pre ATAPI 1.2 drive. */
	
IDE_AFLAG_PRE_ATAPI12		= (1 << 2),
	/* TOC addresses are in BCD. */
	
IDE_AFLAG_TOCADDR_AS_BCD	= (1 << 3),
	/* TOC track numbers are in BCD. */
	
IDE_AFLAG_TOCTRACKS_AS_BCD	= (1 << 4),
	/* Saved TOC information is current. */
	
IDE_AFLAG_TOC_VALID		= (1 << 6),
	/* We think that the drive door is locked. */
	
IDE_AFLAG_DOOR_LOCKED		= (1 << 7),
	/* SET_CD_SPEED command is unsupported. */
	
IDE_AFLAG_NO_SPEED_SELECT	= (1 << 8),
	
IDE_AFLAG_VERTOS_300_SSD	= (1 << 9),
	
IDE_AFLAG_VERTOS_600_ESD	= (1 << 10),
	
IDE_AFLAG_SANYO_3CD		= (1 << 11),
	
IDE_AFLAG_FULL_CAPS_PAGE	= (1 << 12),
	
IDE_AFLAG_PLAY_AUDIO_OK		= (1 << 13),
	
IDE_AFLAG_LE_SPEED_FIELDS	= (1 << 14),

	/* ide-floppy */
	/* Avoid commands not supported in Clik drive */
	
IDE_AFLAG_CLIK_DRIVE		= (1 << 15),
	/* Requires BH algorithm for packets */
	
IDE_AFLAG_ZIP_DRIVE		= (1 << 16),
	/* Supports format progress report */
	
IDE_AFLAG_SRFP			= (1 << 17),

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

	
IDE_AFLAG_NO_AUTOCLOSE		= (1 << 24),
};

/* 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),
	/* disable Host Protected Area */
	
IDE_DFLAG_NOHPA			= (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),
	/* powermanagement told us not to do anything, so sleep nicely */
	
IDE_DFLAG_BLOCKED		= (1 << 17),
	/* sleeping & sleep field valid */
	
IDE_DFLAG_SLEEPING		= (1 << 18),
	
IDE_DFLAG_POST_RESET		= (1 << 19),
	
IDE_DFLAG_UDMA33_WARNED		= (1 << 20),
	
IDE_DFLAG_LBA48			= (1 << 21),
	/* status of write cache */
	
IDE_DFLAG_WCACHE		= (1 << 22),
	/* used for ignoring ATA_DF */
	
IDE_DFLAG_NOWERR		= (1 << 23),
	/* retrying in PIO */
	
IDE_DFLAG_DMA_PIO_RETRY		= (1 << 24),
	
IDE_DFLAG_LBA			= (1 << 25),
	/* don't unload heads */
	
IDE_DFLAG_NO_UNLOAD		= (1 << 26),
	/* heads unloaded, please don't reset port */
	
IDE_DFLAG_PARKED		= (1 << 27),
	
IDE_DFLAG_MEDIA_CHANGED		= (1 << 28),
	/* write protect */
	
IDE_DFLAG_WP			= (1 << 29),
	
IDE_DFLAG_FORMAT_IN_PROGRESS	= (1 << 30),
	
IDE_DFLAG_NIEN_QUIRK		= (1 << 31),
};


struct ide_drive_s {
	
char		name[4];	/* drive name, such as "hda" */
        
char            driver_req[10];	/* requests specific driver */

	
struct request_queue	*queue;	/* request queue */

	
struct request		*rq;	/* current request */
	
void		*driver_data;	/* extra driver data */
	
u16			*id;	/* identification info */
#ifdef CONFIG_IDE_PROC_FS
	
struct proc_dir_entry *proc;	/* /proc/ide/ directory entry */
	
const struct ide_proc_devset *settings; /* /proc/ide/ drive settings */
#endif
	
struct hwif_s		*hwif;	/* actually (ide_hwif_t *) */

	
const struct ide_disk_ops *disk_ops;

	
unsigned long dev_flags;

	
unsigned long sleep;		/* sleep until this time */
	
unsigned long timeout;		/* max time to wait for irq */

	
u8	special_flags;		/* special action flags */

	
u8	select;			/* basic drive/head select reg value */
	
u8	retry_pio;		/* retrying dma capable host in pio */
	
u8	waiting_for_dma;	/* dma currently in progress */
	
u8	dma;			/* atapi dma flag */

        
u8	init_speed;	/* transfer rate set at boot */
        
u8	current_speed;	/* current transfer rate set */
	
u8	desired_speed;	/* desired transfer rate set */
	
u8	pio_mode;	/* for ->set_pio_mode _only_ */
	
u8	dma_mode;	/* for ->set_dma_mode _only_ */
	
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 */
	
u8	bad_wstat;	/* used for ignoring ATA_DF */
	
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 */

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

	
unsigned int	bios_cyl;	/* BIOS/fdisk/LILO number of cyls */
	
unsigned int	cyl;		/* "real" number of cyls */
	
void		*drive_data;	/* used by set_pio_mode/dev_select() */
	
unsigned int	failures;	/* current failure count */
	
unsigned int	max_failures;	/* maximum allowed failure count */
	
u64		probed_capacity;/* initial/native media capacity */
	
u64		capacity64;	/* total number of sectors */

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

	
unsigned long	debug_mask;	/* debugging levels switch */

#ifdef CONFIG_BLK_DEV_IDEACPI
	
struct ide_acpi_drive_link *acpidata;
#endif
	
struct list_head list;
	
struct device	gendev;
	
struct completion gendev_rel_comp;	/* to deal with device release() */

	/* current packet command */
	
struct ide_atapi_pc *pc;

	/* last failed packet command */
	
struct ide_atapi_pc *failed_pc;

	/* callback for packet commands */
	
int  (*pc_callback)(struct ide_drive_s *, int);

	
ide_startstop_t (*irq_handler)(struct ide_drive_s *);

	
unsigned long atapi_flags;

	
struct ide_atapi_pc request_sense_pc;

	/* current sense rq and buffer */
	
bool sense_rq_armed;
	
struct request *sense_rq;
	
struct request_sense sense_data;
};


typedef struct ide_drive_s ide_drive_t;


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


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

struct ide_port_info;


struct ide_tp_ops {
	
void	(*exec_command)(struct hwif_s *, u8);
	
u8	(*read_status)(struct hwif_s *);
	
u8	(*read_altstatus)(struct hwif_s *);
	
void	(*write_devctl)(struct hwif_s *, u8);

	
void	(*dev_select)(ide_drive_t *);
	
void	(*tf_load)(ide_drive_t *, struct ide_taskfile *, u8);
	
void	(*tf_read)(ide_drive_t *, struct ide_taskfile *, u8);

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

extern const struct ide_tp_ops default_tp_ops;

/**
 * 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
 * @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
 * @clear_irq:          clear IRQ
 *
 * @mdma_filter:        filter MDMA modes
 * @udma_filter:        filter UDMA modes
 *
 * @cable_detect:       detect cable type
 */

struct ide_port_ops {
	
void	(*init_dev)(ide_drive_t *);
	
void	(*set_pio_mode)(struct hwif_s *, ide_drive_t *);
	
void	(*set_dma_mode)(struct hwif_s *, 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 *);
	
void	(*clear_irq)(ide_drive_t *);
	
int	(*test_irq)(struct hwif_s *);

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

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


struct ide_dma_ops {
	
void	(*dma_host_set)(struct ide_drive_s *, int);
	
int	(*dma_setup)(struct ide_drive_s *, struct ide_cmd *);
	
void	(*dma_start)(struct ide_drive_s *);
	
int	(*dma_end)(struct ide_drive_s *);