cregit-Linux how code gets into the kernel

Release 4.12 include/linux/libata.h

Directory: include/linux
/*
 *  Copyright 2003-2005 Red Hat, Inc.  All rights reserved.
 *  Copyright 2003-2005 Jeff Garzik
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *
 *  libata documentation is available via 'make {ps|pdf}docs',
 *  as Documentation/DocBook/libata.*
 *
 */

#ifndef __LINUX_LIBATA_H__

#define __LINUX_LIBATA_H__

#include <linux/delay.h>
#include <linux/jiffies.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/scatterlist.h>
#include <linux/io.h>
#include <linux/ata.h>
#include <linux/workqueue.h>
#include <scsi/scsi_host.h>
#include <linux/acpi.h>
#include <linux/cdrom.h>
#include <linux/sched.h>

/*
 * Define if arch has non-standard setup.  This is a _PCI_ standard
 * not a legacy or ISA standard.
 */
#ifdef CONFIG_ATA_NONSTANDARD
#include <asm/libata-portmap.h>
#else

#define ATA_PRIMARY_IRQ(dev)	14

#define ATA_SECONDARY_IRQ(dev)	15
#endif

/*
 * compile-time options: to be removed as soon as all the drivers are
 * converted to the new debugging mechanism
 */

#undef ATA_DEBUG		
/* debugging output */

#undef ATA_VERBOSE_DEBUG	
/* yet more debugging output */

#undef ATA_IRQ_TRAP		
/* define to ack screaming irqs */

#undef ATA_NDEBUG		
/* define to disable quick runtime checks */


/* note: prints function name for you */
#ifdef ATA_DEBUG

#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
#ifdef ATA_VERBOSE_DEBUG

#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
#else

#define VPRINTK(fmt, args...)
#endif	/* ATA_VERBOSE_DEBUG */
#else

#define DPRINTK(fmt, args...)

#define VPRINTK(fmt, args...)
#endif	/* ATA_DEBUG */


#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args)


#define ata_print_version_once(dev, version)			\
({                                                              \
        static bool __print_once;                               \
                                                                \
        if (!__print_once) {                                    \
                __print_once = true;                            \
                ata_print_version(dev, version);                \
        }                                                       \
})

/* NEW: debug levels */

#define HAVE_LIBATA_MSG 1

enum {
	
ATA_MSG_DRV	= 0x0001,
	
ATA_MSG_INFO	= 0x0002,
	
ATA_MSG_PROBE	= 0x0004,
	
ATA_MSG_WARN	= 0x0008,
	
ATA_MSG_MALLOC	= 0x0010,
	
ATA_MSG_CTL	= 0x0020,
	
ATA_MSG_INTR	= 0x0040,
	
ATA_MSG_ERR	= 0x0080,
};


#define ata_msg_drv(p)    ((p)->msg_enable & ATA_MSG_DRV)

#define ata_msg_info(p)   ((p)->msg_enable & ATA_MSG_INFO)

#define ata_msg_probe(p)  ((p)->msg_enable & ATA_MSG_PROBE)

#define ata_msg_warn(p)   ((p)->msg_enable & ATA_MSG_WARN)

#define ata_msg_malloc(p) ((p)->msg_enable & ATA_MSG_MALLOC)

#define ata_msg_ctl(p)    ((p)->msg_enable & ATA_MSG_CTL)

#define ata_msg_intr(p)   ((p)->msg_enable & ATA_MSG_INTR)

#define ata_msg_err(p)    ((p)->msg_enable & ATA_MSG_ERR)




static inline u32 ata_msg_init(int dval, int default_msg_enable_bits)
{
	if (dval < 0 || dval >= (sizeof(u32) * 8))
		return default_msg_enable_bits; /* should be 0x1 - only driver info msgs */
	if (!dval)
		return 0;
	return (1 << dval) - 1;
}


Contributors
PersonTokensPropCommitsCommitProp
Randy Dunlap51100.00%1100.00%


Total51100.00%1100.00%



/* defines only for the constants which don't work well as enums */

#define ATA_TAG_POISON		0xfafbfcfdU

