[J-u-boot.git] / drivers / block / sata_dwc.h

/*
 * sata_dwc.h
 *
 * Synopsys DesignWare Cores (DWC) SATA host driver
 *
 * Author: Mark Miesfeld <[email protected]>
 *
 * Ported from 2.6.19.2 to 2.6.25/26 by Stefan Roese <[email protected]>
 * Copyright 2008 DENX Software Engineering
 *
 * Based on versions provided by AMCC and Synopsys which are:
 *          Copyright 2006 Applied Micro Circuits Corporation
 *          COPYRIGHT (C) 2005  SYNOPSYS, INC.  ALL RIGHTS RESERVED
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */
/*
 * SATA support based on the chip canyonlands.
 *
 * 04-17-2009
 *		The local version of this driver for the canyonlands board
 *		does not use interrupts but polls the chip instead.
 */


#ifndef _SATA_DWC_H_
#define _SATA_DWC_H_

#define __U_BOOT__

#define HZ 100
#define READ 0
#define WRITE 1

enum {
	ATA_READID_POSTRESET	= (1 << 0),

	ATA_DNXFER_PIO		= 0,
	ATA_DNXFER_DMA		= 1,
	ATA_DNXFER_40C		= 2,
	ATA_DNXFER_FORCE_PIO	= 3,
	ATA_DNXFER_FORCE_PIO0	= 4,

	ATA_DNXFER_QUIET	= (1 << 31),
};

enum hsm_task_states {
	HSM_ST_IDLE,
	HSM_ST_FIRST,
	HSM_ST,
	HSM_ST_LAST,
	HSM_ST_ERR,
};

#define	ATA_SHORT_PAUSE		((HZ >> 6) + 1)

struct ata_queued_cmd {
	struct ata_port		*ap;
	struct ata_device	*dev;

	struct ata_taskfile	tf;
	u8			cdb[ATAPI_CDB_LEN];
	unsigned long		flags;
	unsigned int		tag;
	unsigned int		n_elem;

	int			dma_dir;
	unsigned int		sect_size;

	unsigned int		nbytes;
	unsigned int		extrabytes;
	unsigned int		curbytes;

	unsigned int		err_mask;
	struct ata_taskfile	result_tf;

	void			*private_data;
#ifndef __U_BOOT__
	void			*lldd_task;
#endif
	unsigned char		*pdata;
};

typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);

#define ATA_TAG_POISON	0xfafbfcfdU

enum {
	LIBATA_MAX_PRD		= ATA_MAX_PRD / 2,
	LIBATA_DUMB_MAX_PRD	= ATA_MAX_PRD / 4,
	ATA_MAX_PORTS		= 8,
	ATA_DEF_QUEUE		= 1,
	ATA_MAX_QUEUE		= 32,
	ATA_TAG_INTERNAL	= ATA_MAX_QUEUE - 1,
	ATA_MAX_BUS		= 2,
	ATA_DEF_BUSY_WAIT	= 10000,

	ATAPI_MAX_DRAIN		= 16 << 10,

	ATA_SHT_EMULATED	= 1,
	ATA_SHT_CMD_PER_LUN	= 1,
	ATA_SHT_THIS_ID		= -1,
	ATA_SHT_USE_CLUSTERING	= 1,

	ATA_DFLAG_LBA		= (1 << 0),
	ATA_DFLAG_LBA48		= (1 << 1),
	ATA_DFLAG_CDB_INTR	= (1 << 2),
	ATA_DFLAG_NCQ		= (1 << 3),
	ATA_DFLAG_FLUSH_EXT	= (1 << 4),
	ATA_DFLAG_ACPI_PENDING 	= (1 << 5),
	ATA_DFLAG_ACPI_FAILED	= (1 << 6),
	ATA_DFLAG_AN		= (1 << 7),
	ATA_DFLAG_HIPM		= (1 << 8),
	ATA_DFLAG_DIPM		= (1 << 9),
	ATA_DFLAG_DMADIR	= (1 << 10),
	ATA_DFLAG_CFG_MASK	= (1 << 12) - 1,

	ATA_DFLAG_PIO		= (1 << 12),
	ATA_DFLAG_NCQ_OFF	= (1 << 13),
	ATA_DFLAG_SPUNDOWN	= (1 << 14),
	ATA_DFLAG_SLEEPING	= (1 << 15),
	ATA_DFLAG_DUBIOUS_XFER	= (1 << 16),
	ATA_DFLAG_INIT_MASK	= (1 << 24) - 1,

	ATA_DFLAG_DETACH	= (1 << 24),
	ATA_DFLAG_DETACHED	= (1 << 25),

