include/linux/libata.h

0001 /* SPDX-License-Identifier: GPL-2.0-or-later */
0002 /*
0003  *  Copyright 2003-2005 Red Hat, Inc.  All rights reserved.
0004  *  Copyright 2003-2005 Jeff Garzik
0005  *
0006  *  libata documentation is available via 'make {ps|pdf}docs',
0007  *  as Documentation/driver-api/libata.rst
0008  */
0009
0010 #ifndef __LINUX_LIBATA_H__
0011 #define __LINUX_LIBATA_H__
0012
0013 #include <linux/delay.h>
0014 #include <linux/jiffies.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/dma-mapping.h>
0017 #include <linux/scatterlist.h>
0018 #include <linux/io.h>
0019 #include <linux/ata.h>
0020 #include <linux/workqueue.h>
0021 #include <scsi/scsi_host.h>
0022 #include <linux/acpi.h>
0023 #include <linux/cdrom.h>
0024 #include <linux/sched.h>
0025 #include <linux/async.h>
0026
0027 /*
0028  * Define if arch has non-standard setup.  This is a _PCI_ standard
0029  * not a legacy or ISA standard.
0030  */
0031 #ifdef CONFIG_ATA_NONSTANDARD
0032 #include <asm/libata-portmap.h>
0033 #else
0034 #define ATA_PRIMARY_IRQ(dev)    14
0035 #define ATA_SECONDARY_IRQ(dev)  15
0036 #endif
0037
0038 /*
0039  * compile-time options: to be removed as soon as all the drivers are
0040  * converted to the new debugging mechanism
0041  */
0042 #undef ATA_IRQ_TRAP     /* define to ack screaming irqs */
0043
0044
0045 #define ata_print_version_once(dev, version)            \
0046 ({                              \
0047     static bool __print_once;               \
0048                                 \
0049     if (!__print_once) {                    \
0050         __print_once = true;                \
0051         ata_print_version(dev, version);        \
0052     }                           \
0053 })
0054
0055 /* defines only for the constants which don't work well as enums */
0056 #define ATA_TAG_POISON      0xfafbfcfdU
0057
0058 enum {
0059     /* various global constants */
0060     LIBATA_MAX_PRD      = ATA_MAX_PRD / 2,
0061     LIBATA_DUMB_MAX_PRD = ATA_MAX_PRD / 4,  /* Worst case */
0062     ATA_DEF_QUEUE       = 1,
0063     ATA_MAX_QUEUE       = 32,
0064     ATA_TAG_INTERNAL    = ATA_MAX_QUEUE,
0065     ATA_SHORT_PAUSE     = 16,
0066
0067     ATAPI_MAX_DRAIN     = 16 << 10,
0068
0069     ATA_ALL_DEVICES     = (1 << ATA_MAX_DEVICES) - 1,
0070
0071     ATA_SHT_EMULATED    = 1,
0072     ATA_SHT_THIS_ID     = -1,
0073
0074     /* struct ata_taskfile flags */
0075     ATA_TFLAG_LBA48     = (1 << 0), /* enable 48-bit LBA and "HOB" */
0076     ATA_TFLAG_ISADDR    = (1 << 1), /* enable r/w to nsect/lba regs */
0077     ATA_TFLAG_DEVICE    = (1 << 2), /* enable r/w to device reg */
0078     ATA_TFLAG_WRITE     = (1 << 3), /* data dir: host->dev==1 (write) */
0079     ATA_TFLAG_LBA       = (1 << 4), /* enable LBA */
0080     ATA_TFLAG_FUA       = (1 << 5), /* enable FUA */
0081     ATA_TFLAG_POLLING   = (1 << 6), /* set nIEN to 1 and use polling */
0082
0083     /* struct ata_device stuff */
0084     ATA_DFLAG_LBA       = (1 << 0), /* device supports LBA */
0085     ATA_DFLAG_LBA48     = (1 << 1), /* device supports LBA48 */
0086     ATA_DFLAG_CDB_INTR  = (1 << 2), /* device asserts INTRQ when ready for CDB */
0087     ATA_DFLAG_NCQ       = (1 << 3), /* device supports NCQ */
0088     ATA_DFLAG_FLUSH_EXT = (1 << 4), /* do FLUSH_EXT instead of FLUSH */
0089     ATA_DFLAG_ACPI_PENDING  = (1 << 5), /* ACPI resume action pending */
0090     ATA_DFLAG_ACPI_FAILED   = (1 << 6), /* ACPI on devcfg has failed */
0091     ATA_DFLAG_AN        = (1 << 7), /* AN configured */
0092     ATA_DFLAG_TRUSTED   = (1 << 8), /* device supports trusted send/recv */
0093     ATA_DFLAG_DMADIR    = (1 << 10), /* device requires DMADIR */
0094     ATA_DFLAG_CFG_MASK  = (1 << 12) - 1,
0095
0096     ATA_DFLAG_PIO       = (1 << 12), /* device limited to PIO mode */
0097     ATA_DFLAG_NCQ_OFF   = (1 << 13), /* device limited to non-NCQ mode */
0098     ATA_DFLAG_SLEEPING  = (1 << 15), /* device is sleeping */
0099     ATA_DFLAG_DUBIOUS_XFER  = (1 << 16), /* data transfer not verified */
0100     ATA_DFLAG_NO_UNLOAD = (1 << 17), /* device doesn't support unload */
0101     ATA_DFLAG_UNLOCK_HPA    = (1 << 18), /* unlock HPA */
0102     ATA_DFLAG_NCQ_SEND_RECV = (1 << 19), /* device supports NCQ SEND and RECV */
0103     ATA_DFLAG_NCQ_PRIO  = (1 << 20), /* device supports NCQ priority */
0104     ATA_DFLAG_NCQ_PRIO_ENABLE = (1 << 21), /* Priority cmds sent to dev */
0105     ATA_DFLAG_INIT_MASK = (1 << 24) - 1,
0106
0107     ATA_DFLAG_DETACH    = (1 << 24),
0108     ATA_DFLAG_DETACHED  = (1 << 25),
0109
0110     ATA_DFLAG_DA        = (1 << 26), /* device supports Device Attention */
0111     ATA_DFLAG_DEVSLP    = (1 << 27), /* device supports Device Sleep */
0112     ATA_DFLAG_ACPI_DISABLED = (1 << 28), /* ACPI for the device is disabled */
0113     ATA_DFLAG_D_SENSE   = (1 << 29), /* Descriptor sense requested */
0114     ATA_DFLAG_ZAC       = (1 << 30), /* ZAC device */
0115
0116     ATA_DFLAG_FEATURES_MASK = ATA_DFLAG_TRUSTED | ATA_DFLAG_DA | \
0117                   ATA_DFLAG_DEVSLP | ATA_DFLAG_NCQ_SEND_RECV | \
0118                   ATA_DFLAG_NCQ_PRIO,
0119
0120     ATA_DEV_UNKNOWN     = 0,    /* unknown device */
0121     ATA_DEV_ATA     = 1,    /* ATA device */
0122     ATA_DEV_ATA_UNSUP   = 2,    /* ATA device (unsupported) */
0123     ATA_DEV_ATAPI       = 3,    /* ATAPI device */
0124     ATA_DEV_ATAPI_UNSUP = 4,    /* ATAPI device (unsupported) */
0125     ATA_DEV_PMP     = 5,    /* SATA port multiplier */
0126     ATA_DEV_PMP_UNSUP   = 6,    /* SATA port multiplier (unsupported) */
0127     ATA_DEV_SEMB        = 7,    /* SEMB */
0128     ATA_DEV_SEMB_UNSUP  = 8,    /* SEMB (unsupported) */
0129     ATA_DEV_ZAC     = 9,    /* ZAC device */
0130     ATA_DEV_ZAC_UNSUP   = 10,   /* ZAC device (unsupported) */
0131     ATA_DEV_NONE        = 11,   /* no device */
0132
0133     /* struct ata_link flags */
0134     /* NOTE: struct ata_force_param currently stores lflags in u16 */
0135     ATA_LFLAG_NO_HRST   = (1 << 1), /* avoid hardreset */
0136     ATA_LFLAG_NO_SRST   = (1 << 2), /* avoid softreset */
0137     ATA_LFLAG_ASSUME_ATA    = (1 << 3), /* assume ATA class */
0138     ATA_LFLAG_ASSUME_SEMB   = (1 << 4), /* assume SEMB class */
0139     ATA_LFLAG_ASSUME_CLASS  = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
0140     ATA_LFLAG_NO_RETRY  = (1 << 5), /* don't retry this link */
0141     ATA_LFLAG_DISABLED  = (1 << 6), /* link is disabled */
0142     ATA_LFLAG_SW_ACTIVITY   = (1 << 7), /* keep activity stats */
0143     ATA_LFLAG_NO_LPM    = (1 << 8), /* disable LPM on this link */
0144     ATA_LFLAG_RST_ONCE  = (1 << 9), /* limit recovery to one reset */
0145     ATA_LFLAG_CHANGED   = (1 << 10), /* LPM state changed on this link */
0146     ATA_LFLAG_NO_DEBOUNCE_DELAY = (1 << 11), /* no debounce delay on link resume */
0147
0148     /* struct ata_port flags */
0149     ATA_FLAG_SLAVE_POSS = (1 << 0), /* host supports slave dev */
0150                         /* (doesn't imply presence) */
0151     ATA_FLAG_SATA       = (1 << 1),
0152     ATA_FLAG_NO_LPM     = (1 << 2), /* host not happy with LPM */
0153     ATA_FLAG_NO_LOG_PAGE    = (1 << 5), /* do not issue log page read */
0154     ATA_FLAG_NO_ATAPI   = (1 << 6), /* No ATAPI support */
0155     ATA_FLAG_PIO_DMA    = (1 << 7), /* PIO cmds via DMA */
0156     ATA_FLAG_PIO_LBA48  = (1 << 8), /* Host DMA engine is LBA28 only */
0157     ATA_FLAG_PIO_POLLING    = (1 << 9), /* use polling PIO if LLD
0158                          * doesn't handle PIO interrupts */
0159     ATA_FLAG_NCQ        = (1 << 10), /* host supports NCQ */
0160     ATA_FLAG_NO_POWEROFF_SPINDOWN = (1 << 11), /* don't spindown before poweroff */
0161     ATA_FLAG_NO_HIBERNATE_SPINDOWN = (1 << 12), /* don't spindown before hibernation */
0162     ATA_FLAG_DEBUGMSG   = (1 << 13),
0163     ATA_FLAG_FPDMA_AA       = (1 << 14), /* driver supports Auto-Activate */
0164     ATA_FLAG_IGN_SIMPLEX    = (1 << 15), /* ignore SIMPLEX */
0165     ATA_FLAG_NO_IORDY   = (1 << 16), /* controller lacks iordy */
0166     ATA_FLAG_ACPI_SATA  = (1 << 17), /* need native SATA ACPI layout */
0167     ATA_FLAG_AN     = (1 << 18), /* controller supports AN */
0168     ATA_FLAG_PMP        = (1 << 19), /* controller supports PMP */
0169     ATA_FLAG_FPDMA_AUX  = (1 << 20), /* controller supports H2DFIS aux field */
0170     ATA_FLAG_EM     = (1 << 21), /* driver supports enclosure
0171                           * management */
0172     ATA_FLAG_SW_ACTIVITY    = (1 << 22), /* driver supports sw activity
0173                           * led */
0174     ATA_FLAG_NO_DIPM    = (1 << 23), /* host not happy with DIPM */
0175     ATA_FLAG_SAS_HOST   = (1 << 24), /* SAS host */
0176
0177     /* bits 24:31 of ap->flags are reserved for LLD specific flags */
0178
0179
0180     /* struct ata_port pflags */
0181     ATA_PFLAG_EH_PENDING    = (1 << 0), /* EH pending */
0182     ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
0183     ATA_PFLAG_FROZEN    = (1 << 2), /* port is frozen */
0184     ATA_PFLAG_RECOVERED = (1 << 3), /* recovery action performed */
0185     ATA_PFLAG_LOADING   = (1 << 4), /* boot/loading probe */
0186     ATA_PFLAG_SCSI_HOTPLUG  = (1 << 6), /* SCSI hotplug scheduled */
0187     ATA_PFLAG_INITIALIZING  = (1 << 7), /* being initialized, don't touch */
0188     ATA_PFLAG_RESETTING = (1 << 8), /* reset in progress */
0189     ATA_PFLAG_UNLOADING = (1 << 9), /* driver is being unloaded */
0190     ATA_PFLAG_UNLOADED  = (1 << 10), /* driver is unloaded */
0191
0192     ATA_PFLAG_SUSPENDED = (1 << 17), /* port is suspended (power) */
0193     ATA_PFLAG_PM_PENDING    = (1 << 18), /* PM operation pending */
0194     ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */
0195
0196     ATA_PFLAG_PIO32     = (1 << 20),  /* 32bit PIO */
0197     ATA_PFLAG_PIO32CHANGE   = (1 << 21),  /* 32bit PIO can be turned on/off */
0198     ATA_PFLAG_EXTERNAL  = (1 << 22),  /* eSATA/external port */
0199
0200     /* struct ata_queued_cmd flags */
0201     ATA_QCFLAG_ACTIVE   = (1 << 0), /* cmd not yet ack'd to scsi lyer */
0202     ATA_QCFLAG_DMAMAP   = (1 << 1), /* SG table is DMA mapped */
0203     ATA_QCFLAG_IO       = (1 << 3), /* standard IO command */
0204     ATA_QCFLAG_RESULT_TF    = (1 << 4), /* result TF requested */
0205     ATA_QCFLAG_CLEAR_EXCL   = (1 << 5), /* clear excl_link on completion */
0206     ATA_QCFLAG_QUIET    = (1 << 6), /* don't report device error */
0207     ATA_QCFLAG_RETRY    = (1 << 7), /* retry after failure */
0208
0209     ATA_QCFLAG_FAILED   = (1 << 16), /* cmd failed and is owned by EH */
0210     ATA_QCFLAG_SENSE_VALID  = (1 << 17), /* sense data valid */
0211     ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */
0212
0213     /* host set flags */
0214     ATA_HOST_SIMPLEX    = (1 << 0), /* Host is simplex, one DMA channel per host only */
0215     ATA_HOST_STARTED    = (1 << 1), /* Host started */
0216     ATA_HOST_PARALLEL_SCAN  = (1 << 2), /* Ports on this host can be scanned in parallel */
0217     ATA_HOST_IGNORE_ATA = (1 << 3), /* Ignore ATA devices on this host. */
0218
0219     /* bits 24:31 of host->flags are reserved for LLD specific flags */
0220
0221     /* various lengths of time */
0222     ATA_TMOUT_BOOT      = 30000,    /* heuristic */
0223     ATA_TMOUT_BOOT_QUICK    =  7000,    /* heuristic */
0224     ATA_TMOUT_INTERNAL_QUICK = 5000,
0225     ATA_TMOUT_MAX_PARK  = 30000,
0226
0227     /*
0228      * GoVault needs 2s and iVDR disk HHD424020F7SV00 800ms.  2s
0229      * is too much without parallel probing.  Use 2s if parallel
0230      * probing is available, 800ms otherwise.
0231      */
0232     ATA_TMOUT_FF_WAIT_LONG  =  2000,
0233     ATA_TMOUT_FF_WAIT   =   800,
0234
0235     /* Spec mandates to wait for ">= 2ms" before checking status
0236      * after reset.  We wait 150ms, because that was the magic
0237      * delay used for ATAPI devices in Hale Landis's ATADRVR, for
0238      * the period of time between when the ATA command register is
0239      * written, and then status is checked.  Because waiting for
0240      * "a while" before checking status is fine, post SRST, we
0241      * perform this magic delay here as well.
0242      *
0243      * Old drivers/ide uses the 2mS rule and then waits for ready.
0244      */
0245     ATA_WAIT_AFTER_RESET    =  150,
0246
0247     /* If PMP is supported, we have to do follow-up SRST.  As some
0248      * PMPs don't send D2H Reg FIS after hardreset, LLDs are
0249      * advised to wait only for the following duration before
0250      * doing SRST.
0251      */
0252     ATA_TMOUT_PMP_SRST_WAIT = 5000,
0253
0254     /* When the LPM policy is set to ATA_LPM_MAX_POWER, there might
0255      * be a spurious PHY event, so ignore the first PHY event that
0256      * occurs within 10s after the policy change.
0257      */
0258     ATA_TMOUT_SPURIOUS_PHY  = 10000,
0259
0260     /* ATA bus states */
0261     BUS_UNKNOWN     = 0,
0262     BUS_DMA         = 1,
0263     BUS_IDLE        = 2,
0264     BUS_NOINTR      = 3,
0265     BUS_NODATA      = 4,
0266     BUS_TIMER       = 5,
0267     BUS_PIO         = 6,
0268     BUS_EDD         = 7,
0269     BUS_IDENTIFY        = 8,
0270     BUS_PACKET      = 9,
0271
0272     /* SATA port states */
0273     PORT_UNKNOWN        = 0,
0274     PORT_ENABLED        = 1,
0275     PORT_DISABLED       = 2,
0276
0277     /* encoding various smaller bitmaps into a single
0278      * unsigned int bitmap
0279      */
0280     ATA_NR_PIO_MODES    = 7,
0281     ATA_NR_MWDMA_MODES  = 5,
0282     ATA_NR_UDMA_MODES   = 8,
0283
0284     ATA_SHIFT_PIO       = 0,
0285     ATA_SHIFT_MWDMA     = ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
0286     ATA_SHIFT_UDMA      = ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,
0287     ATA_SHIFT_PRIO      = 6,
0288
0289     ATA_PRIO_HIGH       = 2,
0290     /* size of buffer to pad xfers ending on unaligned boundaries */
0291     ATA_DMA_PAD_SZ      = 4,
0292
0293     /* ering size */
0294     ATA_ERING_SIZE      = 32,
0295
0296     /* return values for ->qc_defer */
0297     ATA_DEFER_LINK      = 1,
0298     ATA_DEFER_PORT      = 2,
0299
0300     /* desc_len for ata_eh_info and context */
0301     ATA_EH_DESC_LEN     = 80,
0302
0303     /* reset / recovery action types */
0304     ATA_EH_REVALIDATE   = (1 << 0),
0305     ATA_EH_SOFTRESET    = (1 << 1), /* meaningful only in ->prereset */
0306     ATA_EH_HARDRESET    = (1 << 2), /* meaningful only in ->prereset */
0307     ATA_EH_RESET        = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
0308     ATA_EH_ENABLE_LINK  = (1 << 3),
0309     ATA_EH_PARK     = (1 << 5), /* unload heads and stop I/O */
0310
0311     ATA_EH_PERDEV_MASK  = ATA_EH_REVALIDATE | ATA_EH_PARK,
0312     ATA_EH_ALL_ACTIONS  = ATA_EH_REVALIDATE | ATA_EH_RESET |
0313                   ATA_EH_ENABLE_LINK,
0314
0315     /* ata_eh_info->flags */
0316     ATA_EHI_HOTPLUGGED  = (1 << 0),  /* could have been hotplugged */
0317     ATA_EHI_NO_AUTOPSY  = (1 << 2),  /* no autopsy */
0318     ATA_EHI_QUIET       = (1 << 3),  /* be quiet */
0319     ATA_EHI_NO_RECOVERY = (1 << 4),  /* no recovery */
0320
0321     ATA_EHI_DID_SOFTRESET   = (1 << 16), /* already soft-reset this port */
0322     ATA_EHI_DID_HARDRESET   = (1 << 17), /* already soft-reset this port */
0323     ATA_EHI_PRINTINFO   = (1 << 18), /* print configuration info */
0324     ATA_EHI_SETMODE     = (1 << 19), /* configure transfer mode */
0325     ATA_EHI_POST_SETMODE    = (1 << 20), /* revalidating after setmode */
0326
0327     ATA_EHI_DID_RESET   = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
0328
0329     /* mask of flags to transfer *to* the slave link */
0330     ATA_EHI_TO_SLAVE_MASK   = ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET,
0331
0332     /* max tries if error condition is still set after ->error_handler */
0333     ATA_EH_MAX_TRIES    = 5,
0334
0335     /* sometimes resuming a link requires several retries */
0336     ATA_LINK_RESUME_TRIES   = 5,
0337
0338     /* how hard are we gonna try to probe/recover devices */
0339     ATA_PROBE_MAX_TRIES = 3,
0340     ATA_EH_DEV_TRIES    = 3,
0341     ATA_EH_PMP_TRIES    = 5,
0342     ATA_EH_PMP_LINK_TRIES   = 3,
0343
0344     SATA_PMP_RW_TIMEOUT = 3000,     /* PMP read/write timeout */
0345
0346     /* This should match the actual table size of
0347      * ata_eh_cmd_timeout_table in libata-eh.c.
0348      */
0349     ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 7,
0350
0351     /* Horkage types. May be set by libata or controller on drives
0352        (some horkage may be drive/controller pair dependent */
0353
0354     ATA_HORKAGE_DIAGNOSTIC  = (1 << 0), /* Failed boot diag */
0355     ATA_HORKAGE_NODMA   = (1 << 1), /* DMA problems */
0356     ATA_HORKAGE_NONCQ   = (1 << 2), /* Don't use NCQ */
0357     ATA_HORKAGE_MAX_SEC_128 = (1 << 3), /* Limit max sects to 128 */
0358     ATA_HORKAGE_BROKEN_HPA  = (1 << 4), /* Broken HPA */
0359     ATA_HORKAGE_DISABLE = (1 << 5), /* Disable it */
0360     ATA_HORKAGE_HPA_SIZE    = (1 << 6), /* native size off by one */
0361     ATA_HORKAGE_IVB     = (1 << 8), /* cbl det validity bit bugs */
0362     ATA_HORKAGE_STUCK_ERR   = (1 << 9), /* stuck ERR on next PACKET */
0363     ATA_HORKAGE_BRIDGE_OK   = (1 << 10),    /* no bridge limits */
0364     ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands
0365                             not multiple of 16 bytes */
0366     ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),  /* firmware update warning */
0367     ATA_HORKAGE_1_5_GBPS    = (1 << 13),    /* force 1.5 Gbps */
0368     ATA_HORKAGE_NOSETXFER   = (1 << 14),    /* skip SETXFER, SATA only */
0369     ATA_HORKAGE_BROKEN_FPDMA_AA = (1 << 15),    /* skip AA */
0370     ATA_HORKAGE_DUMP_ID = (1 << 16),    /* dump IDENTIFY data */
0371     ATA_HORKAGE_MAX_SEC_LBA48 = (1 << 17),  /* Set max sects to 65535 */
0372     ATA_HORKAGE_ATAPI_DMADIR = (1 << 18),   /* device requires dmadir */
0373     ATA_HORKAGE_NO_NCQ_TRIM = (1 << 19),    /* don't use queued TRIM */
0374     ATA_HORKAGE_NOLPM   = (1 << 20),    /* don't use LPM */
0375     ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21),  /* some WDs have broken LPM */
0376     ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */
0377     ATA_HORKAGE_NO_DMA_LOG  = (1 << 23),    /* don't use DMA for log read */
0378     ATA_HORKAGE_NOTRIM  = (1 << 24),    /* don't use TRIM */
0379     ATA_HORKAGE_MAX_SEC_1024 = (1 << 25),   /* Limit max sects to 1024 */
0380     ATA_HORKAGE_MAX_TRIM_128M = (1 << 26),  /* Limit max trim size to 128M */
0381     ATA_HORKAGE_NO_NCQ_ON_ATI = (1 << 27),  /* Disable NCQ on ATI chipset */
0382     ATA_HORKAGE_NO_ID_DEV_LOG = (1 << 28),  /* Identify device log missing */
0383     ATA_HORKAGE_NO_LOG_DIR  = (1 << 29),    /* Do not read log directory */
0384
0385      /* DMA mask for user DMA control: User visible values; DO NOT
0386         renumber */
0387     ATA_DMA_MASK_ATA    = (1 << 0), /* DMA on ATA Disk */
0388     ATA_DMA_MASK_ATAPI  = (1 << 1), /* DMA on ATAPI */
0389     ATA_DMA_MASK_CFA    = (1 << 2), /* DMA on CF Card */
0390
0391     /* ATAPI command types */
0392     ATAPI_READ      = 0,        /* READs */
0393     ATAPI_WRITE     = 1,        /* WRITEs */
0394     ATAPI_READ_CD       = 2,        /* READ CD [MSF] */
0395     ATAPI_PASS_THRU     = 3,        /* SAT pass-thru */
0396     ATAPI_MISC      = 4,        /* the rest */
0397
0398     /* Timing constants */
0399     ATA_TIMING_SETUP    = (1 << 0),
0400     ATA_TIMING_ACT8B    = (1 << 1),
0401     ATA_TIMING_REC8B    = (1 << 2),
0402     ATA_TIMING_CYC8B    = (1 << 3),
0403     ATA_TIMING_8BIT     = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
0404                   ATA_TIMING_CYC8B,
0405     ATA_TIMING_ACTIVE   = (1 << 4),
0406     ATA_TIMING_RECOVER  = (1 << 5),
0407     ATA_TIMING_DMACK_HOLD   = (1 << 6),
0408     ATA_TIMING_CYCLE    = (1 << 7),
0409     ATA_TIMING_UDMA     = (1 << 8),
0410     ATA_TIMING_ALL      = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
0411                   ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
0412                   ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
0413                   ATA_TIMING_DMACK_HOLD | ATA_TIMING_CYCLE |
0414                   ATA_TIMING_UDMA,
0415
0416     /* ACPI constants */
0417     ATA_ACPI_FILTER_SETXFER = 1 << 0,
0418     ATA_ACPI_FILTER_LOCK    = 1 << 1,
0419     ATA_ACPI_FILTER_DIPM    = 1 << 2,
0420     ATA_ACPI_FILTER_FPDMA_OFFSET = 1 << 3,  /* FPDMA non-zero offset */
0421     ATA_ACPI_FILTER_FPDMA_AA = 1 << 4,  /* FPDMA auto activate */
0422
0423     ATA_ACPI_FILTER_DEFAULT = ATA_ACPI_FILTER_SETXFER |
0424                   ATA_ACPI_FILTER_LOCK |
0425                   ATA_ACPI_FILTER_DIPM,
0426 };
0427
0428 enum ata_xfer_mask {
0429     ATA_MASK_PIO        = ((1U << ATA_NR_PIO_MODES) - 1) << ATA_SHIFT_PIO,
0430     ATA_MASK_MWDMA      = ((1U << ATA_NR_MWDMA_MODES) - 1) << ATA_SHIFT_MWDMA,
0431     ATA_MASK_UDMA       = ((1U << ATA_NR_UDMA_MODES) - 1) << ATA_SHIFT_UDMA,
0432 };
0433
0434 enum hsm_task_states {
0435     HSM_ST_IDLE,        /* no command on going */
0436     HSM_ST_FIRST,       /* (waiting the device to)
0437                    write CDB or first data block */
0438     HSM_ST,         /* (waiting the device to) transfer data */
0439     HSM_ST_LAST,        /* (waiting the device to) complete command */
0440     HSM_ST_ERR,     /* error */
0441 };
0442
0443 enum ata_completion_errors {
0444     AC_ERR_OK       = 0,        /* no error */
0445     AC_ERR_DEV      = (1 << 0), /* device reported error */
0446     AC_ERR_HSM      = (1 << 1), /* host state machine violation */
0447     AC_ERR_TIMEOUT      = (1 << 2), /* timeout */
0448     AC_ERR_MEDIA        = (1 << 3), /* media error */
0449     AC_ERR_ATA_BUS      = (1 << 4), /* ATA bus error */
0450     AC_ERR_HOST_BUS     = (1 << 5), /* host bus error */
0451     AC_ERR_SYSTEM       = (1 << 6), /* system error */
0452     AC_ERR_INVALID      = (1 << 7), /* invalid argument */
0453     AC_ERR_OTHER        = (1 << 8), /* unknown */
0454     AC_ERR_NODEV_HINT   = (1 << 9), /* polling device detection hint */
0455     AC_ERR_NCQ      = (1 << 10), /* marker for offending NCQ qc */
0456 };
0457
0458 /*
0459  * Link power management policy: If you alter this, you also need to
0460  * alter libata-scsi.c (for the ascii descriptions)
0461  */
0462 enum ata_lpm_policy {
0463     ATA_LPM_UNKNOWN,
0464     ATA_LPM_MAX_POWER,
0465     ATA_LPM_MED_POWER,
0466     ATA_LPM_MED_POWER_WITH_DIPM, /* Med power + DIPM as win IRST does */
0467     ATA_LPM_MIN_POWER_WITH_PARTIAL, /* Min Power + partial and slumber */
0468     ATA_LPM_MIN_POWER, /* Min power + no partial (slumber only) */
0469 };
0470
0471 enum ata_lpm_hints {
0472     ATA_LPM_EMPTY       = (1 << 0), /* port empty/probing */
0473     ATA_LPM_HIPM        = (1 << 1), /* may use HIPM */
0474     ATA_LPM_WAKE_ONLY   = (1 << 2), /* only wake up link */
0475 };
0476
0477 /* forward declarations */
0478 struct scsi_device;
0479 struct ata_port_operations;
0480 struct ata_port;
0481 struct ata_link;
0482 struct ata_queued_cmd;
0483
0484 /* typedefs */
0485 typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
0486 typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);
0487 typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes,
0488                   unsigned long deadline);
0489 typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
0490
0491 extern struct device_attribute dev_attr_unload_heads;
0492 #ifdef CONFIG_SATA_HOST
0493 extern struct device_attribute dev_attr_link_power_management_policy;
0494 extern struct device_attribute dev_attr_ncq_prio_supported;
0495 extern struct device_attribute dev_attr_ncq_prio_enable;
0496 extern struct device_attribute dev_attr_em_message_type;
0497 extern struct device_attribute dev_attr_em_message;
0498 extern struct device_attribute dev_attr_sw_activity;
0499 #endif
0500
0501 enum sw_activity {
0502     OFF,
0503     BLINK_ON,
0504     BLINK_OFF,
0505 };
0506
0507 struct ata_taskfile {
0508     unsigned long       flags;      /* ATA_TFLAG_xxx */
0509     u8          protocol;   /* ATA_PROT_xxx */
0510
0511     u8          ctl;        /* control reg */
0512
0513     u8          hob_feature;    /* additional data */
0514     u8          hob_nsect;  /* to support LBA48 */
0515     u8          hob_lbal;
0516     u8          hob_lbam;
0517     u8          hob_lbah;
0518
0519     union {
0520         u8      error;
0521         u8      feature;
0522     };
0523     u8          nsect;
0524     u8          lbal;
0525     u8          lbam;
0526     u8          lbah;
0527
0528     u8          device;
0529
0530     union {
0531         u8      status;
0532         u8      command;
0533     };
0534
0535     u32         auxiliary;  /* auxiliary field */
0536                         /* from SATA 3.1 and */
0537                         /* ATA-8 ACS-3 */
0538 };
0539
0540 #ifdef CONFIG_ATA_SFF
0541 struct ata_ioports {
0542     void __iomem        *cmd_addr;
0543     void __iomem        *data_addr;
0544     void __iomem        *error_addr;
0545     void __iomem        *feature_addr;
0546     void __iomem        *nsect_addr;
0547     void __iomem        *lbal_addr;
0548     void __iomem        *lbam_addr;
0549     void __iomem        *lbah_addr;
0550     void __iomem        *device_addr;
0551     void __iomem        *status_addr;
0552     void __iomem        *command_addr;
0553     void __iomem        *altstatus_addr;
0554     void __iomem        *ctl_addr;
0555 #ifdef CONFIG_ATA_BMDMA
0556     void __iomem        *bmdma_addr;
0557 #endif /* CONFIG_ATA_BMDMA */
0558     void __iomem        *scr_addr;
0559 };
0560 #endif /* CONFIG_ATA_SFF */
0561
0562 struct ata_host {
0563     spinlock_t      lock;
0564     struct device       *dev;
0565     void __iomem * const    *iomap;
0566     unsigned int        n_ports;
0567     unsigned int        n_tags;         /* nr of NCQ tags */
0568     void            *private_data;
0569     struct ata_port_operations *ops;
0570     unsigned long       flags;
0571     struct kref     kref;
0572
0573     struct mutex        eh_mutex;
0574     struct task_struct  *eh_owner;
0575
0576     struct ata_port     *simplex_claimed;   /* channel owning the DMA */
0577     struct ata_port     *ports[];
0578 };
0579
0580 struct ata_queued_cmd {
0581     struct ata_port     *ap;
0582     struct ata_device   *dev;
0583
0584     struct scsi_cmnd    *scsicmd;
0585     void            (*scsidone)(struct scsi_cmnd *);
0586
0587     struct ata_taskfile tf;
0588     u8          cdb[ATAPI_CDB_LEN];
0589
0590     unsigned long       flags;      /* ATA_QCFLAG_xxx */
0591     unsigned int        tag;        /* libata core tag */
0592     unsigned int        hw_tag;     /* driver tag */
0593     unsigned int        n_elem;
0594     unsigned int        orig_n_elem;
0595
0596     int         dma_dir;
0597
0598     unsigned int        sect_size;
0599
0600     unsigned int        nbytes;
0601     unsigned int        extrabytes;
0602     unsigned int        curbytes;
0603
0604     struct scatterlist  sgent;
0605
0606     struct scatterlist  *sg;
0607
0608     struct scatterlist  *cursg;
0609     unsigned int        cursg_ofs;
0610
0611     unsigned int        err_mask;
0612     struct ata_taskfile result_tf;
0613     ata_qc_cb_t     complete_fn;
0614
0615     void            *private_data;
0616     void            *lldd_task;
0617 };
0618
0619 struct ata_port_stats {
0620     unsigned long       unhandled_irq;
0621     unsigned long       idle_irq;
0622     unsigned long       rw_reqbuf;
0623 };
0624
0625 struct ata_ering_entry {
0626     unsigned int        eflags;
0627     unsigned int        err_mask;
0628     u64         timestamp;
0629 };
0630
0631 struct ata_ering {
0632     int         cursor;
0633     struct ata_ering_entry  ring[ATA_ERING_SIZE];
0634 };
0635
0636 struct ata_cpr {
0637     u8          num;
0638     u8          num_storage_elements;
0639     u64         start_lba;
0640     u64         num_lbas;
0641 };
0642
0643 struct ata_cpr_log {
0644     u8          nr_cpr;
0645     struct ata_cpr      cpr[];
0646 };
0647
0648 struct ata_device {
0649     struct ata_link     *link;
0650     unsigned int        devno;      /* 0 or 1 */
0651     unsigned int        horkage;    /* List of broken features */
0652     unsigned long       flags;      /* ATA_DFLAG_xxx */
0653     struct scsi_device  *sdev;      /* attached SCSI device */
0654     void            *private_data;
0655 #ifdef CONFIG_ATA_ACPI
0656     union acpi_object   *gtf_cache;
0657     unsigned int        gtf_filter;
0658 #endif
0659 #ifdef CONFIG_SATA_ZPODD
0660     void            *zpodd;
0661 #endif
0662     struct device       tdev;
0663     /* n_sector is CLEAR_BEGIN, read comment above CLEAR_BEGIN */
0664     u64         n_sectors;  /* size of device, if ATA */
0665     u64         n_native_sectors; /* native size, if ATA */
0666     unsigned int        class;      /* ATA_DEV_xxx */
0667     unsigned long       unpark_deadline;
0668
0669     u8          pio_mode;
0670     u8          dma_mode;
0671     u8          xfer_mode;
0672     unsigned int        xfer_shift; /* ATA_SHIFT_xxx */
0673
0674     unsigned int        multi_count;    /* sectors count for
0675                            READ/WRITE MULTIPLE */
0676     unsigned int        max_sectors;    /* per-device max sectors */
0677     unsigned int        cdb_len;
0678
0679     /* per-dev xfer mask */
0680     unsigned int        pio_mask;
0681     unsigned int        mwdma_mask;
0682     unsigned int        udma_mask;
0683
0684     /* for CHS addressing */
0685     u16         cylinders;  /* Number of cylinders */
0686     u16         heads;      /* Number of heads */
0687     u16         sectors;    /* Number of sectors per track */
0688
0689     union {
0690         u16     id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
0691         u32     gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
0692     } ____cacheline_aligned;
0693
0694     /* DEVSLP Timing Variables from Identify Device Data Log */
0695     u8          devslp_timing[ATA_LOG_DEVSLP_SIZE];
0696
0697     /* NCQ send and receive log subcommand support */
0698     u8          ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_SIZE];
0699     u8          ncq_non_data_cmds[ATA_LOG_NCQ_NON_DATA_SIZE];
0700
0701     /* ZAC zone configuration */
0702     u32         zac_zoned_cap;
0703     u32         zac_zones_optimal_open;
0704     u32         zac_zones_optimal_nonseq;
0705     u32         zac_zones_max_open;
0706
0707     /* Concurrent positioning ranges */
0708     struct ata_cpr_log  *cpr_log;
0709
0710     /* error history */
0711     int         spdn_cnt;
0712     /* ering is CLEAR_END, read comment above CLEAR_END */
0713     struct ata_ering    ering;
0714 };
0715
0716 /* Fields between ATA_DEVICE_CLEAR_BEGIN and ATA_DEVICE_CLEAR_END are
0717  * cleared to zero on ata_dev_init().
0718  */
0719 #define ATA_DEVICE_CLEAR_BEGIN      offsetof(struct ata_device, n_sectors)
0720 #define ATA_DEVICE_CLEAR_END        offsetof(struct ata_device, ering)
0721
0722 struct ata_eh_info {
0723     struct ata_device   *dev;       /* offending device */
0724     u32         serror;     /* SError from LLDD */
0725     unsigned int        err_mask;   /* port-wide err_mask */
0726     unsigned int        action;     /* ATA_EH_* action mask */
0727     unsigned int        dev_action[ATA_MAX_DEVICES]; /* dev EH action */
0728     unsigned int        flags;      /* ATA_EHI_* flags */
0729
0730     unsigned int        probe_mask;
0731
0732     char            desc[ATA_EH_DESC_LEN];
0733     int         desc_len;
0734 };
0735
0736 struct ata_eh_context {
0737     struct ata_eh_info  i;
0738     int         tries[ATA_MAX_DEVICES];
0739     int         cmd_timeout_idx[ATA_MAX_DEVICES]
0740                            [ATA_EH_CMD_TIMEOUT_TABLE_SIZE];
0741     unsigned int        classes[ATA_MAX_DEVICES];
0742     unsigned int        did_probe_mask;
0743     unsigned int        unloaded_mask;
0744     unsigned int        saved_ncq_enabled;
0745     u8          saved_xfer_mode[ATA_MAX_DEVICES];
0746     /* timestamp for the last reset attempt or success */
0747     unsigned long       last_reset;
0748 };
0749
0750 struct ata_acpi_drive
0751 {
0752     u32 pio;
0753     u32 dma;
0754 } __packed;
0755
0756 struct ata_acpi_gtm {
0757     struct ata_acpi_drive drive[2];
0758     u32 flags;
0759 } __packed;
0760
0761 struct ata_link {
0762     struct ata_port     *ap;
0763     int         pmp;        /* port multiplier port # */
0764
0765     struct device       tdev;
0766     unsigned int        active_tag; /* active tag on this link */
0767     u32         sactive;    /* active NCQ commands */
0768
0769     unsigned int        flags;      /* ATA_LFLAG_xxx */
0770
0771     u32         saved_scontrol; /* SControl on probe */
0772     unsigned int        hw_sata_spd_limit;
0773     unsigned int        sata_spd_limit;
0774     unsigned int        sata_spd;   /* current SATA PHY speed */
0775     enum ata_lpm_policy lpm_policy;
0776
0777     /* record runtime error info, protected by host_set lock */
0778     struct ata_eh_info  eh_info;
0779     /* EH context */
0780     struct ata_eh_context   eh_context;
0781
0782     struct ata_device   device[ATA_MAX_DEVICES];
0783
0784     unsigned long       last_lpm_change; /* when last LPM change happened */
0785 };
0786 #define ATA_LINK_CLEAR_BEGIN        offsetof(struct ata_link, active_tag)
0787 #define ATA_LINK_CLEAR_END      offsetof(struct ata_link, device[0])
0788
0789 struct ata_port {
0790     struct Scsi_Host    *scsi_host; /* our co-allocated scsi host */
0791     struct ata_port_operations *ops;
0792     spinlock_t      *lock;
0793     /* Flags owned by the EH context. Only EH should touch these once the
0794        port is active */
0795     unsigned long       flags;  /* ATA_FLAG_xxx */
0796     /* Flags that change dynamically, protected by ap->lock */
0797     unsigned int        pflags; /* ATA_PFLAG_xxx */
0798     unsigned int        print_id; /* user visible unique port ID */
0799     unsigned int            local_port_no; /* host local port num */
0800     unsigned int        port_no; /* 0 based port no. inside the host */
0801
0802 #ifdef CONFIG_ATA_SFF
0803     struct ata_ioports  ioaddr; /* ATA cmd/ctl/dma register blocks */
0804     u8          ctl;    /* cache of ATA control register */
0805     u8          last_ctl;   /* Cache last written value */
0806     struct ata_link*    sff_pio_task_link; /* link currently used */
0807     struct delayed_work sff_pio_task;
0808 #ifdef CONFIG_ATA_BMDMA
0809     struct ata_bmdma_prd    *bmdma_prd; /* BMDMA SG list */
0810     dma_addr_t      bmdma_prd_dma;  /* and its DMA mapping */
0811 #endif /* CONFIG_ATA_BMDMA */
0812 #endif /* CONFIG_ATA_SFF */
0813
0814     unsigned int        pio_mask;
0815     unsigned int        mwdma_mask;
0816     unsigned int        udma_mask;
0817     unsigned int        cbl;    /* cable type; ATA_CBL_xxx */
0818
0819     struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE + 1];
0820     u64         qc_active;
0821     int         nr_active_links; /* #links with active qcs */
0822
0823     struct ata_link     link;       /* host default link */
0824     struct ata_link     *slave_link;    /* see ata_slave_link_init() */
0825
0826     int         nr_pmp_links;   /* nr of available PMP links */
0827     struct ata_link     *pmp_link;  /* array of PMP links */
0828     struct ata_link     *excl_link; /* for PMP qc exclusion */
0829
0830     struct ata_port_stats   stats;
0831     struct ata_host     *host;
0832     struct device       *dev;
0833     struct device       tdev;
0834
0835     struct mutex        scsi_scan_mutex;
0836     struct delayed_work hotplug_task;
0837     struct work_struct  scsi_rescan_task;
0838
0839     unsigned int        hsm_task_state;
0840
0841     struct list_head    eh_done_q;
0842     wait_queue_head_t   eh_wait_q;
0843     int         eh_tries;
0844     struct completion   park_req_pending;
0845
0846     pm_message_t        pm_mesg;
0847     enum ata_lpm_policy target_lpm_policy;
0848
0849     struct timer_list   fastdrain_timer;
0850     unsigned int        fastdrain_cnt;
0851
0852     async_cookie_t      cookie;
0853
0854     int         em_message_type;
0855     void            *private_data;
0856
0857 #ifdef CONFIG_ATA_ACPI
0858     struct ata_acpi_gtm __acpi_init_gtm; /* use ata_acpi_init_gtm() */
0859 #endif
0860     /* owned by EH */
0861     u8          sector_buf[ATA_SECT_SIZE] ____cacheline_aligned;
0862 };
0863
0864 /* The following initializer overrides a method to NULL whether one of
0865  * its parent has the method defined or not.  This is equivalent to
0866  * ERR_PTR(-ENOENT).  Unfortunately, ERR_PTR doesn't render a constant
0867  * expression and thus can't be used as an initializer.
0868  */
0869 #define ATA_OP_NULL     (void *)(unsigned long)(-ENOENT)
0870
0871 struct ata_port_operations {
0872     /*
0873      * Command execution
0874      */
0875     int (*qc_defer)(struct ata_queued_cmd *qc);
0876     int (*check_atapi_dma)(struct ata_queued_cmd *qc);
0877     enum ata_completion_errors (*qc_prep)(struct ata_queued_cmd *qc);
0878     unsigned int (*qc_issue)(struct ata_queued_cmd *qc);
0879     bool (*qc_fill_rtf)(struct ata_queued_cmd *qc);
0880
0881     /*
0882      * Configuration and exception handling
0883      */
0884     int  (*cable_detect)(struct ata_port *ap);
0885     unsigned int (*mode_filter)(struct ata_device *dev, unsigned int xfer_mask);
0886     void (*set_piomode)(struct ata_port *ap, struct ata_device *dev);
0887     void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev);
0888     int  (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev);
0889     unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf,
0890                 __le16 *id);
0891
0892     void (*dev_config)(struct ata_device *dev);
0893
0894     void (*freeze)(struct ata_port *ap);
0895     void (*thaw)(struct ata_port *ap);
0896     ata_prereset_fn_t   prereset;
0897     ata_reset_fn_t      softreset;
0898     ata_reset_fn_t      hardreset;
0899     ata_postreset_fn_t  postreset;
0900     ata_prereset_fn_t   pmp_prereset;
0901     ata_reset_fn_t      pmp_softreset;
0902     ata_reset_fn_t      pmp_hardreset;
0903     ata_postreset_fn_t  pmp_postreset;
0904     void (*error_handler)(struct ata_port *ap);
0905     void (*lost_interrupt)(struct ata_port *ap);
0906     void (*post_internal_cmd)(struct ata_queued_cmd *qc);
0907     void (*sched_eh)(struct ata_port *ap);
0908     void (*end_eh)(struct ata_port *ap);
0909
0910     /*
0911      * Optional features
0912      */
0913     int  (*scr_read)(struct ata_link *link, unsigned int sc_reg, u32 *val);
0914     int  (*scr_write)(struct ata_link *link, unsigned int sc_reg, u32 val);
0915     void (*pmp_attach)(struct ata_port *ap);
0916     void (*pmp_detach)(struct ata_port *ap);
0917     int  (*set_lpm)(struct ata_link *link, enum ata_lpm_policy policy,
0918             unsigned hints);
0919
0920     /*
0921      * Start, stop, suspend and resume
0922      */
0923     int  (*port_suspend)(struct ata_port *ap, pm_message_t mesg);
0924     int  (*port_resume)(struct ata_port *ap);
0925     int  (*port_start)(struct ata_port *ap);
0926     void (*port_stop)(struct ata_port *ap);
0927     void (*host_stop)(struct ata_host *host);
0928
0929 #ifdef CONFIG_ATA_SFF
0930     /*
0931      * SFF / taskfile oriented ops
0932      */
0933     void (*sff_dev_select)(struct ata_port *ap, unsigned int device);
0934     void (*sff_set_devctl)(struct ata_port *ap, u8 ctl);
0935     u8   (*sff_check_status)(struct ata_port *ap);
0936     u8   (*sff_check_altstatus)(struct ata_port *ap);
0937     void (*sff_tf_load)(struct ata_port *ap, const struct ata_taskfile *tf);
0938     void (*sff_tf_read)(struct ata_port *ap, struct ata_taskfile *tf);
0939     void (*sff_exec_command)(struct ata_port *ap,
0940                  const struct ata_taskfile *tf);
0941     unsigned int (*sff_data_xfer)(struct ata_queued_cmd *qc,
0942             unsigned char *buf, unsigned int buflen, int rw);
0943     void (*sff_irq_on)(struct ata_port *);
0944     bool (*sff_irq_check)(struct ata_port *);
0945     void (*sff_irq_clear)(struct ata_port *);
0946     void (*sff_drain_fifo)(struct ata_queued_cmd *qc);
0947
0948 #ifdef CONFIG_ATA_BMDMA
0949     void (*bmdma_setup)(struct ata_queued_cmd *qc);
0950     void (*bmdma_start)(struct ata_queued_cmd *qc);
0951     void (*bmdma_stop)(struct ata_queued_cmd *qc);
0952     u8   (*bmdma_status)(struct ata_port *ap);
0953 #endif /* CONFIG_ATA_BMDMA */
0954 #endif /* CONFIG_ATA_SFF */
0955
0956     ssize_t (*em_show)(struct ata_port *ap, char *buf);
0957     ssize_t (*em_store)(struct ata_port *ap, const char *message,
0958                 size_t size);
0959     ssize_t (*sw_activity_show)(struct ata_device *dev, char *buf);
0960     ssize_t (*sw_activity_store)(struct ata_device *dev,
0961                      enum sw_activity val);
0962     ssize_t (*transmit_led_message)(struct ata_port *ap, u32 state,
0963                     ssize_t size);
0964
0965     /*
0966      * Obsolete
0967      */
0968     void (*phy_reset)(struct ata_port *ap);
0969     void (*eng_timeout)(struct ata_port *ap);
0970
0971     /*
0972      * ->inherits must be the last field and all the preceding
0973      * fields must be pointers.
0974      */
0975     const struct ata_port_operations    *inherits;
0976 };
0977
0978 struct ata_port_info {
0979     unsigned long       flags;
0980     unsigned long       link_flags;
0981     unsigned int        pio_mask;
0982     unsigned int        mwdma_mask;
0983     unsigned int        udma_mask;
0984     struct ata_port_operations *port_ops;
0985     void            *private_data;
0986 };
0987
0988 struct ata_timing {
0989     unsigned short mode;        /* ATA mode */
0990     unsigned short setup;       /* t1 */
0991     unsigned short act8b;       /* t2 for 8-bit I/O */
0992     unsigned short rec8b;       /* t2i for 8-bit I/O */
0993     unsigned short cyc8b;       /* t0 for 8-bit I/O */
0994     unsigned short active;      /* t2 or tD */
0995     unsigned short recover;     /* t2i or tK */
0996     unsigned short dmack_hold;  /* tj */
0997     unsigned short cycle;       /* t0 */
0998     unsigned short udma;        /* t2CYCTYP/2 */
0999 };
1000
1001 /*
1002  * Core layer - drivers/ata/libata-core.c
1003  */
1004 extern struct ata_port_operations ata_dummy_port_ops;
1005 extern const struct ata_port_info ata_dummy_port_info;
1006
1007 static inline bool ata_is_atapi(u8 prot)
1008 {
1009     return prot & ATA_PROT_FLAG_ATAPI;
1010 }
1011
1012 static inline bool ata_is_pio(u8 prot)
1013 {
1014     return prot & ATA_PROT_FLAG_PIO;
1015 }
1016
1017 static inline bool ata_is_dma(u8 prot)
1018 {
1019     return prot & ATA_PROT_FLAG_DMA;
1020 }
1021
1022 static inline bool ata_is_ncq(u8 prot)
1023 {
1024     return prot & ATA_PROT_FLAG_NCQ;
1025 }
1026
1027 static inline bool ata_is_data(u8 prot)
1028 {
1029     return prot & (ATA_PROT_FLAG_PIO | ATA_PROT_FLAG_DMA);
1030 }
1031
1032 static inline int is_multi_taskfile(struct ata_taskfile *tf)
1033 {
1034     return (tf->command == ATA_CMD_READ_MULTI) ||
1035            (tf->command == ATA_CMD_WRITE_MULTI) ||
1036            (tf->command == ATA_CMD_READ_MULTI_EXT) ||
1037            (tf->command == ATA_CMD_WRITE_MULTI_EXT) ||
1038            (tf->command == ATA_CMD_WRITE_MULTI_FUA_EXT);
1039 }
1040
1041 static inline int ata_port_is_dummy(struct ata_port *ap)
1042 {
1043     return ap->ops == &ata_dummy_port_ops;
1044 }
1045
1046 extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
1047 extern int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
1048                 int (*check_ready)(struct ata_link *link));
1049 extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
1050                   unsigned long deadline);
1051 extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
1052
1053 extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
1054 extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
1055             const struct ata_port_info * const * ppi, int n_ports);
1056 extern void ata_host_get(struct ata_host *host);
1057 extern void ata_host_put(struct ata_host *host);
1058 extern int ata_host_start(struct ata_host *host);
1059 extern int ata_host_register(struct ata_host *host,
1060                  struct scsi_host_template *sht);
1061 extern int ata_host_activate(struct ata_host *host, int irq,
1062                  irq_handler_t irq_handler, unsigned long irq_flags,
1063                  struct scsi_host_template *sht);
1064 extern void ata_host_detach(struct ata_host *host);
1065 extern void ata_host_init(struct ata_host *, struct device *, struct ata_port_operations *);
1066 extern int ata_scsi_detect(struct scsi_host_template *sht);
1067 extern int ata_scsi_ioctl(struct scsi_device *dev, unsigned int cmd,
1068               void __user *arg);
1069 #ifdef CONFIG_COMPAT
1070 #define ATA_SCSI_COMPAT_IOCTL .compat_ioctl = ata_scsi_ioctl,
1071 #else
1072 #define ATA_SCSI_COMPAT_IOCTL /* empty */
1073 #endif
1074 extern int ata_scsi_queuecmd(struct Scsi_Host *h, struct scsi_cmnd *cmd);
1075 #if IS_REACHABLE(CONFIG_ATA)
1076 bool ata_scsi_dma_need_drain(struct request *rq);
1077 #else
1078 #define ata_scsi_dma_need_drain NULL
1079 #endif
1080 extern int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *dev,
1081                 unsigned int cmd, void __user *arg);
1082 extern bool ata_link_online(struct ata_link *link);
1083 extern bool ata_link_offline(struct ata_link *link);
1084 #ifdef CONFIG_PM
1085 extern void ata_host_suspend(struct ata_host *host, pm_message_t mesg);
1086 extern void ata_host_resume(struct ata_host *host);
1087 extern void ata_sas_port_suspend(struct ata_port *ap);
1088 extern void ata_sas_port_resume(struct ata_port *ap);
1089 #else
1090 static inline void ata_sas_port_suspend(struct ata_port *ap)
1091 {
1092 }
1093 static inline void ata_sas_port_resume(struct ata_port *ap)
1094 {
1095 }
1096 #endif
1097 extern int ata_ratelimit(void);
1098 extern void ata_msleep(struct ata_port *ap, unsigned int msecs);
1099 extern u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask,
1100             u32 val, unsigned long interval, unsigned long timeout);
1101 extern int atapi_cmd_type(u8 opcode);
1102 extern unsigned int ata_pack_xfermask(unsigned int pio_mask,
1103                       unsigned int mwdma_mask,
1104                       unsigned int udma_mask);
1105 extern void ata_unpack_xfermask(unsigned int xfer_mask,
1106                 unsigned int *pio_mask,
1107                 unsigned int *mwdma_mask,
1108                 unsigned int *udma_mask);
1109 extern u8 ata_xfer_mask2mode(unsigned int xfer_mask);
1110 extern unsigned int ata_xfer_mode2mask(u8 xfer_mode);
1111 extern int ata_xfer_mode2shift(u8 xfer_mode);
1112 extern const char *ata_mode_string(unsigned int xfer_mask);
1113 extern unsigned int ata_id_xfermask(const u16 *id);
1114 extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
1115 extern enum ata_completion_errors ata_noop_qc_prep(struct ata_queued_cmd *qc);
1116 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
1117          unsigned int n_elem);
1118 extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
1119 extern unsigned int ata_port_classify(struct ata_port *ap,
1120                       const struct ata_taskfile *tf);
1121 extern void ata_dev_disable(struct ata_device *adev);
1122 extern void ata_id_string(const u16 *id, unsigned char *s,
1123               unsigned int ofs, unsigned int len);
1124 extern void ata_id_c_string(const u16 *id, unsigned char *s,
1125                 unsigned int ofs, unsigned int len);
1126 extern unsigned int ata_do_dev_read_id(struct ata_device *dev,
1127                        struct ata_taskfile *tf, __le16 *id);
1128 extern void ata_qc_complete(struct ata_queued_cmd *qc);
1129 extern u64 ata_qc_get_active(struct ata_port *ap);
1130 extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd);
1131 extern int ata_std_bios_param(struct scsi_device *sdev,
1132                   struct block_device *bdev,
1133                   sector_t capacity, int geom[]);
1134 extern void ata_scsi_unlock_native_capacity(struct scsi_device *sdev);
1135 extern int ata_scsi_slave_config(struct scsi_device *sdev);
1136 extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
1137 extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
1138                        int queue_depth);
1139 extern int ata_change_queue_depth(struct ata_port *ap, struct ata_device *dev,
1140                   struct scsi_device *sdev, int queue_depth);
1141 extern struct ata_device *ata_dev_pair(struct ata_device *adev);
1142 extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
1143 extern void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap);
1144 extern void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap, struct list_head *eh_q);
1145
1146 /*
1147  * SATA specific code - drivers/ata/libata-sata.c
1148  */
1149 #ifdef CONFIG_SATA_HOST
1150 extern const unsigned long sata_deb_timing_normal[];
1151 extern const unsigned long sata_deb_timing_hotplug[];
1152 extern const unsigned long sata_deb_timing_long[];
1153
1154 static inline const unsigned long *
1155 sata_ehc_deb_timing(struct ata_eh_context *ehc)
1156 {
1157     if (ehc->i.flags & ATA_EHI_HOTPLUGGED)
1158         return sata_deb_timing_hotplug;
1159     else
1160         return sata_deb_timing_normal;
1161 }
1162
1163 extern int sata_scr_valid(struct ata_link *link);
1164 extern int sata_scr_read(struct ata_link *link, int reg, u32 *val);
1165 extern int sata_scr_write(struct ata_link *link, int reg, u32 val);
1166 extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val);
1167 extern int sata_set_spd(struct ata_link *link);
1168 extern int sata_link_hardreset(struct ata_link *link,
1169             const unsigned long *timing, unsigned long deadline,
1170             bool *online, int (*check_ready)(struct ata_link *));
1171 extern int sata_link_resume(struct ata_link *link, const unsigned long *params,
1172                 unsigned long deadline);
1173 extern void ata_eh_analyze_ncq_error(struct ata_link *link);
1174 #else
1175 static inline const unsigned long *
1176 sata_ehc_deb_timing(struct ata_eh_context *ehc)
1177 {
1178     return NULL;
1179 }
1180 static inline int sata_scr_valid(struct ata_link *link) { return 0; }
1181 static inline int sata_scr_read(struct ata_link *link, int reg, u32 *val)
1182 {
1183     return -EOPNOTSUPP;
1184 }
1185 static inline int sata_scr_write(struct ata_link *link, int reg, u32 val)
1186 {
1187     return -EOPNOTSUPP;
1188 }
1189 static inline int sata_scr_write_flush(struct ata_link *link, int reg, u32 val)
1190 {
1191     return -EOPNOTSUPP;
1192 }
1193 static inline int sata_set_spd(struct ata_link *link) { return -EOPNOTSUPP; }
1194 static inline int sata_link_hardreset(struct ata_link *link,
1195                       const unsigned long *timing,
1196                       unsigned long deadline,
1197                       bool *online,
1198                       int (*check_ready)(struct ata_link *))
1199 {
1200     if (online)
1201         *online = false;
1202     return -EOPNOTSUPP;
1203 }
1204 static inline int sata_link_resume(struct ata_link *link,
1205                    const unsigned long *params,
1206                    unsigned long deadline)
1207 {
1208     return -EOPNOTSUPP;
1209 }
1210 static inline void ata_eh_analyze_ncq_error(struct ata_link *link) { }
1211 #endif
1212 extern int sata_link_debounce(struct ata_link *link,
1213             const unsigned long *params, unsigned long deadline);
1214 extern int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
1215                  bool spm_wakeup);
1216 extern int ata_slave_link_init(struct ata_port *ap);
1217 extern void ata_sas_port_destroy(struct ata_port *);
1218 extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
1219                        struct ata_port_info *, struct Scsi_Host *);
1220 extern void ata_sas_async_probe(struct ata_port *ap);
1221 extern int ata_sas_sync_probe(struct ata_port *ap);
1222 extern int ata_sas_port_init(struct ata_port *);
1223 extern int ata_sas_port_start(struct ata_port *ap);
1224 extern int ata_sas_tport_add(struct device *parent, struct ata_port *ap);
1225 extern void ata_sas_tport_delete(struct ata_port *ap);
1226 extern void ata_sas_port_stop(struct ata_port *ap);
1227 extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *);
1228 extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap);
1229 extern void ata_tf_to_fis(const struct ata_taskfile *tf,
1230               u8 pmp, int is_cmd, u8 *fis);
1231 extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
1232 extern int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active);
1233 extern bool sata_lpm_ignore_phy_events(struct ata_link *link);
1234 extern int sata_async_notification(struct ata_port *ap);
1235
1236 extern int ata_cable_40wire(struct ata_port *ap);
1237 extern int ata_cable_80wire(struct ata_port *ap);
1238 extern int ata_cable_sata(struct ata_port *ap);
1239 extern int ata_cable_ignore(struct ata_port *ap);
1240 extern int ata_cable_unknown(struct ata_port *ap);
1241
1242 /* Timing helpers */
1243 extern unsigned int ata_pio_need_iordy(const struct ata_device *);
1244 extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle);
1245
1246 /* PCI */
1247 #ifdef CONFIG_PCI
1248 struct pci_dev;
1249
1250 struct pci_bits {
1251     unsigned int        reg;    /* PCI config register to read */
1252     unsigned int        width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
1253     unsigned long       mask;
1254     unsigned long       val;
1255 };
1256
1257 extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
1258 extern void ata_pci_shutdown_one(struct pci_dev *pdev);
1259 extern void ata_pci_remove_one(struct pci_dev *pdev);
1260
1261 #ifdef CONFIG_PM
1262 extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
1263 extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
1264 extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
1265 extern int ata_pci_device_resume(struct pci_dev *pdev);
1266 #endif /* CONFIG_PM */
1267 #endif /* CONFIG_PCI */
1268
1269 struct platform_device;
1270
1271 extern int ata_platform_remove_one(struct platform_device *pdev);
1272
1273 /*
1274  * ACPI - drivers/ata/libata-acpi.c
1275  */
1276 #ifdef CONFIG_ATA_ACPI
1277 static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
1278 {
1279     if (ap->pflags & ATA_PFLAG_INIT_GTM_VALID)
1280         return &ap->__acpi_init_gtm;
1281     return NULL;
1282 }
1283 int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm);
1284 int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm);
1285 unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev,
1286                    const struct ata_acpi_gtm *gtm);
1287 int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm);
1288 #else
1289 static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
1290 {
1291     return NULL;
1292 }
1293
1294 static inline int ata_acpi_stm(const struct ata_port *ap,
1295                    struct ata_acpi_gtm *stm)
1296 {
1297     return -ENOSYS;
1298 }
1299
1300 static inline int ata_acpi_gtm(const struct ata_port *ap,
1301                    struct ata_acpi_gtm *stm)
1302 {
1303     return -ENOSYS;
1304 }
1305
1306 static inline unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev,
1307                     const struct ata_acpi_gtm *gtm)
1308 {
1309     return 0;
1310 }
1311
1312 static inline int ata_acpi_cbl_80wire(struct ata_port *ap,
1313                       const struct ata_acpi_gtm *gtm)
1314 {
1315     return 0;
1316 }
1317 #endif
1318
1319 /*
1320  * EH - drivers/ata/libata-eh.c
1321  */
1322 extern void ata_port_schedule_eh(struct ata_port *ap);
1323 extern void ata_port_wait_eh(struct ata_port *ap);
1324 extern int ata_link_abort(struct ata_link *link);
1325 extern int ata_port_abort(struct ata_port *ap);
1326 extern int ata_port_freeze(struct ata_port *ap);
1327
1328 extern void ata_eh_freeze_port(struct ata_port *ap);
1329 extern void ata_eh_thaw_port(struct ata_port *ap);
1330
1331 extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
1332 extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
1333
1334 extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
1335               ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
1336               ata_postreset_fn_t postreset);
1337 extern void ata_std_error_handler(struct ata_port *ap);
1338 extern void ata_std_sched_eh(struct ata_port *ap);
1339 extern void ata_std_end_eh(struct ata_port *ap);
1340 extern int ata_link_nr_enabled(struct ata_link *link);
1341
1342 /*
1343  * Base operations to inherit from and initializers for sht
1344  *
1345  * Operations
1346  *
1347  * base  : Common to all libata drivers.
1348  * sata  : SATA controllers w/ native interface.
1349  * pmp   : SATA controllers w/ PMP support.
1350  * sff   : SFF ATA controllers w/o BMDMA support.
1351  * bmdma : SFF ATA controllers w/ BMDMA support.
1352  *
1353  * sht initializers
1354  *
1355  * BASE  : Common to all libata drivers.  The user must set
1356  *     sg_tablesize and dma_boundary.
1357  * PIO   : SFF ATA controllers w/ only PIO support.
1358  * BMDMA : SFF ATA controllers w/ BMDMA support.  sg_tablesize and
1359  *     dma_boundary are set to BMDMA limits.
1360  * NCQ   : SATA controllers supporting NCQ.  The user must set
1361  *     sg_tablesize, dma_boundary and can_queue.
1362  */
1363 extern const struct ata_port_operations ata_base_port_ops;
1364 extern const struct ata_port_operations sata_port_ops;
1365 extern const struct attribute_group *ata_common_sdev_groups[];
1366
1367 /*
1368  * All sht initializers (BASE, PIO, BMDMA, NCQ) must be instantiated
1369  * by the edge drivers.  Because the 'module' field of sht must be the
1370  * edge driver's module reference, otherwise the driver can be unloaded
1371  * even if the scsi_device is being accessed.
1372  */
1373 #define __ATA_BASE_SHT(drv_name)                \
1374     .module         = THIS_MODULE,          \
1375     .name           = drv_name,         \
1376     .ioctl          = ata_scsi_ioctl,       \
1377     ATA_SCSI_COMPAT_IOCTL                   \
1378     .queuecommand       = ata_scsi_queuecmd,        \
1379     .dma_need_drain     = ata_scsi_dma_need_drain,  \
1380     .this_id        = ATA_SHT_THIS_ID,      \
1381     .emulated       = ATA_SHT_EMULATED,     \
1382     .proc_name      = drv_name,         \
1383     .slave_destroy      = ata_scsi_slave_destroy,   \
1384     .bios_param     = ata_std_bios_param,       \
1385     .unlock_native_capacity = ata_scsi_unlock_native_capacity,\
1386     .max_sectors        = ATA_MAX_SECTORS_LBA48
1387
1388 #define ATA_SUBBASE_SHT(drv_name)               \
1389     __ATA_BASE_SHT(drv_name),               \
1390     .can_queue      = ATA_DEF_QUEUE,        \
1391     .tag_alloc_policy   = BLK_TAG_ALLOC_RR,     \
1392     .slave_configure    = ata_scsi_slave_config
1393
1394 #define ATA_SUBBASE_SHT_QD(drv_name, drv_qd)            \
1395     __ATA_BASE_SHT(drv_name),               \
1396     .can_queue      = drv_qd,           \
1397     .tag_alloc_policy   = BLK_TAG_ALLOC_RR,     \
1398     .slave_configure    = ata_scsi_slave_config
1399
1400 #define ATA_BASE_SHT(drv_name)                  \
1401     ATA_SUBBASE_SHT(drv_name),              \
1402     .sdev_groups        = ata_common_sdev_groups
1403
1404 #ifdef CONFIG_SATA_HOST
1405 extern const struct attribute_group *ata_ncq_sdev_groups[];
1406
1407 #define ATA_NCQ_SHT(drv_name)                   \
1408     ATA_SUBBASE_SHT(drv_name),              \
1409     .sdev_groups        = ata_ncq_sdev_groups,      \
1410     .change_queue_depth = ata_scsi_change_queue_depth
1411
1412 #define ATA_NCQ_SHT_QD(drv_name, drv_qd)            \
1413     ATA_SUBBASE_SHT_QD(drv_name, drv_qd),           \
1414     .sdev_groups        = ata_ncq_sdev_groups,      \
1415     .change_queue_depth = ata_scsi_change_queue_depth
1416 #endif
1417
1418 /*
1419  * PMP helpers
1420  */
1421 #ifdef CONFIG_SATA_PMP
1422 static inline bool sata_pmp_supported(struct ata_port *ap)
1423 {
1424     return ap->flags & ATA_FLAG_PMP;
1425 }
1426
1427 static inline bool sata_pmp_attached(struct ata_port *ap)
1428 {
1429     return ap->nr_pmp_links != 0;
1430 }
1431
1432 static inline bool ata_is_host_link(const struct ata_link *link)
1433 {
1434     return link == &link->ap->link || link == link->ap->slave_link;
1435 }
1436 #else /* CONFIG_SATA_PMP */
1437 static inline bool sata_pmp_supported(struct ata_port *ap)
1438 {
1439     return false;
1440 }
1441
1442 static inline bool sata_pmp_attached(struct ata_port *ap)
1443 {
1444     return false;
1445 }
1446
1447 static inline bool ata_is_host_link(const struct ata_link *link)
1448 {
1449     return true;
1450 }
1451 #endif /* CONFIG_SATA_PMP */
1452
1453 static inline int sata_srst_pmp(struct ata_link *link)
1454 {
1455     if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
1456         return SATA_PMP_CTRL_PORT;
1457     return link->pmp;
1458 }
1459
1460 #define ata_port_printk(level, ap, fmt, ...)            \
1461     pr_ ## level ("ata%u: " fmt, (ap)->print_id, ##__VA_ARGS__)
1462
1463 #define ata_port_err(ap, fmt, ...)              \
1464     ata_port_printk(err, ap, fmt, ##__VA_ARGS__)
1465 #define ata_port_warn(ap, fmt, ...)             \
1466     ata_port_printk(warn, ap, fmt, ##__VA_ARGS__)
1467 #define ata_port_notice(ap, fmt, ...)               \
1468     ata_port_printk(notice, ap, fmt, ##__VA_ARGS__)
1469 #define ata_port_info(ap, fmt, ...)             \
1470     ata_port_printk(info, ap, fmt, ##__VA_ARGS__)
1471 #define ata_port_dbg(ap, fmt, ...)              \
1472     ata_port_printk(debug, ap, fmt, ##__VA_ARGS__)
1473
1474 #define ata_link_printk(level, link, fmt, ...)          \
1475 do {                                \
1476     if (sata_pmp_attached((link)->ap) ||            \
1477         (link)->ap->slave_link)             \
1478         pr_ ## level ("ata%u.%02u: " fmt,       \
1479                   (link)->ap->print_id,     \
1480                   (link)->pmp,          \
1481                   ##__VA_ARGS__);           \
1482         else                            \
1483         pr_ ## level ("ata%u: " fmt,            \
1484                   (link)->ap->print_id,     \
1485                   ##__VA_ARGS__);           \
1486 } while (0)
1487
1488 #define ata_link_err(link, fmt, ...)                \
1489     ata_link_printk(err, link, fmt, ##__VA_ARGS__)
1490 #define ata_link_warn(link, fmt, ...)               \
1491     ata_link_printk(warn, link, fmt, ##__VA_ARGS__)
1492 #define ata_link_notice(link, fmt, ...)             \
1493     ata_link_printk(notice, link, fmt, ##__VA_ARGS__)
1494 #define ata_link_info(link, fmt, ...)               \
1495     ata_link_printk(info, link, fmt, ##__VA_ARGS__)
1496 #define ata_link_dbg(link, fmt, ...)                \
1497     ata_link_printk(debug, link, fmt, ##__VA_ARGS__)
1498
1499 #define ata_dev_printk(level, dev, fmt, ...)            \
1500         pr_ ## level("ata%u.%02u: " fmt,            \
1501                (dev)->link->ap->print_id,           \
1502            (dev)->link->pmp + (dev)->devno,         \
1503            ##__VA_ARGS__)
1504
1505 #define ata_dev_err(dev, fmt, ...)              \
1506     ata_dev_printk(err, dev, fmt, ##__VA_ARGS__)
1507 #define ata_dev_warn(dev, fmt, ...)             \
1508     ata_dev_printk(warn, dev, fmt, ##__VA_ARGS__)
1509 #define ata_dev_notice(dev, fmt, ...)               \
1510     ata_dev_printk(notice, dev, fmt, ##__VA_ARGS__)
1511 #define ata_dev_info(dev, fmt, ...)             \
1512     ata_dev_printk(info, dev, fmt, ##__VA_ARGS__)
1513 #define ata_dev_dbg(dev, fmt, ...)              \
1514     ata_dev_printk(debug, dev, fmt, ##__VA_ARGS__)
1515
1516 void ata_print_version(const struct device *dev, const char *version);
1517
1518 /*
1519  * ata_eh_info helpers
1520  */
1521 extern __printf(2, 3)
1522 void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
1523 extern __printf(2, 3)
1524 void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
1525 extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
1526
1527 static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
1528 {
1529     ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
1530     ehi->flags |= ATA_EHI_HOTPLUGGED;
1531     ehi->action |= ATA_EH_RESET | ATA_EH_ENABLE_LINK;
1532     ehi->err_mask |= AC_ERR_ATA_BUS;
1533 }
1534
1535 /*
1536  * port description helpers
1537  */
1538 extern __printf(2, 3)
1539 void ata_port_desc(struct ata_port *ap, const char *fmt, ...);
1540 #ifdef CONFIG_PCI
1541 extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
1542                    const char *name);
1543 #endif
1544
1545 static inline bool ata_tag_internal(unsigned int tag)
1546 {
1547     return tag == ATA_TAG_INTERNAL;
1548 }
1549
1550 static inline bool ata_tag_valid(unsigned int tag)
1551 {
1552     return tag < ATA_MAX_QUEUE || ata_tag_internal(tag);
1553 }
1554
1555 #define __ata_qc_for_each(ap, qc, tag, max_tag, fn)     \
1556     for ((tag) = 0; (tag) < (max_tag) &&            \
1557          ({ qc = fn((ap), (tag)); 1; }); (tag)++)       \
1558
1559 /*
1560  * Internal use only, iterate commands ignoring error handling and
1561  * status of 'qc'.
1562  */
1563 #define ata_qc_for_each_raw(ap, qc, tag)                    \
1564     __ata_qc_for_each(ap, qc, tag, ATA_MAX_QUEUE, __ata_qc_from_tag)
1565
1566 /*
1567  * Iterate all potential commands that can be queued
1568  */
1569 #define ata_qc_for_each(ap, qc, tag)                    \
1570     __ata_qc_for_each(ap, qc, tag, ATA_MAX_QUEUE, ata_qc_from_tag)
1571
1572 /*
1573  * Like ata_qc_for_each, but with the internal tag included
1574  */
1575 #define ata_qc_for_each_with_internal(ap, qc, tag)          \
1576     __ata_qc_for_each(ap, qc, tag, ATA_MAX_QUEUE + 1, ata_qc_from_tag)
1577
1578 /*
1579  * device helpers
1580  */
1581 static inline unsigned int ata_class_enabled(unsigned int class)
1582 {
1583     return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI ||
1584         class == ATA_DEV_PMP || class == ATA_DEV_SEMB ||
1585         class == ATA_DEV_ZAC;
1586 }
1587
1588 static inline unsigned int ata_class_disabled(unsigned int class)
1589 {
1590     return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP ||
1591         class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP ||
1592         class == ATA_DEV_ZAC_UNSUP;
1593 }
1594
1595 static inline unsigned int ata_class_absent(unsigned int class)
1596 {
1597     return !ata_class_enabled(class) && !ata_class_disabled(class);
1598 }
1599
1600 static inline unsigned int ata_dev_enabled(const struct ata_device *dev)
1601 {
1602     return ata_class_enabled(dev->class);
1603 }
1604
1605 static inline unsigned int ata_dev_disabled(const struct ata_device *dev)
1606 {
1607     return ata_class_disabled(dev->class);
1608 }
1609
1610 static inline unsigned int ata_dev_absent(const struct ata_device *dev)
1611 {
1612     return ata_class_absent(dev->class);
1613 }
1614
1615 /*
1616  * link helpers
1617  */
1618 static inline int ata_link_max_devices(const struct ata_link *link)
1619 {
1620     if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS)
1621         return 2;
1622     return 1;
1623 }
1624
1625 static inline int ata_link_active(struct ata_link *link)
1626 {
1627     return ata_tag_valid(link->active_tag) || link->sactive;
1628 }
1629
1630 /*
1631  * Iterators
1632  *
1633  * ATA_LITER_* constants are used to select link iteration mode and
1634  * ATA_DITER_* device iteration mode.
1635  *
1636  * For a custom iteration directly using ata_{link|dev}_next(), if
1637  * @link or @dev, respectively, is NULL, the first element is
1638  * returned.  @dev and @link can be any valid device or link and the
1639  * next element according to the iteration mode will be returned.
1640  * After the last element, NULL is returned.
1641  */
1642 enum ata_link_iter_mode {
1643     ATA_LITER_EDGE,     /* if present, PMP links only; otherwise,
1644                  * host link.  no slave link */
1645     ATA_LITER_HOST_FIRST,   /* host link followed by PMP or slave links */
1646     ATA_LITER_PMP_FIRST,    /* PMP links followed by host link,
1647                  * slave link still comes after host link */
1648 };
1649
1650 enum ata_dev_iter_mode {
1651     ATA_DITER_ENABLED,
1652     ATA_DITER_ENABLED_REVERSE,
1653     ATA_DITER_ALL,
1654     ATA_DITER_ALL_REVERSE,
1655 };
1656
1657 extern struct ata_link *ata_link_next(struct ata_link *link,
1658                       struct ata_port *ap,
1659                       enum ata_link_iter_mode mode);
1660
1661 extern struct ata_device *ata_dev_next(struct ata_device *dev,
1662                        struct ata_link *link,
1663                        enum ata_dev_iter_mode mode);
1664
1665 /*
1666  * Shortcut notation for iterations
1667  *
1668  * ata_for_each_link() iterates over each link of @ap according to
1669  * @mode.  @link points to the current link in the loop.  @link is
1670  * NULL after loop termination.  ata_for_each_dev() works the same way
1671  * except that it iterates over each device of @link.
1672  *
1673  * Note that the mode prefixes ATA_{L|D}ITER_ shouldn't need to be
1674  * specified when using the following shorthand notations.  Only the
1675  * mode itself (EDGE, HOST_FIRST, ENABLED, etc...) should be
1676  * specified.  This not only increases brevity but also makes it
1677  * impossible to use ATA_LITER_* for device iteration or vice-versa.
1678  */
1679 #define ata_for_each_link(link, ap, mode) \
1680     for ((link) = ata_link_next(NULL, (ap), ATA_LITER_##mode); (link); \
1681          (link) = ata_link_next((link), (ap), ATA_LITER_##mode))
1682
1683 #define ata_for_each_dev(dev, link, mode) \
1684     for ((dev) = ata_dev_next(NULL, (link), ATA_DITER_##mode); (dev); \
1685          (dev) = ata_dev_next((dev), (link), ATA_DITER_##mode))
1686
1687 /**
1688  *  ata_ncq_enabled - Test whether NCQ is enabled
1689  *  @dev: ATA device to test for
1690  *
1691  *  LOCKING:
1692  *  spin_lock_irqsave(host lock)
1693  *
1694  *  RETURNS:
1695  *  1 if NCQ is enabled for @dev, 0 otherwise.
1696  */
1697 static inline int ata_ncq_enabled(struct ata_device *dev)
1698 {
1699     if (!IS_ENABLED(CONFIG_SATA_HOST))
1700         return 0;
1701     return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
1702                   ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ;
1703 }
1704
1705 static inline bool ata_fpdma_dsm_supported(struct ata_device *dev)
1706 {
1707     return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
1708         (dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &
1709          ATA_LOG_NCQ_SEND_RECV_DSM_TRIM);
1710 }
1711
1712 static inline bool ata_fpdma_read_log_supported(struct ata_device *dev)
1713 {
1714     return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
1715         (dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_RD_LOG_OFFSET] &
1716          ATA_LOG_NCQ_SEND_RECV_RD_LOG_SUPPORTED);
1717 }
1718
1719 static inline bool ata_fpdma_zac_mgmt_in_supported(struct ata_device *dev)
1720 {
1721     return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
1722         (dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_OFFSET] &
1723         ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_IN_SUPPORTED);
1724 }
1725
1726 static inline bool ata_fpdma_zac_mgmt_out_supported(struct ata_device *dev)
1727 {
1728     return (dev->ncq_non_data_cmds[ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OFFSET] &
1729         ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OUT);
1730 }
1731
1732 static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
1733 {
1734     qc->tf.ctl |= ATA_NIEN;
1735 }
1736
1737 static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
1738                                unsigned int tag)
1739 {
1740     if (ata_tag_valid(tag))
1741         return &ap->qcmd[tag];
1742     return NULL;
1743 }
1744
1745 static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap,
1746                              unsigned int tag)
1747 {
1748     struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1749
1750     if (unlikely(!qc) || !ap->ops->error_handler)
1751         return qc;
1752
1753     if ((qc->flags & (ATA_QCFLAG_ACTIVE |
1754               ATA_QCFLAG_FAILED)) == ATA_QCFLAG_ACTIVE)
1755         return qc;
1756
1757     return NULL;
1758 }
1759
1760 static inline unsigned int ata_qc_raw_nbytes(struct ata_queued_cmd *qc)
1761 {
1762     return qc->nbytes - min(qc->extrabytes, qc->nbytes);
1763 }
1764
1765 static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
1766 {
1767     memset(tf, 0, sizeof(*tf));
1768
1769 #ifdef CONFIG_ATA_SFF
1770     tf->ctl = dev->link->ap->ctl;
1771 #else
1772     tf->ctl = ATA_DEVCTL_OBS;
1773 #endif
1774     if (dev->devno == 0)
1775         tf->device = ATA_DEVICE_OBS;
1776     else
1777         tf->device = ATA_DEVICE_OBS | ATA_DEV1;
1778 }
1779
1780 static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
1781 {
1782     qc->dma_dir = DMA_NONE;
1783     qc->sg = NULL;
1784     qc->flags = 0;
1785     qc->cursg = NULL;
1786     qc->cursg_ofs = 0;
1787     qc->nbytes = qc->extrabytes = qc->curbytes = 0;
1788     qc->n_elem = 0;
1789     qc->err_mask = 0;
1790     qc->sect_size = ATA_SECT_SIZE;
1791
1792     ata_tf_init(qc->dev, &qc->tf);
1793
1794     /* init result_tf such that it indicates normal completion */
1795     qc->result_tf.command = ATA_DRDY;
1796     qc->result_tf.feature = 0;
1797 }
1798
1799 static inline int ata_try_flush_cache(const struct ata_device *dev)
1800 {
1801     return ata_id_wcache_enabled(dev->id) ||
1802            ata_id_has_flush(dev->id) ||
1803            ata_id_has_flush_ext(dev->id);
1804 }
1805
1806 static inline unsigned int ac_err_mask(u8 status)
1807 {
1808     if (status & (ATA_BUSY | ATA_DRQ))
1809         return AC_ERR_HSM;
1810     if (status & (ATA_ERR | ATA_DF))
1811         return AC_ERR_DEV;
1812     return 0;
1813 }
1814
1815 static inline unsigned int __ac_err_mask(u8 status)
1816 {
1817     unsigned int mask = ac_err_mask(status);
1818     if (mask == 0)
1819         return AC_ERR_OTHER;
1820     return mask;
1821 }
1822
1823 static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host)
1824 {
1825     return *(struct ata_port **)&host->hostdata[0];
1826 }
1827
1828 static inline int ata_check_ready(u8 status)
1829 {
1830     if (!(status & ATA_BUSY))
1831         return 1;
1832
1833     /* 0xff indicates either no device or device not ready */
1834     if (status == 0xff)
1835         return -ENODEV;
1836
1837     return 0;
1838 }
1839
1840 static inline unsigned long ata_deadline(unsigned long from_jiffies,
1841                      unsigned long timeout_msecs)
1842 {
1843     return from_jiffies + msecs_to_jiffies(timeout_msecs);
1844 }
1845
1846 /* Don't open code these in drivers as there are traps. Firstly the range may
1847    change in future hardware and specs, secondly 0xFF means 'no DMA' but is
1848    > UDMA_0. Dyma ddreigiau */
1849
1850 static inline int ata_using_mwdma(struct ata_device *adev)
1851 {
1852     if (adev->dma_mode >= XFER_MW_DMA_0 && adev->dma_mode <= XFER_MW_DMA_4)
1853         return 1;
1854     return 0;
1855 }
1856
1857 static inline int ata_using_udma(struct ata_device *adev)
1858 {
1859     if (adev->dma_mode >= XFER_UDMA_0 && adev->dma_mode <= XFER_UDMA_7)
1860         return 1;
1861     return 0;
1862 }
1863
1864 static inline int ata_dma_enabled(struct ata_device *adev)
1865 {
1866     return (adev->dma_mode == 0xFF ? 0 : 1);
1867 }
1868
1869 /**************************************************************************
1870  * PATA timings - drivers/ata/libata-pata-timings.c
1871  */
1872 extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);
1873 extern int ata_timing_compute(struct ata_device *, unsigned short,
1874                   struct ata_timing *, int, int);
1875 extern void ata_timing_merge(const struct ata_timing *,
1876                  const struct ata_timing *, struct ata_timing *,
1877                  unsigned int);
1878
1879 /**************************************************************************
1880  * PMP - drivers/ata/libata-pmp.c
1881  */
1882 #ifdef CONFIG_SATA_PMP
1883
1884 extern const struct ata_port_operations sata_pmp_port_ops;
1885
1886 extern int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc);
1887 extern void sata_pmp_error_handler(struct ata_port *ap);
1888
1889 #else /* CONFIG_SATA_PMP */
1890
1891 #define sata_pmp_port_ops       sata_port_ops
1892 #define sata_pmp_qc_defer_cmd_switch    ata_std_qc_defer
1893 #define sata_pmp_error_handler      ata_std_error_handler
1894
1895 #endif /* CONFIG_SATA_PMP */
1896
1897
1898 /**************************************************************************
1899  * SFF - drivers/ata/libata-sff.c
1900  */
1901 #ifdef CONFIG_ATA_SFF
1902
1903 extern const struct ata_port_operations ata_sff_port_ops;
1904 extern const struct ata_port_operations ata_bmdma32_port_ops;
1905
1906 /* PIO only, sg_tablesize and dma_boundary limits can be removed */
1907 #define ATA_PIO_SHT(drv_name)                   \
1908     ATA_BASE_SHT(drv_name),                 \
1909     .sg_tablesize       = LIBATA_MAX_PRD,       \
1910     .dma_boundary       = ATA_DMA_BOUNDARY
1911
1912 extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device);
1913 extern u8 ata_sff_check_status(struct ata_port *ap);
1914 extern void ata_sff_pause(struct ata_port *ap);
1915 extern void ata_sff_dma_pause(struct ata_port *ap);
1916 extern int ata_sff_busy_sleep(struct ata_port *ap,
1917                   unsigned long timeout_pat, unsigned long timeout);
1918 extern int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline);
1919 extern void ata_sff_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
1920 extern void ata_sff_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
1921 extern void ata_sff_exec_command(struct ata_port *ap,
1922                  const struct ata_taskfile *tf);
1923 extern unsigned int ata_sff_data_xfer(struct ata_queued_cmd *qc,
1924             unsigned char *buf, unsigned int buflen, int rw);
1925 extern unsigned int ata_sff_data_xfer32(struct ata_queued_cmd *qc,
1926             unsigned char *buf, unsigned int buflen, int rw);
1927 extern void ata_sff_irq_on(struct ata_port *ap);
1928 extern void ata_sff_irq_clear(struct ata_port *ap);
1929 extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
1930                 u8 status, int in_wq);
1931 extern void ata_sff_queue_work(struct work_struct *work);
1932 extern void ata_sff_queue_delayed_work(struct delayed_work *dwork,
1933         unsigned long delay);
1934 extern void ata_sff_queue_pio_task(struct ata_link *link, unsigned long delay);
1935 extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);
1936 extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);
1937 extern unsigned int ata_sff_port_intr(struct ata_port *ap,
1938                       struct ata_queued_cmd *qc);
1939 extern irqreturn_t ata_sff_interrupt(int irq, void *dev_instance);
1940 extern void ata_sff_lost_interrupt(struct ata_port *ap);
1941 extern void ata_sff_freeze(struct ata_port *ap);
1942 extern void ata_sff_thaw(struct ata_port *ap);
1943 extern int ata_sff_prereset(struct ata_link *link, unsigned long deadline);
1944 extern unsigned int ata_sff_dev_classify(struct ata_device *dev, int present,
1945                       u8 *r_err);
1946 extern int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,
1947                     unsigned long deadline);
1948 extern int ata_sff_softreset(struct ata_link *link, unsigned int *classes,
1949                  unsigned long deadline);
1950 extern int sata_sff_hardreset(struct ata_link *link, unsigned int *class,
1951                    unsigned long deadline);
1952 extern void ata_sff_postreset(struct ata_link *link, unsigned int *classes);
1953 extern void ata_sff_drain_fifo(struct ata_queued_cmd *qc);
1954 extern void ata_sff_error_handler(struct ata_port *ap);
1955 extern void ata_sff_std_ports(struct ata_ioports *ioaddr);
1956 #ifdef CONFIG_PCI
1957 extern int ata_pci_sff_init_host(struct ata_host *host);
1958 extern int ata_pci_sff_prepare_host(struct pci_dev *pdev,
1959                     const struct ata_port_info * const * ppi,
1960                     struct ata_host **r_host);
1961 extern int ata_pci_sff_activate_host(struct ata_host *host,
1962                      irq_handler_t irq_handler,
1963                      struct scsi_host_template *sht);
1964 extern int ata_pci_sff_init_one(struct pci_dev *pdev,
1965         const struct ata_port_info * const * ppi,
1966         struct scsi_host_template *sht, void *host_priv, int hflags);
1967 #endif /* CONFIG_PCI */
1968
1969 #ifdef CONFIG_ATA_BMDMA
1970
1971 extern const struct ata_port_operations ata_bmdma_port_ops;
1972
1973 #define ATA_BMDMA_SHT(drv_name)                 \
1974     ATA_BASE_SHT(drv_name),                 \
1975     .sg_tablesize       = LIBATA_MAX_PRD,       \
1976     .dma_boundary       = ATA_DMA_BOUNDARY
1977
1978 extern enum ata_completion_errors ata_bmdma_qc_prep(struct ata_queued_cmd *qc);
1979 extern unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc);
1980 extern enum ata_completion_errors ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc);
1981 extern unsigned int ata_bmdma_port_intr(struct ata_port *ap,
1982                       struct ata_queued_cmd *qc);
1983 extern irqreturn_t ata_bmdma_interrupt(int irq, void *dev_instance);
1984 extern void ata_bmdma_error_handler(struct ata_port *ap);
1985 extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
1986 extern void ata_bmdma_irq_clear(struct ata_port *ap);
1987 extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
1988 extern void ata_bmdma_start(struct ata_queued_cmd *qc);
1989 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
1990 extern u8 ata_bmdma_status(struct ata_port *ap);
1991 extern int ata_bmdma_port_start(struct ata_port *ap);
1992 extern int ata_bmdma_port_start32(struct ata_port *ap);
1993
1994 #ifdef CONFIG_PCI
1995 extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);
1996 extern void ata_pci_bmdma_init(struct ata_host *host);
1997 extern int ata_pci_bmdma_prepare_host(struct pci_dev *pdev,
1998                       const struct ata_port_info * const * ppi,
1999                       struct ata_host **r_host);
2000 extern int ata_pci_bmdma_init_one(struct pci_dev *pdev,
2001                   const struct ata_port_info * const * ppi,
2002                   struct scsi_host_template *sht,
2003                   void *host_priv, int hflags);
2004 #endif /* CONFIG_PCI */
2005 #endif /* CONFIG_ATA_BMDMA */
2006
2007 /**
2008  *  ata_sff_busy_wait - Wait for a port status register
2009  *  @ap: Port to wait for.
2010  *  @bits: bits that must be clear
2011  *  @max: number of 10uS waits to perform
2012  *
2013  *  Waits up to max*10 microseconds for the selected bits in the port's
2014  *  status register to be cleared.
2015  *  Returns final value of status register.
2016  *
2017  *  LOCKING:
2018  *  Inherited from caller.
2019  */
2020 static inline u8 ata_sff_busy_wait(struct ata_port *ap, unsigned int bits,
2021                    unsigned int max)
2022 {
2023     u8 status;
2024
2025     do {
2026         udelay(10);
2027         status = ap->ops->sff_check_status(ap);
2028         max--;
2029     } while (status != 0xff && (status & bits) && (max > 0));
2030
2031     return status;
2032 }
2033
2034 /**
2035  *  ata_wait_idle - Wait for a port to be idle.
2036  *  @ap: Port to wait for.
2037  *
2038  *  Waits up to 10ms for port's BUSY and DRQ signals to clear.
2039  *  Returns final value of status register.
2040  *
2041  *  LOCKING:
2042  *  Inherited from caller.
2043  */
2044 static inline u8 ata_wait_idle(struct ata_port *ap)
2045 {
2046     u8 status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
2047
2048     if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ)))
2049         ata_port_dbg(ap, "abnormal Status 0x%X\n", status);
2050
2051     return status;
2052 }
2053 #endif /* CONFIG_ATA_SFF */
2054
2055 #endif /* __LINUX_LIBATA_H__ */