enum {
	/* various global constants */
	
LIBATA_MAX_PRD		= ATA_MAX_PRD / 2,
	
LIBATA_DUMB_MAX_PRD	= ATA_MAX_PRD / 4,	/* Worst case */
	
ATA_DEF_QUEUE		= 1,
	/* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
	
ATA_MAX_QUEUE		= 32,
	
ATA_TAG_INTERNAL	= ATA_MAX_QUEUE - 1,
	
ATA_SHORT_PAUSE		= 16,

	
ATAPI_MAX_DRAIN		= 16 << 10,

	
ATA_ALL_DEVICES		= (1 << ATA_MAX_DEVICES) - 1,

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

	/* struct ata_taskfile flags */
	
ATA_TFLAG_LBA48		= (1 << 0), /* enable 48-bit LBA and "HOB" */
	
ATA_TFLAG_ISADDR	= (1 << 1), /* enable r/w to nsect/lba regs */
	
ATA_TFLAG_DEVICE	= (1 << 2), /* enable r/w to device reg */
	
ATA_TFLAG_WRITE		= (1 << 3), /* data dir: host->dev==1 (write) */
	
ATA_TFLAG_LBA		= (1 << 4), /* enable LBA */
	
ATA_TFLAG_FUA		= (1 << 5), /* enable FUA */
	
ATA_TFLAG_POLLING	= (1 << 6), /* set nIEN to 1 and use polling */

	/* struct ata_device stuff */
	
ATA_DFLAG_LBA		= (1 << 0), /* device supports LBA */
	
ATA_DFLAG_LBA48		= (1 << 1), /* device supports LBA48 */
	
ATA_DFLAG_CDB_INTR	= (1 << 2), /* device asserts INTRQ when ready for CDB */
	
ATA_DFLAG_NCQ		= (1 << 3), /* device supports NCQ */
	
ATA_DFLAG_FLUSH_EXT	= (1 << 4), /* do FLUSH_EXT instead of FLUSH */
	
ATA_DFLAG_ACPI_PENDING	= (1 << 5), /* ACPI resume action pending */
	
ATA_DFLAG_ACPI_FAILED	= (1 << 6), /* ACPI on devcfg has failed */
	
ATA_DFLAG_AN		= (1 << 7), /* AN configured */
	
ATA_DFLAG_DMADIR	= (1 << 10), /* device requires DMADIR */
	
ATA_DFLAG_CFG_MASK	= (1 << 12) - 1,

	
ATA_DFLAG_PIO		= (1 << 12), /* device limited to PIO mode */
	
ATA_DFLAG_NCQ_OFF	= (1 << 13), /* device limited to non-NCQ mode */
	
ATA_DFLAG_SLEEPING	= (1 << 15), /* device is sleeping */
	
ATA_DFLAG_DUBIOUS_XFER	= (1 << 16), /* data transfer not verified */
	
ATA_DFLAG_NO_UNLOAD	= (1 << 17), /* device doesn't support unload */
	
ATA_DFLAG_UNLOCK_HPA	= (1 << 18), /* unlock HPA */
	
ATA_DFLAG_NCQ_SEND_RECV = (1 << 19), /* device supports NCQ SEND and RECV */
	
ATA_DFLAG_NCQ_PRIO	= (1 << 20), /* device supports NCQ priority */
	
ATA_DFLAG_NCQ_PRIO_ENABLE = (1 << 21), /* Priority cmds sent to dev */
	
ATA_DFLAG_INIT_MASK	= (1 << 24) - 1,

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

	
ATA_DFLAG_DA		= (1 << 26), /* device supports Device Attention */
	
ATA_DFLAG_DEVSLP	= (1 << 27), /* device supports Device Sleep */
	
ATA_DFLAG_ACPI_DISABLED = (1 << 28), /* ACPI for the device is disabled */
	
ATA_DFLAG_D_SENSE	= (1 << 29), /* Descriptor sense requested */
	
ATA_DFLAG_ZAC		= (1 << 30), /* ZAC device */

	
ATA_DEV_UNKNOWN		= 0,	/* unknown device */
	
ATA_DEV_ATA		= 1,	/* ATA device */
	
ATA_DEV_ATA_UNSUP	= 2,	/* ATA device (unsupported) */
	
ATA_DEV_ATAPI		= 3,	/* ATAPI device */
	
ATA_DEV_ATAPI_UNSUP	= 4,	/* ATAPI device (unsupported) */
	
ATA_DEV_PMP		= 5,	/* SATA port multiplier */
	
ATA_DEV_PMP_UNSUP	= 6,	/* SATA port multiplier (unsupported) */
	
ATA_DEV_SEMB		= 7,	/* SEMB */
	
ATA_DEV_SEMB_UNSUP	= 8,	/* SEMB (unsupported) */
	
ATA_DEV_ZAC		= 9,	/* ZAC device */
	
ATA_DEV_ZAC_UNSUP	= 10,	/* ZAC device (unsupported) */
	
ATA_DEV_NONE		= 11,	/* no device */