	ATA_LFLAG_HRST_TO_RESUME	= (1 << 0),
	ATA_LFLAG_SKIP_D2H_BSY		= (1 << 1),
	ATA_LFLAG_NO_SRST		= (1 << 2),
	ATA_LFLAG_ASSUME_ATA		= (1 << 3),
	ATA_LFLAG_ASSUME_SEMB		= (1 << 4),
	ATA_LFLAG_ASSUME_CLASS = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
	ATA_LFLAG_NO_RETRY		= (1 << 5),
	ATA_LFLAG_DISABLED		= (1 << 6),

	ATA_FLAG_SLAVE_POSS	= (1 << 0),
	ATA_FLAG_SATA		= (1 << 1),
	ATA_FLAG_NO_LEGACY	= (1 << 2),
	ATA_FLAG_MMIO		= (1 << 3),
	ATA_FLAG_SRST		= (1 << 4),
	ATA_FLAG_SATA_RESET	= (1 << 5),
	ATA_FLAG_NO_ATAPI	= (1 << 6),
	ATA_FLAG_PIO_DMA	= (1 << 7),
	ATA_FLAG_PIO_LBA48	= (1 << 8),
	ATA_FLAG_PIO_POLLING	= (1 << 9),
	ATA_FLAG_NCQ		= (1 << 10),
	ATA_FLAG_DEBUGMSG	= (1 << 13),
	ATA_FLAG_IGN_SIMPLEX	= (1 << 15),
	ATA_FLAG_NO_IORDY	= (1 << 16),
	ATA_FLAG_ACPI_SATA	= (1 << 17),
	ATA_FLAG_AN		= (1 << 18),
	ATA_FLAG_PMP		= (1 << 19),
	ATA_FLAG_IPM		= (1 << 20),

	ATA_FLAG_DISABLED	= (1 << 23),

	ATA_PFLAG_EH_PENDING		= (1 << 0),
	ATA_PFLAG_EH_IN_PROGRESS	= (1 << 1),
	ATA_PFLAG_FROZEN		= (1 << 2),
	ATA_PFLAG_RECOVERED		= (1 << 3),
	ATA_PFLAG_LOADING		= (1 << 4),
	ATA_PFLAG_UNLOADING		= (1 << 5),
	ATA_PFLAG_SCSI_HOTPLUG		= (1 << 6),
	ATA_PFLAG_INITIALIZING		= (1 << 7),
	ATA_PFLAG_RESETTING		= (1 << 8),
	ATA_PFLAG_SUSPENDED		= (1 << 17),
	ATA_PFLAG_PM_PENDING		= (1 << 18),

	ATA_QCFLAG_ACTIVE	= (1 << 0),
	ATA_QCFLAG_DMAMAP	= (1 << 1),
	ATA_QCFLAG_IO		= (1 << 3),
	ATA_QCFLAG_RESULT_TF	= (1 << 4),
	ATA_QCFLAG_CLEAR_EXCL	= (1 << 5),
	ATA_QCFLAG_QUIET	= (1 << 6),

	ATA_QCFLAG_FAILED	= (1 << 16),
	ATA_QCFLAG_SENSE_VALID	= (1 << 17),
	ATA_QCFLAG_EH_SCHEDULED	= (1 << 18),

	ATA_HOST_SIMPLEX	= (1 << 0),
	ATA_HOST_STARTED	= (1 << 1),

	ATA_TMOUT_BOOT			= 30 * 100,
	ATA_TMOUT_BOOT_QUICK		= 7 * 100,
	ATA_TMOUT_INTERNAL		= 30 * 100,
	ATA_TMOUT_INTERNAL_QUICK	= 5 * 100,

	/* FIXME: GoVault needs 2s but we can't afford that without
	 * parallel probing.  800ms is enough for iVDR disk
	 * HHD424020F7SV00.  Increase to 2secs when parallel probing
	 * is in place.
	 */
	ATA_TMOUT_FF_WAIT	= 4 * 100 / 5,

	BUS_UNKNOWN		= 0,
	BUS_DMA			= 1,
	BUS_IDLE		= 2,
	BUS_NOINTR		= 3,
	BUS_NODATA		= 4,
	BUS_TIMER		= 5,
	BUS_PIO			= 6,
	BUS_EDD			= 7,
	BUS_IDENTIFY		= 8,
	BUS_PACKET		= 9,

	PORT_UNKNOWN		= 0,
	PORT_ENABLED		= 1,
	PORT_DISABLED		= 2,

	/* encoding various smaller bitmaps into a single
	 * unsigned long bitmap
	 */
	ATA_NR_PIO_MODES	= 7,
	ATA_NR_MWDMA_MODES	= 5,
	ATA_NR_UDMA_MODES	= 8,

	ATA_SHIFT_PIO		= 0,
	ATA_SHIFT_MWDMA		= ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
	ATA_SHIFT_UDMA		= ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,

	ATA_DMA_PAD_SZ		= 4,

	ATA_ERING_SIZE		= 32,

	ATA_DEFER_LINK		= 1,
	ATA_DEFER_PORT		= 2,

	ATA_EH_DESC_LEN		= 80,

	ATA_EH_REVALIDATE	= (1 << 0),
	ATA_EH_SOFTRESET	= (1 << 1),
	ATA_EH_HARDRESET	= (1 << 2),
	ATA_EH_ENABLE_LINK	= (1 << 3),
	ATA_EH_LPM		= (1 << 4),

	ATA_EH_RESET_MASK	= ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
	ATA_EH_PERDEV_MASK	= ATA_EH_REVALIDATE,

	ATA_EHI_HOTPLUGGED	= (1 << 0),
	ATA_EHI_RESUME_LINK	= (1 << 1),
	ATA_EHI_NO_AUTOPSY	= (1 << 2),
	ATA_EHI_QUIET		= (1 << 3),

	ATA_EHI_DID_SOFTRESET	= (1 << 16),
	ATA_EHI_DID_HARDRESET	= (1 << 17),
	ATA_EHI_PRINTINFO	= (1 << 18),
	ATA_EHI_SETMODE		= (1 << 19),
	ATA_EHI_POST_SETMODE	= (1 << 20),

	ATA_EHI_DID_RESET = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
	ATA_EHI_RESET_MODIFIER_MASK = ATA_EHI_RESUME_LINK,

	ATA_EH_MAX_TRIES	= 5,

	ATA_PROBE_MAX_TRIES	= 3,
	ATA_EH_DEV_TRIES	= 3,
	ATA_EH_PMP_TRIES	= 5,
	ATA_EH_PMP_LINK_TRIES	= 3,

	SATA_PMP_SCR_TIMEOUT	= 250,

	/* Horkage types. May be set by libata or controller on drives
	(some horkage may be drive/controller pair dependant */

	ATA_HORKAGE_DIAGNOSTIC	= (1 << 0),
	ATA_HORKAGE_NODMA	= (1 << 1),
	ATA_HORKAGE_NONCQ	= (1 << 2),
	ATA_HORKAGE_MAX_SEC_128	= (1 << 3),
	ATA_HORKAGE_BROKEN_HPA	= (1 << 4),
	ATA_HORKAGE_SKIP_PM	= (1 << 5),
	ATA_HORKAGE_HPA_SIZE	= (1 << 6),
	ATA_HORKAGE_IPM		= (1 << 7),
	ATA_HORKAGE_IVB		= (1 << 8),
	ATA_HORKAGE_STUCK_ERR	= (1 << 9),

	ATA_DMA_MASK_ATA	= (1 << 0),
	ATA_DMA_MASK_ATAPI	= (1 << 1),
	ATA_DMA_MASK_CFA	= (1 << 2),

	ATAPI_READ		= 0,
	ATAPI_WRITE		= 1,
	ATAPI_READ_CD		= 2,
	ATAPI_PASS_THRU		= 3,
	ATAPI_MISC		= 4,
};

enum ata_completion_errors {
	AC_ERR_DEV		= (1 << 0),
	AC_ERR_HSM		= (1 << 1),
	AC_ERR_TIMEOUT		= (1 << 2),
	AC_ERR_MEDIA		= (1 << 3),
	AC_ERR_ATA_BUS		= (1 << 4),
	AC_ERR_HOST_BUS		= (1 << 5),
	AC_ERR_SYSTEM		= (1 << 6),
	AC_ERR_INVALID		= (1 << 7),
	AC_ERR_OTHER		= (1 << 8),
	AC_ERR_NODEV_HINT	= (1 << 9),
	AC_ERR_NCQ		= (1 << 10),
};

enum ata_xfer_mask {
	ATA_MASK_PIO	= ((1LU << ATA_NR_PIO_MODES) - 1) << ATA_SHIFT_PIO,
	ATA_MASK_MWDMA	= ((1LU << ATA_NR_MWDMA_MODES) - 1) << ATA_SHIFT_MWDMA,
	ATA_MASK_UDMA	= ((1LU << ATA_NR_UDMA_MODES) - 1) << ATA_SHIFT_UDMA,
};

struct ata_port_info {
#ifndef __U_BOOT__
	struct scsi_host_template	*sht;
#endif
	unsigned long			flags;
	unsigned long			link_flags;
	unsigned long			pio_mask;
	unsigned long			mwdma_mask;
	unsigned long			udma_mask;
#ifndef __U_BOOT__
	const struct ata_port_operations *port_ops;
	void				*private_data;
#endif
};