	/* struct ata_link flags */
	
ATA_LFLAG_NO_HRST	= (1 << 1), /* avoid hardreset */
	
ATA_LFLAG_NO_SRST	= (1 << 2), /* avoid softreset */
	
ATA_LFLAG_ASSUME_ATA	= (1 << 3), /* assume ATA class */
	
ATA_LFLAG_ASSUME_SEMB	= (1 << 4), /* assume SEMB class */
	
ATA_LFLAG_ASSUME_CLASS	= ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
	
ATA_LFLAG_NO_RETRY	= (1 << 5), /* don't retry this link */
	
ATA_LFLAG_DISABLED	= (1 << 6), /* link is disabled */
	
ATA_LFLAG_SW_ACTIVITY	= (1 << 7), /* keep activity stats */
	
ATA_LFLAG_NO_LPM	= (1 << 8), /* disable LPM on this link */
	
ATA_LFLAG_RST_ONCE	= (1 << 9), /* limit recovery to one reset */
	
ATA_LFLAG_CHANGED	= (1 << 10), /* LPM state changed on this link */
	
ATA_LFLAG_NO_DB_DELAY	= (1 << 11), /* no debounce delay on link resume */

	/* struct ata_port flags */
	
ATA_FLAG_SLAVE_POSS	= (1 << 0), /* host supports slave dev */
					    /* (doesn't imply presence) */
	
ATA_FLAG_SATA		= (1 << 1),
	
ATA_FLAG_NO_LOG_PAGE	= (1 << 5), /* do not issue log page read */
	
ATA_FLAG_NO_ATAPI	= (1 << 6), /* No ATAPI support */
	
ATA_FLAG_PIO_DMA	= (1 << 7), /* PIO cmds via DMA */
	
ATA_FLAG_PIO_LBA48	= (1 << 8), /* Host DMA engine is LBA28 only */
	
ATA_FLAG_PIO_POLLING	= (1 << 9), /* use polling PIO if LLD
                                             * doesn't handle PIO interrupts */
	
ATA_FLAG_NCQ		= (1 << 10), /* host supports NCQ */
	
ATA_FLAG_NO_POWEROFF_SPINDOWN = (1 << 11), /* don't spindown before poweroff */
	
ATA_FLAG_NO_HIBERNATE_SPINDOWN = (1 << 12), /* don't spindown before hibernation */
	
ATA_FLAG_DEBUGMSG	= (1 << 13),
	
ATA_FLAG_FPDMA_AA		= (1 << 14), /* driver supports Auto-Activate */
	
ATA_FLAG_IGN_SIMPLEX	= (1 << 15), /* ignore SIMPLEX */
	
ATA_FLAG_NO_IORDY	= (1 << 16), /* controller lacks iordy */
	
ATA_FLAG_ACPI_SATA	= (1 << 17), /* need native SATA ACPI layout */
	
ATA_FLAG_AN		= (1 << 18), /* controller supports AN */
	
ATA_FLAG_PMP		= (1 << 19), /* controller supports PMP */
	
ATA_FLAG_FPDMA_AUX	= (1 << 20), /* controller supports H2DFIS aux field */
	
ATA_FLAG_EM		= (1 << 21), /* driver supports enclosure
                                              * management */
	
ATA_FLAG_SW_ACTIVITY	= (1 << 22), /* driver supports sw activity
                                              * led */
	
ATA_FLAG_NO_DIPM	= (1 << 23), /* host not happy with DIPM */
	
ATA_FLAG_SAS_HOST	= (1 << 24), /* SAS host */