struct ata_ioports {
	void __iomem		*cmd_addr;
	void __iomem		*data_addr;
	void __iomem		*error_addr;
	void __iomem		*feature_addr;
	void __iomem		*nsect_addr;
	void __iomem		*lbal_addr;
	void __iomem		*lbam_addr;
	void __iomem		*lbah_addr;
	void __iomem		*device_addr;
	void __iomem		*status_addr;
	void __iomem		*command_addr;
	void __iomem		*altstatus_addr;
	void __iomem		*ctl_addr;
#ifndef __U_BOOT__
	void __iomem		*bmdma_addr;
#endif
	void __iomem		*scr_addr;
};

struct ata_host {
#ifndef __U_BOOT__
	void __iomem * const	*iomap;
	void			*private_data;
	const struct ata_port_operations *ops;
	unsigned long		flags;
	struct ata_port		*simplex_claimed;
#endif
	unsigned int		n_ports;
	struct ata_port		*ports[0];
};

#ifndef __U_BOOT__
struct ata_port_stats {
	unsigned long		unhandled_irq;
	unsigned long		idle_irq;
	unsigned long		rw_reqbuf;
};
#endif

struct ata_device {
	struct ata_link		*link;
	unsigned int		devno;
	unsigned long		flags;
	unsigned int		horkage;
#ifndef __U_BOOT__
	struct scsi_device	*sdev;
#ifdef CONFIG_ATA_ACPI
	acpi_handle		acpi_handle;
	union acpi_object	*gtf_cache;
#endif
#endif
	u64			n_sectors;
	unsigned int		class;

	union {
		u16		id[ATA_ID_WORDS];
		u32		gscr[SATA_PMP_GSCR_DWORDS];
	};
#ifndef __U_BOOT__
	u8			pio_mode;
	u8			dma_mode;
	u8			xfer_mode;
	unsigned int		xfer_shift;
#endif
	unsigned int		multi_count;
	unsigned int		max_sectors;
	unsigned int		cdb_len;
#ifndef __U_BOOT__
	unsigned long		pio_mask;
	unsigned long		mwdma_mask;
#endif
	unsigned long		udma_mask;
	u16			cylinders;
	u16			heads;
	u16			sectors;
#ifndef __U_BOOT__
	int			spdn_cnt;
#endif
};

enum dma_data_direction {
	DMA_BIDIRECTIONAL = 0,
	DMA_TO_DEVICE = 1,
	DMA_FROM_DEVICE = 2,
	DMA_NONE = 3,
};

struct ata_link {
	struct ata_port		*ap;
	int			pmp;
	unsigned int		active_tag;
	u32			sactive;
	unsigned int		flags;
	unsigned int		hw_sata_spd_limit;
#ifndef __U_BOOT__
	unsigned int		sata_spd_limit;
	unsigned int		sata_spd;
	struct ata_device	device[2];
#endif
};

struct ata_port {
	unsigned long		flags;
	unsigned int		pflags;
	unsigned int		print_id;
	unsigned int		port_no;

	struct ata_ioports	ioaddr;

	u8			ctl;
	u8			last_ctl;
	unsigned int		pio_mask;
	unsigned int		mwdma_mask;
	unsigned int		udma_mask;
	unsigned int		cbl;

	struct ata_queued_cmd	qcmd[ATA_MAX_QUEUE];
	unsigned long		qc_allocated;
	unsigned int		qc_active;
	int			nr_active_links;

	struct ata_link		link;
#ifndef __U_BOOT__
	int			nr_pmp_links;
	struct ata_link		*pmp_link;
#endif
	struct ata_link		*excl_link;
	int			nr_pmp_links;
#ifndef __U_BOOT__
	struct ata_port_stats	stats;
	struct device		*dev;
	u32			msg_enable;
#endif
	struct ata_host		*host;
	void			*port_task_data;

	unsigned int		hsm_task_state;
	void			*private_data;
	unsigned char		*pdata;
};