	/* bits 24:31 of ap->flags are reserved for LLD specific flags */


	/* struct ata_port pflags */
	
ATA_PFLAG_EH_PENDING	= (1 << 0), /* EH pending */
	
ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
	
ATA_PFLAG_FROZEN	= (1 << 2), /* port is frozen */
	
ATA_PFLAG_RECOVERED	= (1 << 3), /* recovery action performed */
	
ATA_PFLAG_LOADING	= (1 << 4), /* boot/loading probe */
	
ATA_PFLAG_SCSI_HOTPLUG	= (1 << 6), /* SCSI hotplug scheduled */
	
ATA_PFLAG_INITIALIZING	= (1 << 7), /* being initialized, don't touch */
	
ATA_PFLAG_RESETTING	= (1 << 8), /* reset in progress */
	
ATA_PFLAG_UNLOADING	= (1 << 9), /* driver is being unloaded */
	
ATA_PFLAG_UNLOADED	= (1 << 10), /* driver is unloaded */

	
ATA_PFLAG_SUSPENDED	= (1 << 17), /* port is suspended (power) */
	
ATA_PFLAG_PM_PENDING	= (1 << 18), /* PM operation pending */
	
ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */

	
ATA_PFLAG_PIO32		= (1 << 20),  /* 32bit PIO */
	
ATA_PFLAG_PIO32CHANGE	= (1 << 21),  /* 32bit PIO can be turned on/off */
	
ATA_PFLAG_EXTERNAL	= (1 << 22),  /* eSATA/external port */

	/* struct ata_queued_cmd flags */
	
ATA_QCFLAG_ACTIVE	= (1 << 0), /* cmd not yet ack'd to scsi lyer */
	
ATA_QCFLAG_DMAMAP	= (1 << 1), /* SG table is DMA mapped */
	
ATA_QCFLAG_IO		= (1 << 3), /* standard IO command */
	
ATA_QCFLAG_RESULT_TF	= (1 << 4), /* result TF requested */
	
ATA_QCFLAG_CLEAR_EXCL	= (1 << 5), /* clear excl_link on completion */
	
ATA_QCFLAG_QUIET	= (1 << 6), /* don't report device error */
	
ATA_QCFLAG_RETRY	= (1 << 7), /* retry after failure */

	
ATA_QCFLAG_FAILED	= (1 << 16), /* cmd failed and is owned by EH */
	
ATA_QCFLAG_SENSE_VALID	= (1 << 17), /* sense data valid */
	
ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */

	/* host set flags */
	
ATA_HOST_SIMPLEX	= (1 << 0),	/* Host is simplex, one DMA channel per host only */
	
ATA_HOST_STARTED	= (1 << 1),	/* Host started */
	
ATA_HOST_PARALLEL_SCAN	= (1 << 2),	/* Ports on this host can be scanned in parallel */
	
ATA_HOST_IGNORE_ATA	= (1 << 3),	/* Ignore ATA devices on this host. */

	/* bits 24:31 of host->flags are reserved for LLD specific flags */

	/* various lengths of time */
	
ATA_TMOUT_BOOT		= 30000,	/* heuristic */
	
ATA_TMOUT_BOOT_QUICK	=  7000,	/* heuristic */
	
ATA_TMOUT_INTERNAL_QUICK = 5000,
	
ATA_TMOUT_MAX_PARK	= 30000,

	/*
         * GoVault needs 2s and iVDR disk HHD424020F7SV00 800ms.  2s
         * is too much without parallel probing.  Use 2s if parallel
         * probing is available, 800ms otherwise.
         */
	
ATA_TMOUT_FF_WAIT_LONG	=  2000,
	
ATA_TMOUT_FF_WAIT	=   800,

	/* Spec mandates to wait for ">= 2ms" before checking status
         * after reset.  We wait 150ms, because that was the magic
         * delay used for ATAPI devices in Hale Landis's ATADRVR, for
         * the period of time between when the ATA command register is
         * written, and then status is checked.  Because waiting for
         * "a while" before checking status is fine, post SRST, we
         * perform this magic delay here as well.
         *
         * Old drivers/ide uses the 2mS rule and then waits for ready.
         */
	
ATA_WAIT_AFTER_RESET	=  150,

	/* If PMP is supported, we have to do follow-up SRST.  As some
         * PMPs don't send D2H Reg FIS after hardreset, LLDs are
         * advised to wait only for the following duration before
         * doing SRST.
         */
	
ATA_TMOUT_PMP_SRST_WAIT	= 5000,

	/* When the LPM policy is set to ATA_LPM_MAX_POWER, there might
         * be a spurious PHY event, so ignore the first PHY event that
         * occurs within 10s after the policy change.
         */
	
ATA_TMOUT_SPURIOUS_PHY	= 10000,

	/* ATA bus states */
	
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,

	/* SATA port states */
	
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_SHIFT_PRIO		= 6,

	
ATA_PRIO_HIGH		= 2,
	/* size of buffer to pad xfers ending on unaligned boundaries */
	
ATA_DMA_PAD_SZ		= 4,

	/* ering size */
	
ATA_ERING_SIZE		= 32,

	/* return values for ->qc_defer */
	
ATA_DEFER_LINK		= 1,
	
ATA_DEFER_PORT		= 2,

	/* desc_len for ata_eh_info and context */
	
ATA_EH_DESC_LEN		= 80,

	/* reset / recovery action types */
	
ATA_EH_REVALIDATE	= (1 << 0),
	
ATA_EH_SOFTRESET	= (1 << 1), /* meaningful only in ->prereset */
	
ATA_EH_HARDRESET	= (1 << 2), /* meaningful only in ->prereset */
	
ATA_EH_RESET		= ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
	
ATA_EH_ENABLE_LINK	= (1 << 3),
	
ATA_EH_PARK		= (1 << 5), /* unload heads and stop I/O */

	
ATA_EH_PERDEV_MASK	= ATA_EH_REVALIDATE | ATA_EH_PARK,
	
ATA_EH_ALL_ACTIONS	= ATA_EH_REVALIDATE | ATA_EH_RESET |
				  ATA_EH_ENABLE_LINK,

	/* ata_eh_info->flags */
	
ATA_EHI_HOTPLUGGED	= (1 << 0),  /* could have been hotplugged */
	
ATA_EHI_NO_AUTOPSY	= (1 << 2),  /* no autopsy */
	
ATA_EHI_QUIET		= (1 << 3),  /* be quiet */
	
ATA_EHI_NO_RECOVERY	= (1 << 4),  /* no recovery */

	
ATA_EHI_DID_SOFTRESET	= (1 << 16), /* already soft-reset this port */
	
ATA_EHI_DID_HARDRESET	= (1 << 17), /* already soft-reset this port */
	
ATA_EHI_PRINTINFO	= (1 << 18), /* print configuration info */
	
ATA_EHI_SETMODE		= (1 << 19), /* configure transfer mode */
	
ATA_EHI_POST_SETMODE	= (1 << 20), /* revalidating after setmode */

	
ATA_EHI_DID_RESET	= ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,

	/* mask of flags to transfer *to* the slave link */
	
ATA_EHI_TO_SLAVE_MASK	= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET,

	/* max tries if error condition is still set after ->error_handler */
	
ATA_EH_MAX_TRIES	= 5,

	/* sometimes resuming a link requires several retries */
	
ATA_LINK_RESUME_TRIES	= 5,

	/* how hard are we gonna try to probe/recover devices */
	
ATA_PROBE_MAX_TRIES	= 3,
	
ATA_EH_DEV_TRIES	= 3,
	
ATA_EH_PMP_TRIES	= 5,
	
ATA_EH_PMP_LINK_TRIES	= 3,

	
SATA_PMP_RW_TIMEOUT	= 3000,		/* PMP read/write timeout */