#endif
Commit	Line	Data
e405afab KI	1	/*
	2	* sata_dwc.h
	3	*
	4	* Synopsys DesignWare Cores (DWC) SATA host driver
	5	*
	6	* Author: Mark Miesfeld <[email protected]>
	7	*
	8	* Ported from 2.6.19.2 to 2.6.25/26 by Stefan Roese <[email protected]>
	9	* Copyright 2008 DENX Software Engineering
	10	*
	11	* Based on versions provided by AMCC and Synopsys which are:
	12	* Copyright 2006 Applied Micro Circuits Corporation
	13	* COPYRIGHT (C) 2005 SYNOPSYS, INC. ALL RIGHTS RESERVED
	14	*
1a459660	15	* SPDX-License-Identifier: GPL-2.0+
e405afab KI	16	*/
	17	/*
	18	* SATA support based on the chip canyonlands.
	19	*
	20	* 04-17-2009
	21	* The local version of this driver for the canyonlands board
	22	* does not use interrupts but polls the chip instead.
	23	*/
	24
	25
	26	#ifndef _SATA_DWC_H_
	27	#define _SATA_DWC_H_
	28
	29	#define __U_BOOT__
	30
	31	#define HZ 100
	32	#define READ 0
	33	#define WRITE 1
	34
	35	enum {
	36	ATA_READID_POSTRESET = (1 << 0),
	37
	38	ATA_DNXFER_PIO = 0,
	39	ATA_DNXFER_DMA = 1,
	40	ATA_DNXFER_40C = 2,
	41	ATA_DNXFER_FORCE_PIO = 3,
	42	ATA_DNXFER_FORCE_PIO0 = 4,
	43
	44	ATA_DNXFER_QUIET = (1 << 31),
	45	};
	46
	47	enum hsm_task_states {
	48	HSM_ST_IDLE,
	49	HSM_ST_FIRST,
	50	HSM_ST,
	51	HSM_ST_LAST,
	52	HSM_ST_ERR,
	53	};
	54
	55	#define ATA_SHORT_PAUSE ((HZ >> 6) + 1)
	56
	57	struct ata_queued_cmd {
	58	struct ata_port *ap;
	59	struct ata_device *dev;
	60
	61	struct ata_taskfile tf;
	62	u8 cdb[ATAPI_CDB_LEN];
	63	unsigned long flags;
	64	unsigned int tag;
	65	unsigned int n_elem;
	66
	67	int dma_dir;
	68	unsigned int sect_size;
	69
	70	unsigned int nbytes;
	71	unsigned int extrabytes;
	72	unsigned int curbytes;
	73
	74	unsigned int err_mask;
	75	struct ata_taskfile result_tf;
	76
	77	void *private_data;
	78	#ifndef __U_BOOT__
	79	void *lldd_task;
80	#endif
81	unsigned char *pdata;
82	};
83
84	typedef void (ata_qc_cb_t) (struct ata_queued_cmd qc);
85
86	#define ATA_TAG_POISON 0xfafbfcfdU
87
88	enum {
89	LIBATA_MAX_PRD = ATA_MAX_PRD / 2,
90	LIBATA_DUMB_MAX_PRD = ATA_MAX_PRD / 4,
91	ATA_MAX_PORTS = 8,
92	ATA_DEF_QUEUE = 1,
93	ATA_MAX_QUEUE = 32,
94	ATA_TAG_INTERNAL = ATA_MAX_QUEUE - 1,
95	ATA_MAX_BUS = 2,
96	ATA_DEF_BUSY_WAIT = 10000,
97
98	ATAPI_MAX_DRAIN = 16 << 10,
99
100	ATA_SHT_EMULATED = 1,
101	ATA_SHT_CMD_PER_LUN = 1,
102	ATA_SHT_THIS_ID = -1,
103	ATA_SHT_USE_CLUSTERING = 1,
104
105	ATA_DFLAG_LBA = (1 << 0),
106	ATA_DFLAG_LBA48 = (1 << 1),
107	ATA_DFLAG_CDB_INTR = (1 << 2),
108	ATA_DFLAG_NCQ = (1 << 3),
109	ATA_DFLAG_FLUSH_EXT = (1 << 4),
110	ATA_DFLAG_ACPI_PENDING = (1 << 5),
111	ATA_DFLAG_ACPI_FAILED = (1 << 6),
112	ATA_DFLAG_AN = (1 << 7),
113	ATA_DFLAG_HIPM = (1 << 8),
114	ATA_DFLAG_DIPM = (1 << 9),
115	ATA_DFLAG_DMADIR = (1 << 10),
116	ATA_DFLAG_CFG_MASK = (1 << 12) - 1,
117
118	ATA_DFLAG_PIO = (1 << 12),
119	ATA_DFLAG_NCQ_OFF = (1 << 13),
120	ATA_DFLAG_SPUNDOWN = (1 << 14),
121	ATA_DFLAG_SLEEPING = (1 << 15),
122	ATA_DFLAG_DUBIOUS_XFER = (1 << 16),
123	ATA_DFLAG_INIT_MASK = (1 << 24) - 1,
124
125	ATA_DFLAG_DETACH = (1 << 24),
126	ATA_DFLAG_DETACHED = (1 << 25),
127
128	ATA_LFLAG_HRST_TO_RESUME = (1 << 0),
129	ATA_LFLAG_SKIP_D2H_BSY = (1 << 1),
130	ATA_LFLAG_NO_SRST = (1 << 2),
131	ATA_LFLAG_ASSUME_ATA = (1 << 3),
132	ATA_LFLAG_ASSUME_SEMB = (1 << 4),
133	ATA_LFLAG_ASSUME_CLASS = ATA_LFLAG_ASSUME_ATA \| ATA_LFLAG_ASSUME_SEMB,
134	ATA_LFLAG_NO_RETRY = (1 << 5),
135	ATA_LFLAG_DISABLED = (1 << 6),
136
137	ATA_FLAG_SLAVE_POSS = (1 << 0),
138	ATA_FLAG_SATA = (1 << 1),
139	ATA_FLAG_NO_LEGACY = (1 << 2),
140	ATA_FLAG_MMIO = (1 << 3),
141	ATA_FLAG_SRST = (1 << 4),
142	ATA_FLAG_SATA_RESET = (1 << 5),
143	ATA_FLAG_NO_ATAPI = (1 << 6),
144	ATA_FLAG_PIO_DMA = (1 << 7),
145	ATA_FLAG_PIO_LBA48 = (1 << 8),
146	ATA_FLAG_PIO_POLLING = (1 << 9),
147	ATA_FLAG_NCQ = (1 << 10),
148	ATA_FLAG_DEBUGMSG = (1 << 13),
149	ATA_FLAG_IGN_SIMPLEX = (1 << 15),
150	ATA_FLAG_NO_IORDY = (1 << 16),
151	ATA_FLAG_ACPI_SATA = (1 << 17),
152	ATA_FLAG_AN = (1 << 18),
153	ATA_FLAG_PMP = (1 << 19),
154	ATA_FLAG_IPM = (1 << 20),
155
156	ATA_FLAG_DISABLED = (1 << 23),
157
158	ATA_PFLAG_EH_PENDING = (1 << 0),
159	ATA_PFLAG_EH_IN_PROGRESS = (1 << 1),
160	ATA_PFLAG_FROZEN = (1 << 2),
161	ATA_PFLAG_RECOVERED = (1 << 3),
162	ATA_PFLAG_LOADING = (1 << 4),
163	ATA_PFLAG_UNLOADING = (1 << 5),
164	ATA_PFLAG_SCSI_HOTPLUG = (1 << 6),
165	ATA_PFLAG_INITIALIZING = (1 << 7),
166	ATA_PFLAG_RESETTING = (1 << 8),
167	ATA_PFLAG_SUSPENDED = (1 << 17),
168	ATA_PFLAG_PM_PENDING = (1 << 18),
169
170	ATA_QCFLAG_ACTIVE = (1 << 0),
171	ATA_QCFLAG_DMAMAP = (1 << 1),
172	ATA_QCFLAG_IO = (1 << 3),
173	ATA_QCFLAG_RESULT_TF = (1 << 4),
174	ATA_QCFLAG_CLEAR_EXCL = (1 << 5),
175	ATA_QCFLAG_QUIET = (1 << 6),
176
177	ATA_QCFLAG_FAILED = (1 << 16),
178	ATA_QCFLAG_SENSE_VALID = (1 << 17),
179	ATA_QCFLAG_EH_SCHEDULED = (1 << 18),
180
181	ATA_HOST_SIMPLEX = (1 << 0),
182	ATA_HOST_STARTED = (1 << 1),
183
184	ATA_TMOUT_BOOT = 30 * 100,
185	ATA_TMOUT_BOOT_QUICK = 7 * 100,
186	ATA_TMOUT_INTERNAL = 30 * 100,
187	ATA_TMOUT_INTERNAL_QUICK = 5 * 100,
188
189	/* FIXME: GoVault needs 2s but we can't afford that without
190	* parallel probing. 800ms is enough for iVDR disk
191	* HHD424020F7SV00. Increase to 2secs when parallel probing
192	* is in place.
193	*/
194	ATA_TMOUT_FF_WAIT = 4 * 100 / 5,
195
196	BUS_UNKNOWN = 0,
197	BUS_DMA = 1,
198	BUS_IDLE = 2,
199	BUS_NOINTR = 3,
200	BUS_NODATA = 4,
201	BUS_TIMER = 5,
202	BUS_PIO = 6,
203	BUS_EDD = 7,
204	BUS_IDENTIFY = 8,
205	BUS_PACKET = 9,
206
207	PORT_UNKNOWN = 0,
208	PORT_ENABLED = 1,
209	PORT_DISABLED = 2,
210
211	/* encoding various smaller bitmaps into a single
212	* unsigned long bitmap
213	*/
214	ATA_NR_PIO_MODES = 7,
215	ATA_NR_MWDMA_MODES = 5,
216	ATA_NR_UDMA_MODES = 8,
217
218	ATA_SHIFT_PIO = 0,
219	ATA_SHIFT_MWDMA = ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
220	ATA_SHIFT_UDMA = ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,
221
222	ATA_DMA_PAD_SZ = 4,
223
224	ATA_ERING_SIZE = 32,
225
226	ATA_DEFER_LINK = 1,
227	ATA_DEFER_PORT = 2,
228
229	ATA_EH_DESC_LEN = 80,
230
231	ATA_EH_REVALIDATE = (1 << 0),
232	ATA_EH_SOFTRESET = (1 << 1),
233	ATA_EH_HARDRESET = (1 << 2),
234	ATA_EH_ENABLE_LINK = (1 << 3),
235	ATA_EH_LPM = (1 << 4),
236
237	ATA_EH_RESET_MASK = ATA_EH_SOFTRESET \| ATA_EH_HARDRESET,
238	ATA_EH_PERDEV_MASK = ATA_EH_REVALIDATE,
239
240	ATA_EHI_HOTPLUGGED = (1 << 0),
241	ATA_EHI_RESUME_LINK = (1 << 1),
242	ATA_EHI_NO_AUTOPSY = (1 << 2),
243	ATA_EHI_QUIET = (1 << 3),
244
245	ATA_EHI_DID_SOFTRESET = (1 << 16),
246	ATA_EHI_DID_HARDRESET = (1 << 17),
247	ATA_EHI_PRINTINFO = (1 << 18),
248	ATA_EHI_SETMODE = (1 << 19),
249	ATA_EHI_POST_SETMODE = (1 << 20),
250
251	ATA_EHI_DID_RESET = ATA_EHI_DID_SOFTRESET \| ATA_EHI_DID_HARDRESET,
252	ATA_EHI_RESET_MODIFIER_MASK = ATA_EHI_RESUME_LINK,
253
254	ATA_EH_MAX_TRIES = 5,
255
256	ATA_PROBE_MAX_TRIES = 3,
257	ATA_EH_DEV_TRIES = 3,
258	ATA_EH_PMP_TRIES = 5,
259	ATA_EH_PMP_LINK_TRIES = 3,
260
261	SATA_PMP_SCR_TIMEOUT = 250,
262
263	/* Horkage types. May be set by libata or controller on drives
264	(some horkage may be drive/controller pair dependant */
265
266	ATA_HORKAGE_DIAGNOSTIC = (1 << 0),
267	ATA_HORKAGE_NODMA = (1 << 1),
268	ATA_HORKAGE_NONCQ = (1 << 2),
269	ATA_HORKAGE_MAX_SEC_128 = (1 << 3),
270	ATA_HORKAGE_BROKEN_HPA = (1 << 4),
271	ATA_HORKAGE_SKIP_PM = (1 << 5),
272	ATA_HORKAGE_HPA_SIZE = (1 << 6),
273	ATA_HORKAGE_IPM = (1 << 7),
274	ATA_HORKAGE_IVB = (1 << 8),
275	ATA_HORKAGE_STUCK_ERR = (1 << 9),
276
277	ATA_DMA_MASK_ATA = (1 << 0),
278	ATA_DMA_MASK_ATAPI = (1 << 1),
279	ATA_DMA_MASK_CFA = (1 << 2),
280
281	ATAPI_READ = 0,
282	ATAPI_WRITE = 1,
283	ATAPI_READ_CD = 2,
284	ATAPI_PASS_THRU = 3,
285	ATAPI_MISC = 4,
286	};
287
288	enum ata_completion_errors {
289	AC_ERR_DEV = (1 << 0),
290	AC_ERR_HSM = (1 << 1),
291	AC_ERR_TIMEOUT = (1 << 2),
292	AC_ERR_MEDIA = (1 << 3),
293	AC_ERR_ATA_BUS = (1 << 4),
294	AC_ERR_HOST_BUS = (1 << 5),
295	AC_ERR_SYSTEM = (1 << 6),
296	AC_ERR_INVALID = (1 << 7),
297	AC_ERR_OTHER = (1 << 8),
298	AC_ERR_NODEV_HINT = (1 << 9),
299	AC_ERR_NCQ = (1 << 10),
300	};
301
302	enum ata_xfer_mask {
303	ATA_MASK_PIO = ((1LU << ATA_NR_PIO_MODES) - 1) << ATA_SHIFT_PIO,
304	ATA_MASK_MWDMA = ((1LU << ATA_NR_MWDMA_MODES) - 1) << ATA_SHIFT_MWDMA,
305	ATA_MASK_UDMA = ((1LU << ATA_NR_UDMA_MODES) - 1) << ATA_SHIFT_UDMA,
306	};
307
308	struct ata_port_info {
309	#ifndef __U_BOOT__
310	struct scsi_host_template *sht;
311	#endif
312	unsigned long flags;
313	unsigned long link_flags;
314	unsigned long pio_mask;
315	unsigned long mwdma_mask;
316	unsigned long udma_mask;
317	#ifndef __U_BOOT__
318	const struct ata_port_operations *port_ops;
319	void *private_data;
320	#endif
321	};
322
323	struct ata_ioports {
324	void __iomem *cmd_addr;
325	void __iomem *data_addr;
326	void __iomem *error_addr;
327	void __iomem *feature_addr;
328	void __iomem *nsect_addr;
329	void __iomem *lbal_addr;
330	void __iomem *lbam_addr;
331	void __iomem *lbah_addr;
332	void __iomem *device_addr;
333	void __iomem *status_addr;
334	void __iomem *command_addr;
335	void __iomem *altstatus_addr;
336	void __iomem *ctl_addr;
337	#ifndef __U_BOOT__
338	void __iomem *bmdma_addr;
339	#endif
340	void __iomem *scr_addr;
341	};
342
343	struct ata_host {
344	#ifndef __U_BOOT__
345	void __iomem * const *iomap;
346	void *private_data;
347	const struct ata_port_operations *ops;
348	unsigned long flags;
349	struct ata_port *simplex_claimed;
350	#endif
351	unsigned int n_ports;
352	struct ata_port *ports[0];
353	};
354
355	#ifndef __U_BOOT__
356	struct ata_port_stats {
357	unsigned long unhandled_irq;
358	unsigned long idle_irq;
359	unsigned long rw_reqbuf;
360	};
361	#endif
362
363	struct ata_device {
364	struct ata_link *link;
365	unsigned int devno;
366	unsigned long flags;
367	unsigned int horkage;
368	#ifndef __U_BOOT__
369	struct scsi_device *sdev;
370	#ifdef CONFIG_ATA_ACPI
371	acpi_handle acpi_handle;
372	union acpi_object *gtf_cache;
373	#endif
374	#endif
375	u64 n_sectors;
376	unsigned int class;
377
378	union {
379	u16 id[ATA_ID_WORDS];
380	u32 gscr[SATA_PMP_GSCR_DWORDS];
381	};
382	#ifndef __U_BOOT__
383	u8 pio_mode;
384	u8 dma_mode;
385	u8 xfer_mode;
386	unsigned int xfer_shift;
387	#endif
388	unsigned int multi_count;
389	unsigned int max_sectors;
390	unsigned int cdb_len;
391	#ifndef __U_BOOT__
392	unsigned long pio_mask;
393	unsigned long mwdma_mask;
394	#endif
395	unsigned long udma_mask;
396	u16 cylinders;
397	u16 heads;
398	u16 sectors;
399	#ifndef __U_BOOT__
400	int spdn_cnt;
401	#endif
402	};
403
404	enum dma_data_direction {
405	DMA_BIDIRECTIONAL = 0,
406	DMA_TO_DEVICE = 1,
407	DMA_FROM_DEVICE = 2,
408	DMA_NONE = 3,
409	};
410
411	struct ata_link {
412	struct ata_port *ap;
413	int pmp;
414	unsigned int active_tag;
415	u32 sactive;
416	unsigned int flags;
417	unsigned int hw_sata_spd_limit;
418	#ifndef __U_BOOT__
419	unsigned int sata_spd_limit;
420	unsigned int sata_spd;
421	struct ata_device device[2];
422	#endif
423	};
424
425	struct ata_port {
426	unsigned long flags;
427	unsigned int pflags;
428	unsigned int print_id;
429	unsigned int port_no;
430
431	struct ata_ioports ioaddr;
432
433	u8 ctl;
434	u8 last_ctl;
435	unsigned int pio_mask;
436	unsigned int mwdma_mask;
437	unsigned int udma_mask;
438	unsigned int cbl;
439
440	struct ata_queued_cmd qcmd[ATA_MAX_QUEUE];
441	unsigned long qc_allocated;
442	unsigned int qc_active;
443	int nr_active_links;
444
445	struct ata_link link;
446	#ifndef __U_BOOT__
447	int nr_pmp_links;
448	struct ata_link *pmp_link;
449	#endif
450	struct ata_link *excl_link;
451	int nr_pmp_links;
452	#ifndef __U_BOOT__
453	struct ata_port_stats stats;
454	struct device *dev;
455	u32 msg_enable;
456	#endif
457	struct ata_host *host;
458	void *port_task_data;
459
460	unsigned int hsm_task_state;
461	void *private_data;
462	unsigned char *pdata;
463	};
464
e405afab	465	#endif