	/* This should match the actual table size of
         * ata_eh_cmd_timeout_table in libata-eh.c.
         */
	
ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 6,

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

	
ATA_HORKAGE_DIAGNOSTIC	= (1 << 0),	/* Failed boot diag */
	
ATA_HORKAGE_NODMA	= (1 << 1),	/* DMA problems */
	
ATA_HORKAGE_NONCQ	= (1 << 2),	/* Don't use NCQ */
	
ATA_HORKAGE_MAX_SEC_128	= (1 << 3),	/* Limit max sects to 128 */
	
ATA_HORKAGE_BROKEN_HPA	= (1 << 4),	/* Broken HPA */
	
ATA_HORKAGE_DISABLE	= (1 << 5),	/* Disable it */
	
ATA_HORKAGE_HPA_SIZE	= (1 << 6),	/* native size off by one */
	
ATA_HORKAGE_IVB		= (1 << 8),	/* cbl det validity bit bugs */
	
ATA_HORKAGE_STUCK_ERR	= (1 << 9),	/* stuck ERR on next PACKET */
	
ATA_HORKAGE_BRIDGE_OK	= (1 << 10),	/* no bridge limits */
	
ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands
                                                    not multiple of 16 bytes */
	
ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),	/* firmware update warning */
	
ATA_HORKAGE_1_5_GBPS	= (1 << 13),	/* force 1.5 Gbps */
	
ATA_HORKAGE_NOSETXFER	= (1 << 14),	/* skip SETXFER, SATA only */
	
ATA_HORKAGE_BROKEN_FPDMA_AA	= (1 << 15),	/* skip AA */
	
ATA_HORKAGE_DUMP_ID	= (1 << 16),	/* dump IDENTIFY data */
	
ATA_HORKAGE_MAX_SEC_LBA48 = (1 << 17),	/* Set max sects to 65535 */
	
ATA_HORKAGE_ATAPI_DMADIR = (1 << 18),	/* device requires dmadir */
	
ATA_HORKAGE_NO_NCQ_TRIM	= (1 << 19),	/* don't use queued TRIM */
	
ATA_HORKAGE_NOLPM	= (1 << 20),	/* don't use LPM */
	
ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21),	/* some WDs have broken LPM */
	
ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */
	
ATA_HORKAGE_NO_NCQ_LOG	= (1 << 23),	/* don't use NCQ for log read */
	
ATA_HORKAGE_NOTRIM	= (1 << 24),	/* don't use TRIM */
	
ATA_HORKAGE_MAX_SEC_1024 = (1 << 25),	/* Limit max sects to 1024 */

	 /* DMA mask for user DMA control: User visible values; DO NOT
            renumber */
	
ATA_DMA_MASK_ATA	= (1 << 0),	/* DMA on ATA Disk */
	
ATA_DMA_MASK_ATAPI	= (1 << 1),	/* DMA on ATAPI */
	
ATA_DMA_MASK_CFA	= (1 << 2),	/* DMA on CF Card */

	/* ATAPI command types */
	
ATAPI_READ		= 0,		/* READs */
	
ATAPI_WRITE		= 1,		/* WRITEs */
	
ATAPI_READ_CD		= 2,		/* READ CD [MSF] */
	
ATAPI_PASS_THRU		= 3,		/* SAT pass-thru */
	
ATAPI_MISC		= 4,		/* the rest */

	/* Timing constants */
	
ATA_TIMING_SETUP	= (1 << 0),
	
ATA_TIMING_ACT8B	= (1 << 1),
	
ATA_TIMING_REC8B	= (1 << 2),
	
ATA_TIMING_CYC8B	= (1 << 3),
	
ATA_TIMING_8BIT		= ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
				  ATA_TIMING_CYC8B,
	
ATA_TIMING_ACTIVE	= (1 << 4),
	
ATA_TIMING_RECOVER	= (1 << 5),
	
ATA_TIMING_DMACK_HOLD	= (1 << 6),
	
ATA_TIMING_CYCLE	= (1 << 7),
	
ATA_TIMING_UDMA		= (1 << 8),
	
ATA_TIMING_ALL		= ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
				  ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
				  ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
				  ATA_TIMING_DMACK_HOLD | ATA_TIMING_CYCLE |
				  ATA_TIMING_UDMA,

	/* ACPI constants */
	
ATA_ACPI_FILTER_SETXFER	= 1 << 0,
	
ATA_ACPI_FILTER_LOCK	= 1 << 1,
	
ATA_ACPI_FILTER_DIPM	= 1 << 2,
	
ATA_ACPI_FILTER_FPDMA_OFFSET = 1 << 3,	/* FPDMA non-zero offset */
	
ATA_ACPI_FILTER_FPDMA_AA = 1 << 4,	/* FPDMA auto activate */

	
ATA_ACPI_FILTER_DEFAULT	= ATA_ACPI_FILTER_SETXFER |
				  ATA_ACPI_FILTER_LOCK |
				  ATA_ACPI_FILTER_DIPM,
};


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


enum hsm_task_states {
	
HSM_ST_IDLE,		/* no command on going */
	
HSM_ST_FIRST,		/* (waiting the device to)
                                   write CDB or first data block */
	
HSM_ST,			/* (waiting the device to) transfer data */
	
HSM_ST_LAST,		/* (waiting the device to) complete command */
	
HSM_ST_ERR,		/* error */
};


enum ata_completion_errors {
	
AC_ERR_DEV		= (1 << 0), /* device reported error */
	
AC_ERR_HSM		= (1 << 1), /* host state machine violation */
	
AC_ERR_TIMEOUT		= (1 << 2), /* timeout */
	
AC_ERR_MEDIA		= (1 << 3), /* media error */
	
AC_ERR_ATA_BUS		= (1 << 4), /* ATA bus error */
	
AC_ERR_HOST_BUS		= (1 << 5), /* host bus error */
	
AC_ERR_SYSTEM		= (1 << 6), /* system error */
	
AC_ERR_INVALID		= (1 << 7), /* invalid argument */
	
AC_ERR_OTHER		= (1 << 8), /* unknown */
	
AC_ERR_NODEV_HINT	= (1 << 9), /* polling device detection hint */
	
AC_ERR_NCQ		= (1 << 10), /* marker for offending NCQ qc */
};

/*
 * Link power management policy: If you alter this, you also need to
 * alter libata-scsi.c (for the ascii descriptions)
 */

enum ata_lpm_policy {
	
ATA_LPM_UNKNOWN,
	
ATA_LPM_MAX_POWER,
	
ATA_LPM_MED_POWER,
	
ATA_LPM_MIN_POWER,
};


enum ata_lpm_hints {
	
ATA_LPM_EMPTY		= (1 << 0), /* port empty/probing */
	
ATA_LPM_HIPM		= (1 << 1), /* may use HIPM */
	
ATA_LPM_WAKE_ONLY	= (1 << 2), /* only wake up link */
};

/* forward declarations */
struct scsi_device;
struct ata_port_operations;
struct ata_port;
struct ata_link;
struct ata_queued_cmd;

/* typedefs */

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

typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);

typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes,
			      unsigned long deadline);

typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);

extern struct device_attribute dev_attr_link_power_management_policy;
extern struct device_attribute dev_attr_unload_heads;
extern struct device_attribute dev_attr_ncq_prio_enable;
extern struct device_attribute dev_attr_em_message_type;
extern struct device_attribute dev_attr_em_message;
extern struct device_attribute dev_attr_sw_activity;


enum sw_activity {
	
OFF,
	
BLINK_ON,
	
BLINK_OFF,
};


struct ata_taskfile {
	
unsigned long		flags;		/* ATA_TFLAG_xxx */
	
u8			protocol;	/* ATA_PROT_xxx */

	
u8			ctl;		/* control reg */

	
u8			hob_feature;	/* additional data */
	
u8			hob_nsect;	/* to support LBA48 */
	
u8			hob_lbal;
	
u8			hob_lbam;
	
u8			hob_lbah;

	
u8			feature;
	
u8			nsect;
	
u8			lbal;
	
u8			lbam;
	
u8