LCOV - code coverage report
Current view: top level - include/linux - libata.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 94 131 71.8 %
Date: 2022-03-28 13:20:08 Functions: 3 3 100.0 %
Branches: 139 428 32.5 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0-or-later */
       2                 :            : /*
       3                 :            :  *  Copyright 2003-2005 Red Hat, Inc.  All rights reserved.
       4                 :            :  *  Copyright 2003-2005 Jeff Garzik
       5                 :            :  *
       6                 :            :  *  libata documentation is available via 'make {ps|pdf}docs',
       7                 :            :  *  as Documentation/driver-api/libata.rst
       8                 :            :  */
       9                 :            : 
      10                 :            : #ifndef __LINUX_LIBATA_H__
      11                 :            : #define __LINUX_LIBATA_H__
      12                 :            : 
      13                 :            : #include <linux/delay.h>
      14                 :            : #include <linux/jiffies.h>
      15                 :            : #include <linux/interrupt.h>
      16                 :            : #include <linux/dma-mapping.h>
      17                 :            : #include <linux/scatterlist.h>
      18                 :            : #include <linux/io.h>
      19                 :            : #include <linux/ata.h>
      20                 :            : #include <linux/workqueue.h>
      21                 :            : #include <scsi/scsi_host.h>
      22                 :            : #include <linux/acpi.h>
      23                 :            : #include <linux/cdrom.h>
      24                 :            : #include <linux/sched.h>
      25                 :            : 
      26                 :            : /*
      27                 :            :  * Define if arch has non-standard setup.  This is a _PCI_ standard
      28                 :            :  * not a legacy or ISA standard.
      29                 :            :  */
      30                 :            : #ifdef CONFIG_ATA_NONSTANDARD
      31                 :            : #include <asm/libata-portmap.h>
      32                 :            : #else
      33                 :            : #define ATA_PRIMARY_IRQ(dev)    14
      34                 :            : #define ATA_SECONDARY_IRQ(dev)  15
      35                 :            : #endif
      36                 :            : 
      37                 :            : /*
      38                 :            :  * compile-time options: to be removed as soon as all the drivers are
      39                 :            :  * converted to the new debugging mechanism
      40                 :            :  */
      41                 :            : #undef ATA_DEBUG                /* debugging output */
      42                 :            : #undef ATA_VERBOSE_DEBUG        /* yet more debugging output */
      43                 :            : #undef ATA_IRQ_TRAP             /* define to ack screaming irqs */
      44                 :            : #undef ATA_NDEBUG               /* define to disable quick runtime checks */
      45                 :            : 
      46                 :            : 
      47                 :            : /* note: prints function name for you */
      48                 :            : #ifdef ATA_DEBUG
      49                 :            : #define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
      50                 :            : #ifdef ATA_VERBOSE_DEBUG
      51                 :            : #define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
      52                 :            : #else
      53                 :            : #define VPRINTK(fmt, args...)
      54                 :            : #endif  /* ATA_VERBOSE_DEBUG */
      55                 :            : #else
      56                 :            : #define DPRINTK(fmt, args...)
      57                 :            : #define VPRINTK(fmt, args...)
      58                 :            : #endif  /* ATA_DEBUG */
      59                 :            : 
      60                 :            : #define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args)
      61                 :            : 
      62                 :            : #define ata_print_version_once(dev, version)                    \
      63                 :            : ({                                                              \
      64                 :            :         static bool __print_once;                               \
      65                 :            :                                                                 \
      66                 :            :         if (!__print_once) {                                    \
      67                 :            :                 __print_once = true;                            \
      68                 :            :                 ata_print_version(dev, version);                \
      69                 :            :         }                                                       \
      70                 :            : })
      71                 :            : 
      72                 :            : /* NEW: debug levels */
      73                 :            : #define HAVE_LIBATA_MSG 1
      74                 :            : 
      75                 :            : enum {
      76                 :            :         ATA_MSG_DRV     = 0x0001,
      77                 :            :         ATA_MSG_INFO    = 0x0002,
      78                 :            :         ATA_MSG_PROBE   = 0x0004,
      79                 :            :         ATA_MSG_WARN    = 0x0008,
      80                 :            :         ATA_MSG_MALLOC  = 0x0010,
      81                 :            :         ATA_MSG_CTL     = 0x0020,
      82                 :            :         ATA_MSG_INTR    = 0x0040,
      83                 :            :         ATA_MSG_ERR     = 0x0080,
      84                 :            : };
      85                 :            : 
      86                 :            : #define ata_msg_drv(p)    ((p)->msg_enable & ATA_MSG_DRV)
      87                 :            : #define ata_msg_info(p)   ((p)->msg_enable & ATA_MSG_INFO)
      88                 :            : #define ata_msg_probe(p)  ((p)->msg_enable & ATA_MSG_PROBE)
      89                 :            : #define ata_msg_warn(p)   ((p)->msg_enable & ATA_MSG_WARN)
      90                 :            : #define ata_msg_malloc(p) ((p)->msg_enable & ATA_MSG_MALLOC)
      91                 :            : #define ata_msg_ctl(p)    ((p)->msg_enable & ATA_MSG_CTL)
      92                 :            : #define ata_msg_intr(p)   ((p)->msg_enable & ATA_MSG_INTR)
      93                 :            : #define ata_msg_err(p)    ((p)->msg_enable & ATA_MSG_ERR)
      94                 :            : 
      95                 :            : static inline u32 ata_msg_init(int dval, int default_msg_enable_bits)
      96                 :            : {
      97                 :            :         if (dval < 0 || dval >= (sizeof(u32) * 8))
      98                 :            :                 return default_msg_enable_bits; /* should be 0x1 - only driver info msgs */
      99                 :            :         if (!dval)
     100                 :            :                 return 0;
     101                 :            :         return (1 << dval) - 1;
     102                 :            : }
     103                 :            : 
     104                 :            : /* defines only for the constants which don't work well as enums */
     105                 :            : #define ATA_TAG_POISON          0xfafbfcfdU
     106                 :            : 
     107                 :            : enum {
     108                 :            :         /* various global constants */
     109                 :            :         LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
     110                 :            :         LIBATA_DUMB_MAX_PRD     = ATA_MAX_PRD / 4,      /* Worst case */
     111                 :            :         ATA_DEF_QUEUE           = 1,
     112                 :            :         ATA_MAX_QUEUE           = 32,
     113                 :            :         ATA_TAG_INTERNAL        = ATA_MAX_QUEUE,
     114                 :            :         ATA_SHORT_PAUSE         = 16,
     115                 :            : 
     116                 :            :         ATAPI_MAX_DRAIN         = 16 << 10,
     117                 :            : 
     118                 :            :         ATA_ALL_DEVICES         = (1 << ATA_MAX_DEVICES) - 1,
     119                 :            : 
     120                 :            :         ATA_SHT_EMULATED        = 1,
     121                 :            :         ATA_SHT_THIS_ID         = -1,
     122                 :            : 
     123                 :            :         /* struct ata_taskfile flags */
     124                 :            :         ATA_TFLAG_LBA48         = (1 << 0), /* enable 48-bit LBA and "HOB" */
     125                 :            :         ATA_TFLAG_ISADDR        = (1 << 1), /* enable r/w to nsect/lba regs */
     126                 :            :         ATA_TFLAG_DEVICE        = (1 << 2), /* enable r/w to device reg */
     127                 :            :         ATA_TFLAG_WRITE         = (1 << 3), /* data dir: host->dev==1 (write) */
     128                 :            :         ATA_TFLAG_LBA           = (1 << 4), /* enable LBA */
     129                 :            :         ATA_TFLAG_FUA           = (1 << 5), /* enable FUA */
     130                 :            :         ATA_TFLAG_POLLING       = (1 << 6), /* set nIEN to 1 and use polling */
     131                 :            : 
     132                 :            :         /* struct ata_device stuff */
     133                 :            :         ATA_DFLAG_LBA           = (1 << 0), /* device supports LBA */
     134                 :            :         ATA_DFLAG_LBA48         = (1 << 1), /* device supports LBA48 */
     135                 :            :         ATA_DFLAG_CDB_INTR      = (1 << 2), /* device asserts INTRQ when ready for CDB */
     136                 :            :         ATA_DFLAG_NCQ           = (1 << 3), /* device supports NCQ */
     137                 :            :         ATA_DFLAG_FLUSH_EXT     = (1 << 4), /* do FLUSH_EXT instead of FLUSH */
     138                 :            :         ATA_DFLAG_ACPI_PENDING  = (1 << 5), /* ACPI resume action pending */
     139                 :            :         ATA_DFLAG_ACPI_FAILED   = (1 << 6), /* ACPI on devcfg has failed */
     140                 :            :         ATA_DFLAG_AN            = (1 << 7), /* AN configured */
     141                 :            :         ATA_DFLAG_TRUSTED       = (1 << 8), /* device supports trusted send/recv */
     142                 :            :         ATA_DFLAG_DMADIR        = (1 << 10), /* device requires DMADIR */
     143                 :            :         ATA_DFLAG_CFG_MASK      = (1 << 12) - 1,
     144                 :            : 
     145                 :            :         ATA_DFLAG_PIO           = (1 << 12), /* device limited to PIO mode */
     146                 :            :         ATA_DFLAG_NCQ_OFF       = (1 << 13), /* device limited to non-NCQ mode */
     147                 :            :         ATA_DFLAG_SLEEPING      = (1 << 15), /* device is sleeping */
     148                 :            :         ATA_DFLAG_DUBIOUS_XFER  = (1 << 16), /* data transfer not verified */
     149                 :            :         ATA_DFLAG_NO_UNLOAD     = (1 << 17), /* device doesn't support unload */
     150                 :            :         ATA_DFLAG_UNLOCK_HPA    = (1 << 18), /* unlock HPA */
     151                 :            :         ATA_DFLAG_NCQ_SEND_RECV = (1 << 19), /* device supports NCQ SEND and RECV */
     152                 :            :         ATA_DFLAG_NCQ_PRIO      = (1 << 20), /* device supports NCQ priority */
     153                 :            :         ATA_DFLAG_NCQ_PRIO_ENABLE = (1 << 21), /* Priority cmds sent to dev */
     154                 :            :         ATA_DFLAG_INIT_MASK     = (1 << 24) - 1,
     155                 :            : 
     156                 :            :         ATA_DFLAG_DETACH        = (1 << 24),
     157                 :            :         ATA_DFLAG_DETACHED      = (1 << 25),
     158                 :            : 
     159                 :            :         ATA_DFLAG_DA            = (1 << 26), /* device supports Device Attention */
     160                 :            :         ATA_DFLAG_DEVSLP        = (1 << 27), /* device supports Device Sleep */
     161                 :            :         ATA_DFLAG_ACPI_DISABLED = (1 << 28), /* ACPI for the device is disabled */
     162                 :            :         ATA_DFLAG_D_SENSE       = (1 << 29), /* Descriptor sense requested */
     163                 :            :         ATA_DFLAG_ZAC           = (1 << 30), /* ZAC device */
     164                 :            : 
     165                 :            :         ATA_DEV_UNKNOWN         = 0,    /* unknown device */
     166                 :            :         ATA_DEV_ATA             = 1,    /* ATA device */
     167                 :            :         ATA_DEV_ATA_UNSUP       = 2,    /* ATA device (unsupported) */
     168                 :            :         ATA_DEV_ATAPI           = 3,    /* ATAPI device */
     169                 :            :         ATA_DEV_ATAPI_UNSUP     = 4,    /* ATAPI device (unsupported) */
     170                 :            :         ATA_DEV_PMP             = 5,    /* SATA port multiplier */
     171                 :            :         ATA_DEV_PMP_UNSUP       = 6,    /* SATA port multiplier (unsupported) */
     172                 :            :         ATA_DEV_SEMB            = 7,    /* SEMB */
     173                 :            :         ATA_DEV_SEMB_UNSUP      = 8,    /* SEMB (unsupported) */
     174                 :            :         ATA_DEV_ZAC             = 9,    /* ZAC device */
     175                 :            :         ATA_DEV_ZAC_UNSUP       = 10,   /* ZAC device (unsupported) */
     176                 :            :         ATA_DEV_NONE            = 11,   /* no device */
     177                 :            : 
     178                 :            :         /* struct ata_link flags */
     179                 :            :         ATA_LFLAG_NO_HRST       = (1 << 1), /* avoid hardreset */
     180                 :            :         ATA_LFLAG_NO_SRST       = (1 << 2), /* avoid softreset */
     181                 :            :         ATA_LFLAG_ASSUME_ATA    = (1 << 3), /* assume ATA class */
     182                 :            :         ATA_LFLAG_ASSUME_SEMB   = (1 << 4), /* assume SEMB class */
     183                 :            :         ATA_LFLAG_ASSUME_CLASS  = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
     184                 :            :         ATA_LFLAG_NO_RETRY      = (1 << 5), /* don't retry this link */
     185                 :            :         ATA_LFLAG_DISABLED      = (1 << 6), /* link is disabled */
     186                 :            :         ATA_LFLAG_SW_ACTIVITY   = (1 << 7), /* keep activity stats */
     187                 :            :         ATA_LFLAG_NO_LPM        = (1 << 8), /* disable LPM on this link */
     188                 :            :         ATA_LFLAG_RST_ONCE      = (1 << 9), /* limit recovery to one reset */
     189                 :            :         ATA_LFLAG_CHANGED       = (1 << 10), /* LPM state changed on this link */
     190                 :            :         ATA_LFLAG_NO_DB_DELAY   = (1 << 11), /* no debounce delay on link resume */
     191                 :            : 
     192                 :            :         /* struct ata_port flags */
     193                 :            :         ATA_FLAG_SLAVE_POSS     = (1 << 0), /* host supports slave dev */
     194                 :            :                                             /* (doesn't imply presence) */
     195                 :            :         ATA_FLAG_SATA           = (1 << 1),
     196                 :            :         ATA_FLAG_NO_LPM         = (1 << 2), /* host not happy with LPM */
     197                 :            :         ATA_FLAG_NO_LOG_PAGE    = (1 << 5), /* do not issue log page read */
     198                 :            :         ATA_FLAG_NO_ATAPI       = (1 << 6), /* No ATAPI support */
     199                 :            :         ATA_FLAG_PIO_DMA        = (1 << 7), /* PIO cmds via DMA */
     200                 :            :         ATA_FLAG_PIO_LBA48      = (1 << 8), /* Host DMA engine is LBA28 only */
     201                 :            :         ATA_FLAG_PIO_POLLING    = (1 << 9), /* use polling PIO if LLD
     202                 :            :                                              * doesn't handle PIO interrupts */
     203                 :            :         ATA_FLAG_NCQ            = (1 << 10), /* host supports NCQ */
     204                 :            :         ATA_FLAG_NO_POWEROFF_SPINDOWN = (1 << 11), /* don't spindown before poweroff */
     205                 :            :         ATA_FLAG_NO_HIBERNATE_SPINDOWN = (1 << 12), /* don't spindown before hibernation */
     206                 :            :         ATA_FLAG_DEBUGMSG       = (1 << 13),
     207                 :            :         ATA_FLAG_FPDMA_AA               = (1 << 14), /* driver supports Auto-Activate */
     208                 :            :         ATA_FLAG_IGN_SIMPLEX    = (1 << 15), /* ignore SIMPLEX */
     209                 :            :         ATA_FLAG_NO_IORDY       = (1 << 16), /* controller lacks iordy */
     210                 :            :         ATA_FLAG_ACPI_SATA      = (1 << 17), /* need native SATA ACPI layout */
     211                 :            :         ATA_FLAG_AN             = (1 << 18), /* controller supports AN */
     212                 :            :         ATA_FLAG_PMP            = (1 << 19), /* controller supports PMP */
     213                 :            :         ATA_FLAG_FPDMA_AUX      = (1 << 20), /* controller supports H2DFIS aux field */
     214                 :            :         ATA_FLAG_EM             = (1 << 21), /* driver supports enclosure
     215                 :            :                                               * management */
     216                 :            :         ATA_FLAG_SW_ACTIVITY    = (1 << 22), /* driver supports sw activity
     217                 :            :                                               * led */
     218                 :            :         ATA_FLAG_NO_DIPM        = (1 << 23), /* host not happy with DIPM */
     219                 :            :         ATA_FLAG_SAS_HOST       = (1 << 24), /* SAS host */
     220                 :            : 
     221                 :            :         /* bits 24:31 of ap->flags are reserved for LLD specific flags */
     222                 :            : 
     223                 :            : 
     224                 :            :         /* struct ata_port pflags */
     225                 :            :         ATA_PFLAG_EH_PENDING    = (1 << 0), /* EH pending */
     226                 :            :         ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
     227                 :            :         ATA_PFLAG_FROZEN        = (1 << 2), /* port is frozen */
     228                 :            :         ATA_PFLAG_RECOVERED     = (1 << 3), /* recovery action performed */
     229                 :            :         ATA_PFLAG_LOADING       = (1 << 4), /* boot/loading probe */
     230                 :            :         ATA_PFLAG_SCSI_HOTPLUG  = (1 << 6), /* SCSI hotplug scheduled */
     231                 :            :         ATA_PFLAG_INITIALIZING  = (1 << 7), /* being initialized, don't touch */
     232                 :            :         ATA_PFLAG_RESETTING     = (1 << 8), /* reset in progress */
     233                 :            :         ATA_PFLAG_UNLOADING     = (1 << 9), /* driver is being unloaded */
     234                 :            :         ATA_PFLAG_UNLOADED      = (1 << 10), /* driver is unloaded */
     235                 :            : 
     236                 :            :         ATA_PFLAG_SUSPENDED     = (1 << 17), /* port is suspended (power) */
     237                 :            :         ATA_PFLAG_PM_PENDING    = (1 << 18), /* PM operation pending */
     238                 :            :         ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */
     239                 :            : 
     240                 :            :         ATA_PFLAG_PIO32         = (1 << 20),  /* 32bit PIO */
     241                 :            :         ATA_PFLAG_PIO32CHANGE   = (1 << 21),  /* 32bit PIO can be turned on/off */
     242                 :            :         ATA_PFLAG_EXTERNAL      = (1 << 22),  /* eSATA/external port */
     243                 :            : 
     244                 :            :         /* struct ata_queued_cmd flags */
     245                 :            :         ATA_QCFLAG_ACTIVE       = (1 << 0), /* cmd not yet ack'd to scsi lyer */
     246                 :            :         ATA_QCFLAG_DMAMAP       = (1 << 1), /* SG table is DMA mapped */
     247                 :            :         ATA_QCFLAG_IO           = (1 << 3), /* standard IO command */
     248                 :            :         ATA_QCFLAG_RESULT_TF    = (1 << 4), /* result TF requested */
     249                 :            :         ATA_QCFLAG_CLEAR_EXCL   = (1 << 5), /* clear excl_link on completion */
     250                 :            :         ATA_QCFLAG_QUIET        = (1 << 6), /* don't report device error */
     251                 :            :         ATA_QCFLAG_RETRY        = (1 << 7), /* retry after failure */
     252                 :            : 
     253                 :            :         ATA_QCFLAG_FAILED       = (1 << 16), /* cmd failed and is owned by EH */
     254                 :            :         ATA_QCFLAG_SENSE_VALID  = (1 << 17), /* sense data valid */
     255                 :            :         ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */
     256                 :            : 
     257                 :            :         /* host set flags */
     258                 :            :         ATA_HOST_SIMPLEX        = (1 << 0),       /* Host is simplex, one DMA channel per host only */
     259                 :            :         ATA_HOST_STARTED        = (1 << 1),       /* Host started */
     260                 :            :         ATA_HOST_PARALLEL_SCAN  = (1 << 2),       /* Ports on this host can be scanned in parallel */
     261                 :            :         ATA_HOST_IGNORE_ATA     = (1 << 3),       /* Ignore ATA devices on this host. */
     262                 :            : 
     263                 :            :         /* bits 24:31 of host->flags are reserved for LLD specific flags */
     264                 :            : 
     265                 :            :         /* various lengths of time */
     266                 :            :         ATA_TMOUT_BOOT          = 30000,        /* heuristic */
     267                 :            :         ATA_TMOUT_BOOT_QUICK    =  7000,        /* heuristic */
     268                 :            :         ATA_TMOUT_INTERNAL_QUICK = 5000,
     269                 :            :         ATA_TMOUT_MAX_PARK      = 30000,
     270                 :            : 
     271                 :            :         /*
     272                 :            :          * GoVault needs 2s and iVDR disk HHD424020F7SV00 800ms.  2s
     273                 :            :          * is too much without parallel probing.  Use 2s if parallel
     274                 :            :          * probing is available, 800ms otherwise.
     275                 :            :          */
     276                 :            :         ATA_TMOUT_FF_WAIT_LONG  =  2000,
     277                 :            :         ATA_TMOUT_FF_WAIT       =   800,
     278                 :            : 
     279                 :            :         /* Spec mandates to wait for ">= 2ms" before checking status
     280                 :            :          * after reset.  We wait 150ms, because that was the magic
     281                 :            :          * delay used for ATAPI devices in Hale Landis's ATADRVR, for
     282                 :            :          * the period of time between when the ATA command register is
     283                 :            :          * written, and then status is checked.  Because waiting for
     284                 :            :          * "a while" before checking status is fine, post SRST, we
     285                 :            :          * perform this magic delay here as well.
     286                 :            :          *
     287                 :            :          * Old drivers/ide uses the 2mS rule and then waits for ready.
     288                 :            :          */
     289                 :            :         ATA_WAIT_AFTER_RESET    =  150,
     290                 :            : 
     291                 :            :         /* If PMP is supported, we have to do follow-up SRST.  As some
     292                 :            :          * PMPs don't send D2H Reg FIS after hardreset, LLDs are
     293                 :            :          * advised to wait only for the following duration before
     294                 :            :          * doing SRST.
     295                 :            :          */
     296                 :            :         ATA_TMOUT_PMP_SRST_WAIT = 5000,
     297                 :            : 
     298                 :            :         /* When the LPM policy is set to ATA_LPM_MAX_POWER, there might
     299                 :            :          * be a spurious PHY event, so ignore the first PHY event that
     300                 :            :          * occurs within 10s after the policy change.
     301                 :            :          */
     302                 :            :         ATA_TMOUT_SPURIOUS_PHY  = 10000,
     303                 :            : 
     304                 :            :         /* ATA bus states */
     305                 :            :         BUS_UNKNOWN             = 0,
     306                 :            :         BUS_DMA                 = 1,
     307                 :            :         BUS_IDLE                = 2,
     308                 :            :         BUS_NOINTR              = 3,
     309                 :            :         BUS_NODATA              = 4,
     310                 :            :         BUS_TIMER               = 5,
     311                 :            :         BUS_PIO                 = 6,
     312                 :            :         BUS_EDD                 = 7,
     313                 :            :         BUS_IDENTIFY            = 8,
     314                 :            :         BUS_PACKET              = 9,
     315                 :            : 
     316                 :            :         /* SATA port states */
     317                 :            :         PORT_UNKNOWN            = 0,
     318                 :            :         PORT_ENABLED            = 1,
     319                 :            :         PORT_DISABLED           = 2,
     320                 :            : 
     321                 :            :         /* encoding various smaller bitmaps into a single
     322                 :            :          * unsigned long bitmap
     323                 :            :          */
     324                 :            :         ATA_NR_PIO_MODES        = 7,
     325                 :            :         ATA_NR_MWDMA_MODES      = 5,
     326                 :            :         ATA_NR_UDMA_MODES       = 8,
     327                 :            : 
     328                 :            :         ATA_SHIFT_PIO           = 0,
     329                 :            :         ATA_SHIFT_MWDMA         = ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
     330                 :            :         ATA_SHIFT_UDMA          = ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,
     331                 :            :         ATA_SHIFT_PRIO          = 6,
     332                 :            : 
     333                 :            :         ATA_PRIO_HIGH           = 2,
     334                 :            :         /* size of buffer to pad xfers ending on unaligned boundaries */
     335                 :            :         ATA_DMA_PAD_SZ          = 4,
     336                 :            : 
     337                 :            :         /* ering size */
     338                 :            :         ATA_ERING_SIZE          = 32,
     339                 :            : 
     340                 :            :         /* return values for ->qc_defer */
     341                 :            :         ATA_DEFER_LINK          = 1,
     342                 :            :         ATA_DEFER_PORT          = 2,
     343                 :            : 
     344                 :            :         /* desc_len for ata_eh_info and context */
     345                 :            :         ATA_EH_DESC_LEN         = 80,
     346                 :            : 
     347                 :            :         /* reset / recovery action types */
     348                 :            :         ATA_EH_REVALIDATE       = (1 << 0),
     349                 :            :         ATA_EH_SOFTRESET        = (1 << 1), /* meaningful only in ->prereset */
     350                 :            :         ATA_EH_HARDRESET        = (1 << 2), /* meaningful only in ->prereset */
     351                 :            :         ATA_EH_RESET            = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
     352                 :            :         ATA_EH_ENABLE_LINK      = (1 << 3),
     353                 :            :         ATA_EH_PARK             = (1 << 5), /* unload heads and stop I/O */
     354                 :            : 
     355                 :            :         ATA_EH_PERDEV_MASK      = ATA_EH_REVALIDATE | ATA_EH_PARK,
     356                 :            :         ATA_EH_ALL_ACTIONS      = ATA_EH_REVALIDATE | ATA_EH_RESET |
     357                 :            :                                   ATA_EH_ENABLE_LINK,
     358                 :            : 
     359                 :            :         /* ata_eh_info->flags */
     360                 :            :         ATA_EHI_HOTPLUGGED      = (1 << 0),  /* could have been hotplugged */
     361                 :            :         ATA_EHI_NO_AUTOPSY      = (1 << 2),  /* no autopsy */
     362                 :            :         ATA_EHI_QUIET           = (1 << 3),  /* be quiet */
     363                 :            :         ATA_EHI_NO_RECOVERY     = (1 << 4),  /* no recovery */
     364                 :            : 
     365                 :            :         ATA_EHI_DID_SOFTRESET   = (1 << 16), /* already soft-reset this port */
     366                 :            :         ATA_EHI_DID_HARDRESET   = (1 << 17), /* already soft-reset this port */
     367                 :            :         ATA_EHI_PRINTINFO       = (1 << 18), /* print configuration info */
     368                 :            :         ATA_EHI_SETMODE         = (1 << 19), /* configure transfer mode */
     369                 :            :         ATA_EHI_POST_SETMODE    = (1 << 20), /* revalidating after setmode */
     370                 :            : 
     371                 :            :         ATA_EHI_DID_RESET       = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
     372                 :            : 
     373                 :            :         /* mask of flags to transfer *to* the slave link */
     374                 :            :         ATA_EHI_TO_SLAVE_MASK   = ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET,
     375                 :            : 
     376                 :            :         /* max tries if error condition is still set after ->error_handler */
     377                 :            :         ATA_EH_MAX_TRIES        = 5,
     378                 :            : 
     379                 :            :         /* sometimes resuming a link requires several retries */
     380                 :            :         ATA_LINK_RESUME_TRIES   = 5,
     381                 :            : 
     382                 :            :         /* how hard are we gonna try to probe/recover devices */
     383                 :            :         ATA_PROBE_MAX_TRIES     = 3,
     384                 :            :         ATA_EH_DEV_TRIES        = 3,
     385                 :            :         ATA_EH_PMP_TRIES        = 5,
     386                 :            :         ATA_EH_PMP_LINK_TRIES   = 3,
     387                 :            : 
     388                 :            :         SATA_PMP_RW_TIMEOUT     = 3000,         /* PMP read/write timeout */
     389                 :            : 
     390                 :            :         /* This should match the actual table size of
     391                 :            :          * ata_eh_cmd_timeout_table in libata-eh.c.
     392                 :            :          */
     393                 :            :         ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 6,
     394                 :            : 
     395                 :            :         /* Horkage types. May be set by libata or controller on drives
     396                 :            :            (some horkage may be drive/controller pair dependent */
     397                 :            : 
     398                 :            :         ATA_HORKAGE_DIAGNOSTIC  = (1 << 0),       /* Failed boot diag */
     399                 :            :         ATA_HORKAGE_NODMA       = (1 << 1),       /* DMA problems */
     400                 :            :         ATA_HORKAGE_NONCQ       = (1 << 2),       /* Don't use NCQ */
     401                 :            :         ATA_HORKAGE_MAX_SEC_128 = (1 << 3),       /* Limit max sects to 128 */
     402                 :            :         ATA_HORKAGE_BROKEN_HPA  = (1 << 4),       /* Broken HPA */
     403                 :            :         ATA_HORKAGE_DISABLE     = (1 << 5),       /* Disable it */
     404                 :            :         ATA_HORKAGE_HPA_SIZE    = (1 << 6),       /* native size off by one */
     405                 :            :         ATA_HORKAGE_IVB         = (1 << 8),       /* cbl det validity bit bugs */
     406                 :            :         ATA_HORKAGE_STUCK_ERR   = (1 << 9),       /* stuck ERR on next PACKET */
     407                 :            :         ATA_HORKAGE_BRIDGE_OK   = (1 << 10),      /* no bridge limits */
     408                 :            :         ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands
     409                 :            :                                                     not multiple of 16 bytes */
     410                 :            :         ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),    /* firmware update warning */
     411                 :            :         ATA_HORKAGE_1_5_GBPS    = (1 << 13),      /* force 1.5 Gbps */
     412                 :            :         ATA_HORKAGE_NOSETXFER   = (1 << 14),      /* skip SETXFER, SATA only */
     413                 :            :         ATA_HORKAGE_BROKEN_FPDMA_AA     = (1 << 15),      /* skip AA */
     414                 :            :         ATA_HORKAGE_DUMP_ID     = (1 << 16),      /* dump IDENTIFY data */
     415                 :            :         ATA_HORKAGE_MAX_SEC_LBA48 = (1 << 17),    /* Set max sects to 65535 */
     416                 :            :         ATA_HORKAGE_ATAPI_DMADIR = (1 << 18),     /* device requires dmadir */
     417                 :            :         ATA_HORKAGE_NO_NCQ_TRIM = (1 << 19),      /* don't use queued TRIM */
     418                 :            :         ATA_HORKAGE_NOLPM       = (1 << 20),      /* don't use LPM */
     419                 :            :         ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21),    /* some WDs have broken LPM */
     420                 :            :         ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */
     421                 :            :         ATA_HORKAGE_NO_DMA_LOG  = (1 << 23),      /* don't use DMA for log read */
     422                 :            :         ATA_HORKAGE_NOTRIM      = (1 << 24),      /* don't use TRIM */
     423                 :            :         ATA_HORKAGE_MAX_SEC_1024 = (1 << 25),     /* Limit max sects to 1024 */
     424                 :            : 
     425                 :            :          /* DMA mask for user DMA control: User visible values; DO NOT
     426                 :            :             renumber */
     427                 :            :         ATA_DMA_MASK_ATA        = (1 << 0),       /* DMA on ATA Disk */
     428                 :            :         ATA_DMA_MASK_ATAPI      = (1 << 1),       /* DMA on ATAPI */
     429                 :            :         ATA_DMA_MASK_CFA        = (1 << 2),       /* DMA on CF Card */
     430                 :            : 
     431                 :            :         /* ATAPI command types */
     432                 :            :         ATAPI_READ              = 0,            /* READs */
     433                 :            :         ATAPI_WRITE             = 1,            /* WRITEs */
     434                 :            :         ATAPI_READ_CD           = 2,            /* READ CD [MSF] */
     435                 :            :         ATAPI_PASS_THRU         = 3,            /* SAT pass-thru */
     436                 :            :         ATAPI_MISC              = 4,            /* the rest */
     437                 :            : 
     438                 :            :         /* Timing constants */
     439                 :            :         ATA_TIMING_SETUP        = (1 << 0),
     440                 :            :         ATA_TIMING_ACT8B        = (1 << 1),
     441                 :            :         ATA_TIMING_REC8B        = (1 << 2),
     442                 :            :         ATA_TIMING_CYC8B        = (1 << 3),
     443                 :            :         ATA_TIMING_8BIT         = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
     444                 :            :                                   ATA_TIMING_CYC8B,
     445                 :            :         ATA_TIMING_ACTIVE       = (1 << 4),
     446                 :            :         ATA_TIMING_RECOVER      = (1 << 5),
     447                 :            :         ATA_TIMING_DMACK_HOLD   = (1 << 6),
     448                 :            :         ATA_TIMING_CYCLE        = (1 << 7),
     449                 :            :         ATA_TIMING_UDMA         = (1 << 8),
     450                 :            :         ATA_TIMING_ALL          = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
     451                 :            :                                   ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
     452                 :            :                                   ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
     453                 :            :                                   ATA_TIMING_DMACK_HOLD | ATA_TIMING_CYCLE |
     454                 :            :                                   ATA_TIMING_UDMA,
     455                 :            : 
     456                 :            :         /* ACPI constants */
     457                 :            :         ATA_ACPI_FILTER_SETXFER = 1 << 0,
     458                 :            :         ATA_ACPI_FILTER_LOCK    = 1 << 1,
     459                 :            :         ATA_ACPI_FILTER_DIPM    = 1 << 2,
     460                 :            :         ATA_ACPI_FILTER_FPDMA_OFFSET = 1 << 3,    /* FPDMA non-zero offset */
     461                 :            :         ATA_ACPI_FILTER_FPDMA_AA = 1 << 4,        /* FPDMA auto activate */
     462                 :            : 
     463                 :            :         ATA_ACPI_FILTER_DEFAULT = ATA_ACPI_FILTER_SETXFER |
     464                 :            :                                   ATA_ACPI_FILTER_LOCK |
     465                 :            :                                   ATA_ACPI_FILTER_DIPM,
     466                 :            : };
     467                 :            : 
     468                 :            : enum ata_xfer_mask {
     469                 :            :         ATA_MASK_PIO            = ((1LU << ATA_NR_PIO_MODES) - 1)
     470                 :            :                                         << ATA_SHIFT_PIO,
     471                 :            :         ATA_MASK_MWDMA          = ((1LU << ATA_NR_MWDMA_MODES) - 1)
     472                 :            :                                         << ATA_SHIFT_MWDMA,
     473                 :            :         ATA_MASK_UDMA           = ((1LU << ATA_NR_UDMA_MODES) - 1)
     474                 :            :                                         << ATA_SHIFT_UDMA,
     475                 :            : };
     476                 :            : 
     477                 :            : enum hsm_task_states {
     478                 :            :         HSM_ST_IDLE,            /* no command on going */
     479                 :            :         HSM_ST_FIRST,           /* (waiting the device to)
     480                 :            :                                    write CDB or first data block */
     481                 :            :         HSM_ST,                 /* (waiting the device to) transfer data */
     482                 :            :         HSM_ST_LAST,            /* (waiting the device to) complete command */
     483                 :            :         HSM_ST_ERR,             /* error */
     484                 :            : };
     485                 :            : 
     486                 :            : enum ata_completion_errors {
     487                 :            :         AC_ERR_OK               = 0,        /* no error */
     488                 :            :         AC_ERR_DEV              = (1 << 0), /* device reported error */
     489                 :            :         AC_ERR_HSM              = (1 << 1), /* host state machine violation */
     490                 :            :         AC_ERR_TIMEOUT          = (1 << 2), /* timeout */
     491                 :            :         AC_ERR_MEDIA            = (1 << 3), /* media error */
     492                 :            :         AC_ERR_ATA_BUS          = (1 << 4), /* ATA bus error */
     493                 :            :         AC_ERR_HOST_BUS         = (1 << 5), /* host bus error */
     494                 :            :         AC_ERR_SYSTEM           = (1 << 6), /* system error */
     495                 :            :         AC_ERR_INVALID          = (1 << 7), /* invalid argument */
     496                 :            :         AC_ERR_OTHER            = (1 << 8), /* unknown */
     497                 :            :         AC_ERR_NODEV_HINT       = (1 << 9), /* polling device detection hint */
     498                 :            :         AC_ERR_NCQ              = (1 << 10), /* marker for offending NCQ qc */
     499                 :            : };
     500                 :            : 
     501                 :            : /*
     502                 :            :  * Link power management policy: If you alter this, you also need to
     503                 :            :  * alter libata-scsi.c (for the ascii descriptions)
     504                 :            :  */
     505                 :            : enum ata_lpm_policy {
     506                 :            :         ATA_LPM_UNKNOWN,
     507                 :            :         ATA_LPM_MAX_POWER,
     508                 :            :         ATA_LPM_MED_POWER,
     509                 :            :         ATA_LPM_MED_POWER_WITH_DIPM, /* Med power + DIPM as win IRST does */
     510                 :            :         ATA_LPM_MIN_POWER_WITH_PARTIAL, /* Min Power + partial and slumber */
     511                 :            :         ATA_LPM_MIN_POWER, /* Min power + no partial (slumber only) */
     512                 :            : };
     513                 :            : 
     514                 :            : enum ata_lpm_hints {
     515                 :            :         ATA_LPM_EMPTY           = (1 << 0), /* port empty/probing */
     516                 :            :         ATA_LPM_HIPM            = (1 << 1), /* may use HIPM */
     517                 :            :         ATA_LPM_WAKE_ONLY       = (1 << 2), /* only wake up link */
     518                 :            : };
     519                 :            : 
     520                 :            : /* forward declarations */
     521                 :            : struct scsi_device;
     522                 :            : struct ata_port_operations;
     523                 :            : struct ata_port;
     524                 :            : struct ata_link;
     525                 :            : struct ata_queued_cmd;
     526                 :            : 
     527                 :            : /* typedefs */
     528                 :            : typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
     529                 :            : typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);
     530                 :            : typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes,
     531                 :            :                               unsigned long deadline);
     532                 :            : typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
     533                 :            : 
     534                 :            : extern struct device_attribute dev_attr_link_power_management_policy;
     535                 :            : extern struct device_attribute dev_attr_unload_heads;
     536                 :            : extern struct device_attribute dev_attr_ncq_prio_enable;
     537                 :            : extern struct device_attribute dev_attr_em_message_type;
     538                 :            : extern struct device_attribute dev_attr_em_message;
     539                 :            : extern struct device_attribute dev_attr_sw_activity;
     540                 :            : 
     541                 :            : enum sw_activity {
     542                 :            :         OFF,
     543                 :            :         BLINK_ON,
     544                 :            :         BLINK_OFF,
     545                 :            : };
     546                 :            : 
     547                 :            : struct ata_taskfile {
     548                 :            :         unsigned long           flags;          /* ATA_TFLAG_xxx */
     549                 :            :         u8                      protocol;       /* ATA_PROT_xxx */
     550                 :            : 
     551                 :            :         u8                      ctl;            /* control reg */
     552                 :            : 
     553                 :            :         u8                      hob_feature;    /* additional data */
     554                 :            :         u8                      hob_nsect;      /* to support LBA48 */
     555                 :            :         u8                      hob_lbal;
     556                 :            :         u8                      hob_lbam;
     557                 :            :         u8                      hob_lbah;
     558                 :            : 
     559                 :            :         u8                      feature;
     560                 :            :         u8                      nsect;
     561                 :            :         u8                      lbal;
     562                 :            :         u8                      lbam;
     563                 :            :         u8                      lbah;
     564                 :            : 
     565                 :            :         u8                      device;
     566                 :            : 
     567                 :            :         u8                      command;        /* IO operation */
     568                 :            : 
     569                 :            :         u32                     auxiliary;      /* auxiliary field */
     570                 :            :                                                 /* from SATA 3.1 and */
     571                 :            :                                                 /* ATA-8 ACS-3 */
     572                 :            : };
     573                 :            : 
     574                 :            : #ifdef CONFIG_ATA_SFF
     575                 :            : struct ata_ioports {
     576                 :            :         void __iomem            *cmd_addr;
     577                 :            :         void __iomem            *data_addr;
     578                 :            :         void __iomem            *error_addr;
     579                 :            :         void __iomem            *feature_addr;
     580                 :            :         void __iomem            *nsect_addr;
     581                 :            :         void __iomem            *lbal_addr;
     582                 :            :         void __iomem            *lbam_addr;
     583                 :            :         void __iomem            *lbah_addr;
     584                 :            :         void __iomem            *device_addr;
     585                 :            :         void __iomem            *status_addr;
     586                 :            :         void __iomem            *command_addr;
     587                 :            :         void __iomem            *altstatus_addr;
     588                 :            :         void __iomem            *ctl_addr;
     589                 :            : #ifdef CONFIG_ATA_BMDMA
     590                 :            :         void __iomem            *bmdma_addr;
     591                 :            : #endif /* CONFIG_ATA_BMDMA */
     592                 :            :         void __iomem            *scr_addr;
     593                 :            : };
     594                 :            : #endif /* CONFIG_ATA_SFF */
     595                 :            : 
     596                 :            : struct ata_host {
     597                 :            :         spinlock_t              lock;
     598                 :            :         struct device           *dev;
     599                 :            :         void __iomem * const    *iomap;
     600                 :            :         unsigned int            n_ports;
     601                 :            :         unsigned int            n_tags;                 /* nr of NCQ tags */
     602                 :            :         void                    *private_data;
     603                 :            :         struct ata_port_operations *ops;
     604                 :            :         unsigned long           flags;
     605                 :            :         struct kref             kref;
     606                 :            : 
     607                 :            :         struct mutex            eh_mutex;
     608                 :            :         struct task_struct      *eh_owner;
     609                 :            : 
     610                 :            :         struct ata_port         *simplex_claimed;       /* channel owning the DMA */
     611                 :            :         struct ata_port         *ports[0];
     612                 :            : };
     613                 :            : 
     614                 :            : struct ata_queued_cmd {
     615                 :            :         struct ata_port         *ap;
     616                 :            :         struct ata_device       *dev;
     617                 :            : 
     618                 :            :         struct scsi_cmnd        *scsicmd;
     619                 :            :         void                    (*scsidone)(struct scsi_cmnd *);
     620                 :            : 
     621                 :            :         struct ata_taskfile     tf;
     622                 :            :         u8                      cdb[ATAPI_CDB_LEN];
     623                 :            : 
     624                 :            :         unsigned long           flags;          /* ATA_QCFLAG_xxx */
     625                 :            :         unsigned int            tag;            /* libata core tag */
     626                 :            :         unsigned int            hw_tag;         /* driver tag */
     627                 :            :         unsigned int            n_elem;
     628                 :            :         unsigned int            orig_n_elem;
     629                 :            : 
     630                 :            :         int                     dma_dir;
     631                 :            : 
     632                 :            :         unsigned int            sect_size;
     633                 :            : 
     634                 :            :         unsigned int            nbytes;
     635                 :            :         unsigned int            extrabytes;
     636                 :            :         unsigned int            curbytes;
     637                 :            : 
     638                 :            :         struct scatterlist      sgent;
     639                 :            : 
     640                 :            :         struct scatterlist      *sg;
     641                 :            : 
     642                 :            :         struct scatterlist      *cursg;
     643                 :            :         unsigned int            cursg_ofs;
     644                 :            : 
     645                 :            :         unsigned int            err_mask;
     646                 :            :         struct ata_taskfile     result_tf;
     647                 :            :         ata_qc_cb_t             complete_fn;
     648                 :            : 
     649                 :            :         void                    *private_data;
     650                 :            :         void                    *lldd_task;
     651                 :            : };
     652                 :            : 
     653                 :            : struct ata_port_stats {
     654                 :            :         unsigned long           unhandled_irq;
     655                 :            :         unsigned long           idle_irq;
     656                 :            :         unsigned long           rw_reqbuf;
     657                 :            : };
     658                 :            : 
     659                 :            : struct ata_ering_entry {
     660                 :            :         unsigned int            eflags;
     661                 :            :         unsigned int            err_mask;
     662                 :            :         u64                     timestamp;
     663                 :            : };
     664                 :            : 
     665                 :            : struct ata_ering {
     666                 :            :         int                     cursor;
     667                 :            :         struct ata_ering_entry  ring[ATA_ERING_SIZE];
     668                 :            : };
     669                 :            : 
     670                 :            : struct ata_device {
     671                 :            :         struct ata_link         *link;
     672                 :            :         unsigned int            devno;          /* 0 or 1 */
     673                 :            :         unsigned int            horkage;        /* List of broken features */
     674                 :            :         unsigned long           flags;          /* ATA_DFLAG_xxx */
     675                 :            :         struct scsi_device      *sdev;          /* attached SCSI device */
     676                 :            :         void                    *private_data;
     677                 :            : #ifdef CONFIG_ATA_ACPI
     678                 :            :         union acpi_object       *gtf_cache;
     679                 :            :         unsigned int            gtf_filter;
     680                 :            : #endif
     681                 :            : #ifdef CONFIG_SATA_ZPODD
     682                 :            :         void                    *zpodd;
     683                 :            : #endif
     684                 :            :         struct device           tdev;
     685                 :            :         /* n_sector is CLEAR_BEGIN, read comment above CLEAR_BEGIN */
     686                 :            :         u64                     n_sectors;      /* size of device, if ATA */
     687                 :            :         u64                     n_native_sectors; /* native size, if ATA */
     688                 :            :         unsigned int            class;          /* ATA_DEV_xxx */
     689                 :            :         unsigned long           unpark_deadline;
     690                 :            : 
     691                 :            :         u8                      pio_mode;
     692                 :            :         u8                      dma_mode;
     693                 :            :         u8                      xfer_mode;
     694                 :            :         unsigned int            xfer_shift;     /* ATA_SHIFT_xxx */
     695                 :            : 
     696                 :            :         unsigned int            multi_count;    /* sectors count for
     697                 :            :                                                    READ/WRITE MULTIPLE */
     698                 :            :         unsigned int            max_sectors;    /* per-device max sectors */
     699                 :            :         unsigned int            cdb_len;
     700                 :            : 
     701                 :            :         /* per-dev xfer mask */
     702                 :            :         unsigned long           pio_mask;
     703                 :            :         unsigned long           mwdma_mask;
     704                 :            :         unsigned long           udma_mask;
     705                 :            : 
     706                 :            :         /* for CHS addressing */
     707                 :            :         u16                     cylinders;      /* Number of cylinders */
     708                 :            :         u16                     heads;          /* Number of heads */
     709                 :            :         u16                     sectors;        /* Number of sectors per track */
     710                 :            : 
     711                 :            :         union {
     712                 :            :                 u16             id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
     713                 :            :                 u32             gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
     714                 :            :         } ____cacheline_aligned;
     715                 :            : 
     716                 :            :         /* DEVSLP Timing Variables from Identify Device Data Log */
     717                 :            :         u8                      devslp_timing[ATA_LOG_DEVSLP_SIZE];
     718                 :            : 
     719                 :            :         /* NCQ send and receive log subcommand support */
     720                 :            :         u8                      ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_SIZE];
     721                 :            :         u8                      ncq_non_data_cmds[ATA_LOG_NCQ_NON_DATA_SIZE];
     722                 :            : 
     723                 :            :         /* ZAC zone configuration */
     724                 :            :         u32                     zac_zoned_cap;
     725                 :            :         u32                     zac_zones_optimal_open;
     726                 :            :         u32                     zac_zones_optimal_nonseq;
     727                 :            :         u32                     zac_zones_max_open;
     728                 :            : 
     729                 :            :         /* error history */
     730                 :            :         int                     spdn_cnt;
     731                 :            :         /* ering is CLEAR_END, read comment above CLEAR_END */
     732                 :            :         struct ata_ering        ering;
     733                 :            : };
     734                 :            : 
     735                 :            : /* Fields between ATA_DEVICE_CLEAR_BEGIN and ATA_DEVICE_CLEAR_END are
     736                 :            :  * cleared to zero on ata_dev_init().
     737                 :            :  */
     738                 :            : #define ATA_DEVICE_CLEAR_BEGIN          offsetof(struct ata_device, n_sectors)
     739                 :            : #define ATA_DEVICE_CLEAR_END            offsetof(struct ata_device, ering)
     740                 :            : 
     741                 :            : struct ata_eh_info {
     742                 :            :         struct ata_device       *dev;           /* offending device */
     743                 :            :         u32                     serror;         /* SError from LLDD */
     744                 :            :         unsigned int            err_mask;       /* port-wide err_mask */
     745                 :            :         unsigned int            action;         /* ATA_EH_* action mask */
     746                 :            :         unsigned int            dev_action[ATA_MAX_DEVICES]; /* dev EH action */
     747                 :            :         unsigned int            flags;          /* ATA_EHI_* flags */
     748                 :            : 
     749                 :            :         unsigned int            probe_mask;
     750                 :            : 
     751                 :            :         char                    desc[ATA_EH_DESC_LEN];
     752                 :            :         int                     desc_len;
     753                 :            : };
     754                 :            : 
     755                 :            : struct ata_eh_context {
     756                 :            :         struct ata_eh_info      i;
     757                 :            :         int                     tries[ATA_MAX_DEVICES];
     758                 :            :         int                     cmd_timeout_idx[ATA_MAX_DEVICES]
     759                 :            :                                                [ATA_EH_CMD_TIMEOUT_TABLE_SIZE];
     760                 :            :         unsigned int            classes[ATA_MAX_DEVICES];
     761                 :            :         unsigned int            did_probe_mask;
     762                 :            :         unsigned int            unloaded_mask;
     763                 :            :         unsigned int            saved_ncq_enabled;
     764                 :            :         u8                      saved_xfer_mode[ATA_MAX_DEVICES];
     765                 :            :         /* timestamp for the last reset attempt or success */
     766                 :            :         unsigned long           last_reset;
     767                 :            : };
     768                 :            : 
     769                 :            : struct ata_acpi_drive
     770                 :            : {
     771                 :            :         u32 pio;
     772                 :            :         u32 dma;
     773                 :            : } __packed;
     774                 :            : 
     775                 :            : struct ata_acpi_gtm {
     776                 :            :         struct ata_acpi_drive drive[2];
     777                 :            :         u32 flags;
     778                 :            : } __packed;
     779                 :            : 
     780                 :            : struct ata_link {
     781                 :            :         struct ata_port         *ap;
     782                 :            :         int                     pmp;            /* port multiplier port # */
     783                 :            : 
     784                 :            :         struct device           tdev;
     785                 :            :         unsigned int            active_tag;     /* active tag on this link */
     786                 :            :         u32                     sactive;        /* active NCQ commands */
     787                 :            : 
     788                 :            :         unsigned int            flags;          /* ATA_LFLAG_xxx */
     789                 :            : 
     790                 :            :         u32                     saved_scontrol; /* SControl on probe */
     791                 :            :         unsigned int            hw_sata_spd_limit;
     792                 :            :         unsigned int            sata_spd_limit;
     793                 :            :         unsigned int            sata_spd;       /* current SATA PHY speed */
     794                 :            :         enum ata_lpm_policy     lpm_policy;
     795                 :            : 
     796                 :            :         /* record runtime error info, protected by host_set lock */
     797                 :            :         struct ata_eh_info      eh_info;
     798                 :            :         /* EH context */
     799                 :            :         struct ata_eh_context   eh_context;
     800                 :            : 
     801                 :            :         struct ata_device       device[ATA_MAX_DEVICES];
     802                 :            : 
     803                 :            :         unsigned long           last_lpm_change; /* when last LPM change happened */
     804                 :            : };
     805                 :            : #define ATA_LINK_CLEAR_BEGIN            offsetof(struct ata_link, active_tag)
     806                 :            : #define ATA_LINK_CLEAR_END              offsetof(struct ata_link, device[0])
     807                 :            : 
     808                 :            : struct ata_port {
     809                 :            :         struct Scsi_Host        *scsi_host; /* our co-allocated scsi host */
     810                 :            :         struct ata_port_operations *ops;
     811                 :            :         spinlock_t              *lock;
     812                 :            :         /* Flags owned by the EH context. Only EH should touch these once the
     813                 :            :            port is active */
     814                 :            :         unsigned long           flags;  /* ATA_FLAG_xxx */
     815                 :            :         /* Flags that change dynamically, protected by ap->lock */
     816                 :            :         unsigned int            pflags; /* ATA_PFLAG_xxx */
     817                 :            :         unsigned int            print_id; /* user visible unique port ID */
     818                 :            :         unsigned int            local_port_no; /* host local port num */
     819                 :            :         unsigned int            port_no; /* 0 based port no. inside the host */
     820                 :            : 
     821                 :            : #ifdef CONFIG_ATA_SFF
     822                 :            :         struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
     823                 :            :         u8                      ctl;    /* cache of ATA control register */
     824                 :            :         u8                      last_ctl;       /* Cache last written value */
     825                 :            :         struct ata_link*        sff_pio_task_link; /* link currently used */
     826                 :            :         struct delayed_work     sff_pio_task;
     827                 :            : #ifdef CONFIG_ATA_BMDMA
     828                 :            :         struct ata_bmdma_prd    *bmdma_prd;     /* BMDMA SG list */
     829                 :            :         dma_addr_t              bmdma_prd_dma;  /* and its DMA mapping */
     830                 :            : #endif /* CONFIG_ATA_BMDMA */
     831                 :            : #endif /* CONFIG_ATA_SFF */
     832                 :            : 
     833                 :            :         unsigned int            pio_mask;
     834                 :            :         unsigned int            mwdma_mask;
     835                 :            :         unsigned int            udma_mask;
     836                 :            :         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
     837                 :            : 
     838                 :            :         struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE + 1];
     839                 :            :         unsigned long           sas_tag_allocated; /* for sas tag allocation only */
     840                 :            :         u64                     qc_active;
     841                 :            :         int                     nr_active_links; /* #links with active qcs */
     842                 :            :         unsigned int            sas_last_tag;   /* track next tag hw expects */
     843                 :            : 
     844                 :            :         struct ata_link         link;           /* host default link */
     845                 :            :         struct ata_link         *slave_link;    /* see ata_slave_link_init() */
     846                 :            : 
     847                 :            :         int                     nr_pmp_links;   /* nr of available PMP links */
     848                 :            :         struct ata_link         *pmp_link;      /* array of PMP links */
     849                 :            :         struct ata_link         *excl_link;     /* for PMP qc exclusion */
     850                 :            : 
     851                 :            :         struct ata_port_stats   stats;
     852                 :            :         struct ata_host         *host;
     853                 :            :         struct device           *dev;
     854                 :            :         struct device           tdev;
     855                 :            : 
     856                 :            :         struct mutex            scsi_scan_mutex;
     857                 :            :         struct delayed_work     hotplug_task;
     858                 :            :         struct work_struct      scsi_rescan_task;
     859                 :            : 
     860                 :            :         unsigned int            hsm_task_state;
     861                 :            : 
     862                 :            :         u32                     msg_enable;
     863                 :            :         struct list_head        eh_done_q;
     864                 :            :         wait_queue_head_t       eh_wait_q;
     865                 :            :         int                     eh_tries;
     866                 :            :         struct completion       park_req_pending;
     867                 :            : 
     868                 :            :         pm_message_t            pm_mesg;
     869                 :            :         enum ata_lpm_policy     target_lpm_policy;
     870                 :            : 
     871                 :            :         struct timer_list       fastdrain_timer;
     872                 :            :         unsigned long           fastdrain_cnt;
     873                 :            : 
     874                 :            :         int                     em_message_type;
     875                 :            :         void                    *private_data;
     876                 :            : 
     877                 :            : #ifdef CONFIG_ATA_ACPI
     878                 :            :         struct ata_acpi_gtm     __acpi_init_gtm; /* use ata_acpi_init_gtm() */
     879                 :            : #endif
     880                 :            :         /* owned by EH */
     881                 :            :         u8                      sector_buf[ATA_SECT_SIZE] ____cacheline_aligned;
     882                 :            : };
     883                 :            : 
     884                 :            : /* The following initializer overrides a method to NULL whether one of
     885                 :            :  * its parent has the method defined or not.  This is equivalent to
     886                 :            :  * ERR_PTR(-ENOENT).  Unfortunately, ERR_PTR doesn't render a constant
     887                 :            :  * expression and thus can't be used as an initializer.
     888                 :            :  */
     889                 :            : #define ATA_OP_NULL             (void *)(unsigned long)(-ENOENT)
     890                 :            : 
     891                 :            : struct ata_port_operations {
     892                 :            :         /*
     893                 :            :          * Command execution
     894                 :            :          */
     895                 :            :         int (*qc_defer)(struct ata_queued_cmd *qc);
     896                 :            :         int (*check_atapi_dma)(struct ata_queued_cmd *qc);
     897                 :            :         enum ata_completion_errors (*qc_prep)(struct ata_queued_cmd *qc);
     898                 :            :         unsigned int (*qc_issue)(struct ata_queued_cmd *qc);
     899                 :            :         bool (*qc_fill_rtf)(struct ata_queued_cmd *qc);
     900                 :            : 
     901                 :            :         /*
     902                 :            :          * Configuration and exception handling
     903                 :            :          */
     904                 :            :         int  (*cable_detect)(struct ata_port *ap);
     905                 :            :         unsigned long (*mode_filter)(struct ata_device *dev, unsigned long xfer_mask);
     906                 :            :         void (*set_piomode)(struct ata_port *ap, struct ata_device *dev);
     907                 :            :         void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev);
     908                 :            :         int  (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev);
     909                 :            :         unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, u16 *id);
     910                 :            : 
     911                 :            :         void (*dev_config)(struct ata_device *dev);
     912                 :            : 
     913                 :            :         void (*freeze)(struct ata_port *ap);
     914                 :            :         void (*thaw)(struct ata_port *ap);
     915                 :            :         ata_prereset_fn_t       prereset;
     916                 :            :         ata_reset_fn_t          softreset;
     917                 :            :         ata_reset_fn_t          hardreset;
     918                 :            :         ata_postreset_fn_t      postreset;
     919                 :            :         ata_prereset_fn_t       pmp_prereset;
     920                 :            :         ata_reset_fn_t          pmp_softreset;
     921                 :            :         ata_reset_fn_t          pmp_hardreset;
     922                 :            :         ata_postreset_fn_t      pmp_postreset;
     923                 :            :         void (*error_handler)(struct ata_port *ap);
     924                 :            :         void (*lost_interrupt)(struct ata_port *ap);
     925                 :            :         void (*post_internal_cmd)(struct ata_queued_cmd *qc);
     926                 :            :         void (*sched_eh)(struct ata_port *ap);
     927                 :            :         void (*end_eh)(struct ata_port *ap);
     928                 :            : 
     929                 :            :         /*
     930                 :            :          * Optional features
     931                 :            :          */
     932                 :            :         int  (*scr_read)(struct ata_link *link, unsigned int sc_reg, u32 *val);
     933                 :            :         int  (*scr_write)(struct ata_link *link, unsigned int sc_reg, u32 val);
     934                 :            :         void (*pmp_attach)(struct ata_port *ap);
     935                 :            :         void (*pmp_detach)(struct ata_port *ap);
     936                 :            :         int  (*set_lpm)(struct ata_link *link, enum ata_lpm_policy policy,
     937                 :            :                         unsigned hints);
     938                 :            : 
     939                 :            :         /*
     940                 :            :          * Start, stop, suspend and resume
     941                 :            :          */
     942                 :            :         int  (*port_suspend)(struct ata_port *ap, pm_message_t mesg);
     943                 :            :         int  (*port_resume)(struct ata_port *ap);
     944                 :            :         int  (*port_start)(struct ata_port *ap);
     945                 :            :         void (*port_stop)(struct ata_port *ap);
     946                 :            :         void (*host_stop)(struct ata_host *host);
     947                 :            : 
     948                 :            : #ifdef CONFIG_ATA_SFF
     949                 :            :         /*
     950                 :            :          * SFF / taskfile oriented ops
     951                 :            :          */
     952                 :            :         void (*sff_dev_select)(struct ata_port *ap, unsigned int device);
     953                 :            :         void (*sff_set_devctl)(struct ata_port *ap, u8 ctl);
     954                 :            :         u8   (*sff_check_status)(struct ata_port *ap);
     955                 :            :         u8   (*sff_check_altstatus)(struct ata_port *ap);
     956                 :            :         void (*sff_tf_load)(struct ata_port *ap, const struct ata_taskfile *tf);
     957                 :            :         void (*sff_tf_read)(struct ata_port *ap, struct ata_taskfile *tf);
     958                 :            :         void (*sff_exec_command)(struct ata_port *ap,
     959                 :            :                                  const struct ata_taskfile *tf);
     960                 :            :         unsigned int (*sff_data_xfer)(struct ata_queued_cmd *qc,
     961                 :            :                         unsigned char *buf, unsigned int buflen, int rw);
     962                 :            :         void (*sff_irq_on)(struct ata_port *);
     963                 :            :         bool (*sff_irq_check)(struct ata_port *);
     964                 :            :         void (*sff_irq_clear)(struct ata_port *);
     965                 :            :         void (*sff_drain_fifo)(struct ata_queued_cmd *qc);
     966                 :            : 
     967                 :            : #ifdef CONFIG_ATA_BMDMA
     968                 :            :         void (*bmdma_setup)(struct ata_queued_cmd *qc);
     969                 :            :         void (*bmdma_start)(struct ata_queued_cmd *qc);
     970                 :            :         void (*bmdma_stop)(struct ata_queued_cmd *qc);
     971                 :            :         u8   (*bmdma_status)(struct ata_port *ap);
     972                 :            : #endif /* CONFIG_ATA_BMDMA */
     973                 :            : #endif /* CONFIG_ATA_SFF */
     974                 :            : 
     975                 :            :         ssize_t (*em_show)(struct ata_port *ap, char *buf);
     976                 :            :         ssize_t (*em_store)(struct ata_port *ap, const char *message,
     977                 :            :                             size_t size);
     978                 :            :         ssize_t (*sw_activity_show)(struct ata_device *dev, char *buf);
     979                 :            :         ssize_t (*sw_activity_store)(struct ata_device *dev,
     980                 :            :                                      enum sw_activity val);
     981                 :            :         ssize_t (*transmit_led_message)(struct ata_port *ap, u32 state,
     982                 :            :                                         ssize_t size);
     983                 :            : 
     984                 :            :         /*
     985                 :            :          * Obsolete
     986                 :            :          */
     987                 :            :         void (*phy_reset)(struct ata_port *ap);
     988                 :            :         void (*eng_timeout)(struct ata_port *ap);
     989                 :            : 
     990                 :            :         /*
     991                 :            :          * ->inherits must be the last field and all the preceding
     992                 :            :          * fields must be pointers.
     993                 :            :          */
     994                 :            :         const struct ata_port_operations        *inherits;
     995                 :            : };
     996                 :            : 
     997                 :            : struct ata_port_info {
     998                 :            :         unsigned long           flags;
     999                 :            :         unsigned long           link_flags;
    1000                 :            :         unsigned long           pio_mask;
    1001                 :            :         unsigned long           mwdma_mask;
    1002                 :            :         unsigned long           udma_mask;
    1003                 :            :         struct ata_port_operations *port_ops;
    1004                 :            :         void                    *private_data;
    1005                 :            : };
    1006                 :            : 
    1007                 :            : struct ata_timing {
    1008                 :            :         unsigned short mode;            /* ATA mode */
    1009                 :            :         unsigned short setup;           /* t1 */
    1010                 :            :         unsigned short act8b;           /* t2 for 8-bit I/O */
    1011                 :            :         unsigned short rec8b;           /* t2i for 8-bit I/O */
    1012                 :            :         unsigned short cyc8b;           /* t0 for 8-bit I/O */
    1013                 :            :         unsigned short active;          /* t2 or tD */
    1014                 :            :         unsigned short recover;         /* t2i or tK */
    1015                 :            :         unsigned short dmack_hold;      /* tj */
    1016                 :            :         unsigned short cycle;           /* t0 */
    1017                 :            :         unsigned short udma;            /* t2CYCTYP/2 */
    1018                 :            : };
    1019                 :            : 
    1020                 :            : /*
    1021                 :            :  * Core layer - drivers/ata/libata-core.c
    1022                 :            :  */
    1023                 :            : extern const unsigned long sata_deb_timing_normal[];
    1024                 :            : extern const unsigned long sata_deb_timing_hotplug[];
    1025                 :            : extern const unsigned long sata_deb_timing_long[];
    1026                 :            : 
    1027                 :            : extern struct ata_port_operations ata_dummy_port_ops;
    1028                 :            : extern const struct ata_port_info ata_dummy_port_info;
    1029                 :            : 
    1030                 :          0 : static inline bool ata_is_atapi(u8 prot)
    1031                 :            : {
    1032         [ #  # ]:          0 :         return prot & ATA_PROT_FLAG_ATAPI;
    1033                 :            : }
    1034                 :            : 
    1035                 :       2162 : static inline bool ata_is_pio(u8 prot)
    1036                 :            : {
    1037   [ +  +  +  + ]:       2162 :         return prot & ATA_PROT_FLAG_PIO;
    1038                 :            : }
    1039                 :            : 
    1040                 :      97164 : static inline bool ata_is_dma(u8 prot)
    1041                 :            : {
    1042   [ +  +  -  +  :      97164 :         return prot & ATA_PROT_FLAG_DMA;
          +  +  -  +  +  
                      + ]
    1043                 :            : }
    1044                 :            : 
    1045                 :      64966 : static inline bool ata_is_ncq(u8 prot)
    1046                 :            : {
    1047   [ -  +  -  +  :      64966 :         return prot & ATA_PROT_FLAG_NCQ;
                   -  + ]
    1048                 :            : }
    1049                 :            : 
    1050                 :      32468 : static inline bool ata_is_data(u8 prot)
    1051                 :            : {
    1052   [ +  +  +  - ]:      32468 :         return prot & (ATA_PROT_FLAG_PIO | ATA_PROT_FLAG_DMA);
    1053                 :            : }
    1054                 :            : 
    1055                 :        360 : static inline int is_multi_taskfile(struct ata_taskfile *tf)
    1056                 :            : {
    1057                 :        360 :         return (tf->command == ATA_CMD_READ_MULTI) ||
    1058                 :        360 :                (tf->command == ATA_CMD_WRITE_MULTI) ||
    1059   [ +  -  +  - ]:        360 :                (tf->command == ATA_CMD_READ_MULTI_EXT) ||
    1060   [ +  -  +  -  :        720 :                (tf->command == ATA_CMD_WRITE_MULTI_EXT) ||
             +  -  -  + ]
    1061                 :            :                (tf->command == ATA_CMD_WRITE_MULTI_FUA_EXT);
    1062                 :            : }
    1063                 :            : 
    1064                 :            : static inline const unsigned long *
    1065                 :         60 : sata_ehc_deb_timing(struct ata_eh_context *ehc)
    1066                 :            : {
    1067   [ -  -  +  -  :         60 :         if (ehc->i.flags & ATA_EHI_HOTPLUGGED)
                   #  # ]
    1068                 :            :                 return sata_deb_timing_hotplug;
    1069                 :            :         else
    1070                 :         60 :                 return sata_deb_timing_normal;
    1071                 :            : }
    1072                 :            : 
    1073                 :        300 : static inline int ata_port_is_dummy(struct ata_port *ap)
    1074                 :            : {
    1075   [ +  +  +  -  :        300 :         return ap->ops == &ata_dummy_port_ops;
          +  -  -  -  +  
             -  +  -  -  
                      + ]
    1076                 :            : }
    1077                 :            : 
    1078                 :            : extern int sata_set_spd(struct ata_link *link);
    1079                 :            : extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
    1080                 :            : extern int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
    1081                 :            :                                 int (*check_ready)(struct ata_link *link));
    1082                 :            : extern int sata_link_debounce(struct ata_link *link,
    1083                 :            :                         const unsigned long *params, unsigned long deadline);
    1084                 :            : extern int sata_link_resume(struct ata_link *link, const unsigned long *params,
    1085                 :            :                             unsigned long deadline);
    1086                 :            : extern int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
    1087                 :            :                              bool spm_wakeup);
    1088                 :            : extern int sata_link_hardreset(struct ata_link *link,
    1089                 :            :                         const unsigned long *timing, unsigned long deadline,
    1090                 :            :                         bool *online, int (*check_ready)(struct ata_link *));
    1091                 :            : extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
    1092                 :            :                               unsigned long deadline);
    1093                 :            : extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
    1094                 :            : 
    1095                 :            : extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
    1096                 :            : extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
    1097                 :            :                         const struct ata_port_info * const * ppi, int n_ports);
    1098                 :            : extern int ata_slave_link_init(struct ata_port *ap);
    1099                 :            : extern void ata_host_get(struct ata_host *host);
    1100                 :            : extern void ata_host_put(struct ata_host *host);
    1101                 :            : extern int ata_host_start(struct ata_host *host);
    1102                 :            : extern int ata_host_register(struct ata_host *host,
    1103                 :            :                              struct scsi_host_template *sht);
    1104                 :            : extern int ata_host_activate(struct ata_host *host, int irq,
    1105                 :            :                              irq_handler_t irq_handler, unsigned long irq_flags,
    1106                 :            :                              struct scsi_host_template *sht);
    1107                 :            : extern void ata_host_detach(struct ata_host *host);
    1108                 :            : extern void ata_host_init(struct ata_host *, struct device *, struct ata_port_operations *);
    1109                 :            : extern int ata_scsi_detect(struct scsi_host_template *sht);
    1110                 :            : extern int ata_scsi_ioctl(struct scsi_device *dev, unsigned int cmd,
    1111                 :            :                           void __user *arg);
    1112                 :            : #ifdef CONFIG_COMPAT
    1113                 :            : #define ATA_SCSI_COMPAT_IOCTL .compat_ioctl = ata_scsi_ioctl,
    1114                 :            : #else
    1115                 :            : #define ATA_SCSI_COMPAT_IOCTL /* empty */
    1116                 :            : #endif
    1117                 :            : extern int ata_scsi_queuecmd(struct Scsi_Host *h, struct scsi_cmnd *cmd);
    1118                 :            : extern int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *dev,
    1119                 :            :                             unsigned int cmd, void __user *arg);
    1120                 :            : extern void ata_sas_port_destroy(struct ata_port *);
    1121                 :            : extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
    1122                 :            :                                            struct ata_port_info *, struct Scsi_Host *);
    1123                 :            : extern void ata_sas_async_probe(struct ata_port *ap);
    1124                 :            : extern int ata_sas_sync_probe(struct ata_port *ap);
    1125                 :            : extern int ata_sas_port_init(struct ata_port *);
    1126                 :            : extern int ata_sas_port_start(struct ata_port *ap);
    1127                 :            : extern int ata_sas_tport_add(struct device *parent, struct ata_port *ap);
    1128                 :            : extern void ata_sas_tport_delete(struct ata_port *ap);
    1129                 :            : extern void ata_sas_port_stop(struct ata_port *ap);
    1130                 :            : extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *);
    1131                 :            : extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap);
    1132                 :            : extern int sata_scr_valid(struct ata_link *link);
    1133                 :            : extern int sata_scr_read(struct ata_link *link, int reg, u32 *val);
    1134                 :            : extern int sata_scr_write(struct ata_link *link, int reg, u32 val);
    1135                 :            : extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val);
    1136                 :            : extern bool ata_link_online(struct ata_link *link);
    1137                 :            : extern bool ata_link_offline(struct ata_link *link);
    1138                 :            : #ifdef CONFIG_PM
    1139                 :            : extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
    1140                 :            : extern void ata_host_resume(struct ata_host *host);
    1141                 :            : extern void ata_sas_port_suspend(struct ata_port *ap);
    1142                 :            : extern void ata_sas_port_resume(struct ata_port *ap);
    1143                 :            : #else
    1144                 :            : static inline void ata_sas_port_suspend(struct ata_port *ap)
    1145                 :            : {
    1146                 :            : }
    1147                 :            : static inline void ata_sas_port_resume(struct ata_port *ap)
    1148                 :            : {
    1149                 :            : }
    1150                 :            : #endif
    1151                 :            : extern int ata_ratelimit(void);
    1152                 :            : extern void ata_msleep(struct ata_port *ap, unsigned int msecs);
    1153                 :            : extern u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask,
    1154                 :            :                         u32 val, unsigned long interval, unsigned long timeout);
    1155                 :            : extern int atapi_cmd_type(u8 opcode);
    1156                 :            : extern void ata_tf_to_fis(const struct ata_taskfile *tf,
    1157                 :            :                           u8 pmp, int is_cmd, u8 *fis);
    1158                 :            : extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
    1159                 :            : extern unsigned long ata_pack_xfermask(unsigned long pio_mask,
    1160                 :            :                         unsigned long mwdma_mask, unsigned long udma_mask);
    1161                 :            : extern void ata_unpack_xfermask(unsigned long xfer_mask,
    1162                 :            :                         unsigned long *pio_mask, unsigned long *mwdma_mask,
    1163                 :            :                         unsigned long *udma_mask);
    1164                 :            : extern u8 ata_xfer_mask2mode(unsigned long xfer_mask);
    1165                 :            : extern unsigned long ata_xfer_mode2mask(u8 xfer_mode);
    1166                 :            : extern int ata_xfer_mode2shift(unsigned long xfer_mode);
    1167                 :            : extern const char *ata_mode_string(unsigned long xfer_mask);
    1168                 :            : extern unsigned long ata_id_xfermask(const u16 *id);
    1169                 :            : extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
    1170                 :            : extern enum ata_completion_errors ata_noop_qc_prep(struct ata_queued_cmd *qc);
    1171                 :            : extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
    1172                 :            :                  unsigned int n_elem);
    1173                 :            : extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
    1174                 :            : extern void ata_dev_disable(struct ata_device *adev);
    1175                 :            : extern void ata_id_string(const u16 *id, unsigned char *s,
    1176                 :            :                           unsigned int ofs, unsigned int len);
    1177                 :            : extern void ata_id_c_string(const u16 *id, unsigned char *s,
    1178                 :            :                             unsigned int ofs, unsigned int len);
    1179                 :            : extern unsigned int ata_do_dev_read_id(struct ata_device *dev,
    1180                 :            :                                         struct ata_taskfile *tf, u16 *id);
    1181                 :            : extern void ata_qc_complete(struct ata_queued_cmd *qc);
    1182                 :            : extern int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active);
    1183                 :            : extern u64 ata_qc_get_active(struct ata_port *ap);
    1184                 :            : extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd);
    1185                 :            : extern int ata_std_bios_param(struct scsi_device *sdev,
    1186                 :            :                               struct block_device *bdev,
    1187                 :            :                               sector_t capacity, int geom[]);
    1188                 :            : extern void ata_scsi_unlock_native_capacity(struct scsi_device *sdev);
    1189                 :            : extern int ata_scsi_slave_config(struct scsi_device *sdev);
    1190                 :            : extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
    1191                 :            : extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
    1192                 :            :                                        int queue_depth);
    1193                 :            : extern int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
    1194                 :            :                                     int queue_depth);
    1195                 :            : extern struct ata_device *ata_dev_pair(struct ata_device *adev);
    1196                 :            : extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
    1197                 :            : extern void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap);
    1198                 :            : extern void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap, struct list_head *eh_q);
    1199                 :            : extern bool sata_lpm_ignore_phy_events(struct ata_link *link);
    1200                 :            : 
    1201                 :            : extern int ata_cable_40wire(struct ata_port *ap);
    1202                 :            : extern int ata_cable_80wire(struct ata_port *ap);
    1203                 :            : extern int ata_cable_sata(struct ata_port *ap);
    1204                 :            : extern int ata_cable_ignore(struct ata_port *ap);
    1205                 :            : extern int ata_cable_unknown(struct ata_port *ap);
    1206                 :            : 
    1207                 :            : /* Timing helpers */
    1208                 :            : extern unsigned int ata_pio_need_iordy(const struct ata_device *);
    1209                 :            : extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);
    1210                 :            : extern int ata_timing_compute(struct ata_device *, unsigned short,
    1211                 :            :                               struct ata_timing *, int, int);
    1212                 :            : extern void ata_timing_merge(const struct ata_timing *,
    1213                 :            :                              const struct ata_timing *, struct ata_timing *,
    1214                 :            :                              unsigned int);
    1215                 :            : extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle);
    1216                 :            : 
    1217                 :            : /* PCI */
    1218                 :            : #ifdef CONFIG_PCI
    1219                 :            : struct pci_dev;
    1220                 :            : 
    1221                 :            : struct pci_bits {
    1222                 :            :         unsigned int            reg;    /* PCI config register to read */
    1223                 :            :         unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
    1224                 :            :         unsigned long           mask;
    1225                 :            :         unsigned long           val;
    1226                 :            : };
    1227                 :            : 
    1228                 :            : extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
    1229                 :            : extern void ata_pci_shutdown_one(struct pci_dev *pdev);
    1230                 :            : extern void ata_pci_remove_one(struct pci_dev *pdev);
    1231                 :            : 
    1232                 :            : #ifdef CONFIG_PM
    1233                 :            : extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
    1234                 :            : extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
    1235                 :            : extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
    1236                 :            : extern int ata_pci_device_resume(struct pci_dev *pdev);
    1237                 :            : #endif /* CONFIG_PM */
    1238                 :            : #endif /* CONFIG_PCI */
    1239                 :            : 
    1240                 :            : struct platform_device;
    1241                 :            : 
    1242                 :            : extern int ata_platform_remove_one(struct platform_device *pdev);
    1243                 :            : 
    1244                 :            : /*
    1245                 :            :  * ACPI - drivers/ata/libata-acpi.c
    1246                 :            :  */
    1247                 :            : #ifdef CONFIG_ATA_ACPI
    1248                 :          0 : static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
    1249                 :            : {
    1250   [ #  #  #  # ]:          0 :         if (ap->pflags & ATA_PFLAG_INIT_GTM_VALID)
    1251         [ #  # ]:          0 :                 return &ap->__acpi_init_gtm;
    1252                 :            :         return NULL;
    1253                 :            : }
    1254                 :            : int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm);
    1255                 :            : int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm);
    1256                 :            : unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
    1257                 :            :                                     const struct ata_acpi_gtm *gtm);
    1258                 :            : int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm);
    1259                 :            : #else
    1260                 :            : static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
    1261                 :            : {
    1262                 :            :         return NULL;
    1263                 :            : }
    1264                 :            : 
    1265                 :            : static inline int ata_acpi_stm(const struct ata_port *ap,
    1266                 :            :                                struct ata_acpi_gtm *stm)
    1267                 :            : {
    1268                 :            :         return -ENOSYS;
    1269                 :            : }
    1270                 :            : 
    1271                 :            : static inline int ata_acpi_gtm(const struct ata_port *ap,
    1272                 :            :                                struct ata_acpi_gtm *stm)
    1273                 :            : {
    1274                 :            :         return -ENOSYS;
    1275                 :            : }
    1276                 :            : 
    1277                 :            : static inline unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev,
    1278                 :            :                                         const struct ata_acpi_gtm *gtm)
    1279                 :            : {
    1280                 :            :         return 0;
    1281                 :            : }
    1282                 :            : 
    1283                 :            : static inline int ata_acpi_cbl_80wire(struct ata_port *ap,
    1284                 :            :                                       const struct ata_acpi_gtm *gtm)
    1285                 :            : {
    1286                 :            :         return 0;
    1287                 :            : }
    1288                 :            : #endif
    1289                 :            : 
    1290                 :            : /*
    1291                 :            :  * EH - drivers/ata/libata-eh.c
    1292                 :            :  */
    1293                 :            : extern void ata_port_schedule_eh(struct ata_port *ap);
    1294                 :            : extern void ata_port_wait_eh(struct ata_port *ap);
    1295                 :            : extern int ata_link_abort(struct ata_link *link);
    1296                 :            : extern int ata_port_abort(struct ata_port *ap);
    1297                 :            : extern int ata_port_freeze(struct ata_port *ap);
    1298                 :            : extern int sata_async_notification(struct ata_port *ap);
    1299                 :            : 
    1300                 :            : extern void ata_eh_freeze_port(struct ata_port *ap);
    1301                 :            : extern void ata_eh_thaw_port(struct ata_port *ap);
    1302                 :            : 
    1303                 :            : extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
    1304                 :            : extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
    1305                 :            : extern void ata_eh_analyze_ncq_error(struct ata_link *link);
    1306                 :            : 
    1307                 :            : extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
    1308                 :            :                       ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
    1309                 :            :                       ata_postreset_fn_t postreset);
    1310                 :            : extern void ata_std_error_handler(struct ata_port *ap);
    1311                 :            : extern void ata_std_sched_eh(struct ata_port *ap);
    1312                 :            : extern void ata_std_end_eh(struct ata_port *ap);
    1313                 :            : extern int ata_link_nr_enabled(struct ata_link *link);
    1314                 :            : 
    1315                 :            : /*
    1316                 :            :  * Base operations to inherit from and initializers for sht
    1317                 :            :  *
    1318                 :            :  * Operations
    1319                 :            :  *
    1320                 :            :  * base  : Common to all libata drivers.
    1321                 :            :  * sata  : SATA controllers w/ native interface.
    1322                 :            :  * pmp   : SATA controllers w/ PMP support.
    1323                 :            :  * sff   : SFF ATA controllers w/o BMDMA support.
    1324                 :            :  * bmdma : SFF ATA controllers w/ BMDMA support.
    1325                 :            :  *
    1326                 :            :  * sht initializers
    1327                 :            :  *
    1328                 :            :  * BASE  : Common to all libata drivers.  The user must set
    1329                 :            :  *         sg_tablesize and dma_boundary.
    1330                 :            :  * PIO   : SFF ATA controllers w/ only PIO support.
    1331                 :            :  * BMDMA : SFF ATA controllers w/ BMDMA support.  sg_tablesize and
    1332                 :            :  *         dma_boundary are set to BMDMA limits.
    1333                 :            :  * NCQ   : SATA controllers supporting NCQ.  The user must set
    1334                 :            :  *         sg_tablesize, dma_boundary and can_queue.
    1335                 :            :  */
    1336                 :            : extern const struct ata_port_operations ata_base_port_ops;
    1337                 :            : extern const struct ata_port_operations sata_port_ops;
    1338                 :            : extern struct device_attribute *ata_common_sdev_attrs[];
    1339                 :            : 
    1340                 :            : /*
    1341                 :            :  * All sht initializers (BASE, PIO, BMDMA, NCQ) must be instantiated
    1342                 :            :  * by the edge drivers.  Because the 'module' field of sht must be the
    1343                 :            :  * edge driver's module reference, otherwise the driver can be unloaded
    1344                 :            :  * even if the scsi_device is being accessed.
    1345                 :            :  */
    1346                 :            : #define ATA_BASE_SHT(drv_name)                                  \
    1347                 :            :         .module                 = THIS_MODULE,                  \
    1348                 :            :         .name                   = drv_name,                     \
    1349                 :            :         .ioctl                  = ata_scsi_ioctl,               \
    1350                 :            :         ATA_SCSI_COMPAT_IOCTL                                   \
    1351                 :            :         .queuecommand           = ata_scsi_queuecmd,            \
    1352                 :            :         .can_queue              = ATA_DEF_QUEUE,                \
    1353                 :            :         .tag_alloc_policy       = BLK_TAG_ALLOC_RR,             \
    1354                 :            :         .this_id                = ATA_SHT_THIS_ID,              \
    1355                 :            :         .emulated               = ATA_SHT_EMULATED,             \
    1356                 :            :         .proc_name              = drv_name,                     \
    1357                 :            :         .slave_configure        = ata_scsi_slave_config,        \
    1358                 :            :         .slave_destroy          = ata_scsi_slave_destroy,       \
    1359                 :            :         .bios_param             = ata_std_bios_param,           \
    1360                 :            :         .unlock_native_capacity = ata_scsi_unlock_native_capacity, \
    1361                 :            :         .sdev_attrs             = ata_common_sdev_attrs
    1362                 :            : 
    1363                 :            : #define ATA_NCQ_SHT(drv_name)                                   \
    1364                 :            :         ATA_BASE_SHT(drv_name),                                 \
    1365                 :            :         .change_queue_depth     = ata_scsi_change_queue_depth
    1366                 :            : 
    1367                 :            : /*
    1368                 :            :  * PMP helpers
    1369                 :            :  */
    1370                 :            : #ifdef CONFIG_SATA_PMP
    1371                 :          0 : static inline bool sata_pmp_supported(struct ata_port *ap)
    1372                 :            : {
    1373         [ #  # ]:          0 :         return ap->flags & ATA_FLAG_PMP;
    1374                 :            : }
    1375                 :            : 
    1376                 :      74896 : static inline bool sata_pmp_attached(struct ata_port *ap)
    1377                 :            : {
    1378   [ -  +  +  -  :      74896 :         return ap->nr_pmp_links != 0;
          +  +  -  +  -  
                      - ]
    1379                 :            : }
    1380                 :            : 
    1381                 :      45998 : static inline bool ata_is_host_link(const struct ata_link *link)
    1382                 :            : {
    1383   [ -  +  -  -  :       1770 :         return link == &link->ap->link || link == link->ap->slave_link;
          +  -  -  +  -  
          -  +  -  -  +  
          -  -  +  -  -  
          +  -  -  +  -  
          -  -  -  -  -  
          -  -  +  -  -  
          +  -  -  +  -  
          -  +  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
                      - ]
    1384                 :            : }
    1385                 :            : #else /* CONFIG_SATA_PMP */
    1386                 :            : static inline bool sata_pmp_supported(struct ata_port *ap)
    1387                 :            : {
    1388                 :            :         return false;
    1389                 :            : }
    1390                 :            : 
    1391                 :            : static inline bool sata_pmp_attached(struct ata_port *ap)
    1392                 :            : {
    1393                 :            :         return false;
    1394                 :            : }
    1395                 :            : 
    1396                 :            : static inline bool ata_is_host_link(const struct ata_link *link)
    1397                 :            : {
    1398                 :            :         return 1;
    1399                 :            : }
    1400                 :            : #endif /* CONFIG_SATA_PMP */
    1401                 :            : 
    1402                 :          0 : static inline int sata_srst_pmp(struct ata_link *link)
    1403                 :            : {
    1404   [ #  #  #  #  :          0 :         if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
             #  #  #  # ]
    1405                 :            :                 return SATA_PMP_CTRL_PORT;
    1406                 :          0 :         return link->pmp;
    1407                 :            : }
    1408                 :            : 
    1409                 :            : /*
    1410                 :            :  * printk helpers
    1411                 :            :  */
    1412                 :            : __printf(3, 4)
    1413                 :            : void ata_port_printk(const struct ata_port *ap, const char *level,
    1414                 :            :                      const char *fmt, ...);
    1415                 :            : __printf(3, 4)
    1416                 :            : void ata_link_printk(const struct ata_link *link, const char *level,
    1417                 :            :                      const char *fmt, ...);
    1418                 :            : __printf(3, 4)
    1419                 :            : void ata_dev_printk(const struct ata_device *dev, const char *level,
    1420                 :            :                     const char *fmt, ...);
    1421                 :            : 
    1422                 :            : #define ata_port_err(ap, fmt, ...)                              \
    1423                 :            :         ata_port_printk(ap, KERN_ERR, fmt, ##__VA_ARGS__)
    1424                 :            : #define ata_port_warn(ap, fmt, ...)                             \
    1425                 :            :         ata_port_printk(ap, KERN_WARNING, fmt, ##__VA_ARGS__)
    1426                 :            : #define ata_port_notice(ap, fmt, ...)                           \
    1427                 :            :         ata_port_printk(ap, KERN_NOTICE, fmt, ##__VA_ARGS__)
    1428                 :            : #define ata_port_info(ap, fmt, ...)                             \
    1429                 :            :         ata_port_printk(ap, KERN_INFO, fmt, ##__VA_ARGS__)
    1430                 :            : #define ata_port_dbg(ap, fmt, ...)                              \
    1431                 :            :         ata_port_printk(ap, KERN_DEBUG, fmt, ##__VA_ARGS__)
    1432                 :            : 
    1433                 :            : #define ata_link_err(link, fmt, ...)                            \
    1434                 :            :         ata_link_printk(link, KERN_ERR, fmt, ##__VA_ARGS__)
    1435                 :            : #define ata_link_warn(link, fmt, ...)                           \
    1436                 :            :         ata_link_printk(link, KERN_WARNING, fmt, ##__VA_ARGS__)
    1437                 :            : #define ata_link_notice(link, fmt, ...)                         \
    1438                 :            :         ata_link_printk(link, KERN_NOTICE, fmt, ##__VA_ARGS__)
    1439                 :            : #define ata_link_info(link, fmt, ...)                           \
    1440                 :            :         ata_link_printk(link, KERN_INFO, fmt, ##__VA_ARGS__)
    1441                 :            : #define ata_link_dbg(link, fmt, ...)                            \
    1442                 :            :         ata_link_printk(link, KERN_DEBUG, fmt, ##__VA_ARGS__)
    1443                 :            : 
    1444                 :            : #define ata_dev_err(dev, fmt, ...)                              \
    1445                 :            :         ata_dev_printk(dev, KERN_ERR, fmt, ##__VA_ARGS__)
    1446                 :            : #define ata_dev_warn(dev, fmt, ...)                             \
    1447                 :            :         ata_dev_printk(dev, KERN_WARNING, fmt, ##__VA_ARGS__)
    1448                 :            : #define ata_dev_notice(dev, fmt, ...)                           \
    1449                 :            :         ata_dev_printk(dev, KERN_NOTICE, fmt, ##__VA_ARGS__)
    1450                 :            : #define ata_dev_info(dev, fmt, ...)                             \
    1451                 :            :         ata_dev_printk(dev, KERN_INFO, fmt, ##__VA_ARGS__)
    1452                 :            : #define ata_dev_dbg(dev, fmt, ...)                              \
    1453                 :            :         ata_dev_printk(dev, KERN_DEBUG, fmt, ##__VA_ARGS__)
    1454                 :            : 
    1455                 :            : void ata_print_version(const struct device *dev, const char *version);
    1456                 :            : 
    1457                 :            : /*
    1458                 :            :  * ata_eh_info helpers
    1459                 :            :  */
    1460                 :            : extern __printf(2, 3)
    1461                 :            : void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
    1462                 :            : extern __printf(2, 3)
    1463                 :            : void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
    1464                 :            : extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
    1465                 :            : 
    1466                 :          0 : static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
    1467                 :            : {
    1468                 :          0 :         ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
    1469                 :          0 :         ehi->flags |= ATA_EHI_HOTPLUGGED;
    1470                 :          0 :         ehi->action |= ATA_EH_RESET | ATA_EH_ENABLE_LINK;
    1471         [ #  # ]:          0 :         ehi->err_mask |= AC_ERR_ATA_BUS;
    1472                 :          0 : }
    1473                 :            : 
    1474                 :            : /*
    1475                 :            :  * port description helpers
    1476                 :            :  */
    1477                 :            : extern __printf(2, 3)
    1478                 :            : void ata_port_desc(struct ata_port *ap, const char *fmt, ...);
    1479                 :            : #ifdef CONFIG_PCI
    1480                 :            : extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
    1481                 :            :                                const char *name);
    1482                 :            : #endif
    1483                 :            : 
    1484                 :      67486 : static inline bool ata_tag_internal(unsigned int tag)
    1485                 :            : {
    1486   [ +  +  -  - ]:      33518 :         return tag == ATA_TAG_INTERNAL;
    1487                 :            : }
    1488                 :            : 
    1489                 :     136254 : static inline bool ata_tag_valid(unsigned int tag)
    1490                 :            : {
    1491   [ +  +  -  +  :      66856 :         return tag < ATA_MAX_QUEUE || ata_tag_internal(tag);
          +  +  +  -  +  
          +  +  -  +  +  
          -  -  -  -  -  
          -  -  -  -  -  
             -  -  -  - ]
    1492                 :            : }
    1493                 :            : 
    1494                 :            : #define __ata_qc_for_each(ap, qc, tag, max_tag, fn)             \
    1495                 :            :         for ((tag) = 0; (tag) < (max_tag) &&                 \
    1496                 :            :              ({ qc = fn((ap), (tag)); 1; }); (tag)++)           \
    1497                 :            : 
    1498                 :            : /*
    1499                 :            :  * Internal use only, iterate commands ignoring error handling and
    1500                 :            :  * status of 'qc'.
    1501                 :            :  */
    1502                 :            : #define ata_qc_for_each_raw(ap, qc, tag)                                        \
    1503                 :            :         __ata_qc_for_each(ap, qc, tag, ATA_MAX_QUEUE, __ata_qc_from_tag)
    1504                 :            : 
    1505                 :            : /*
    1506                 :            :  * Iterate all potential commands that can be queued
    1507                 :            :  */
    1508                 :            : #define ata_qc_for_each(ap, qc, tag)                                    \
    1509                 :            :         __ata_qc_for_each(ap, qc, tag, ATA_MAX_QUEUE, ata_qc_from_tag)
    1510                 :            : 
    1511                 :            : /*
    1512                 :            :  * Like ata_qc_for_each, but with the internal tag included
    1513                 :            :  */
    1514                 :            : #define ata_qc_for_each_with_internal(ap, qc, tag)                      \
    1515                 :            :         __ata_qc_for_each(ap, qc, tag, ATA_MAX_QUEUE + 1, ata_qc_from_tag)
    1516                 :            : 
    1517                 :            : /*
    1518                 :            :  * device helpers
    1519                 :            :  */
    1520                 :      39098 : static inline unsigned int ata_class_enabled(unsigned int class)
    1521                 :            : {
    1522                 :      39098 :         return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI ||
    1523   [ +  -  +  +  :       2280 :                 class == ATA_DEV_PMP || class == ATA_DEV_SEMB ||
          -  -  -  -  +  
          -  +  -  +  +  
          +  -  +  -  -  
          -  -  -  -  -  
          -  -  +  -  +  
                -  +  - ]
    1524                 :            :                 class == ATA_DEV_ZAC;
    1525                 :            : }
    1526                 :            : 
    1527                 :          0 : static inline unsigned int ata_class_disabled(unsigned int class)
    1528                 :            : {
    1529                 :          0 :         return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP ||
    1530   [ #  #  #  # ]:          0 :                 class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP ||
    1531                 :            :                 class == ATA_DEV_ZAC_UNSUP;
    1532                 :            : }
    1533                 :            : 
    1534                 :            : static inline unsigned int ata_class_absent(unsigned int class)
    1535                 :            : {
    1536                 :            :         return !ata_class_enabled(class) && !ata_class_disabled(class);
    1537                 :            : }
    1538                 :            : 
    1539                 :      38558 : static inline unsigned int ata_dev_enabled(const struct ata_device *dev)
    1540                 :            : {
    1541   [ +  +  -  +  :      38558 :         return ata_class_enabled(dev->class);
          +  -  -  -  +  
                +  +  + ]
    1542                 :            : }
    1543                 :            : 
    1544                 :          0 : static inline unsigned int ata_dev_disabled(const struct ata_device *dev)
    1545                 :            : {
    1546         [ #  # ]:          0 :         return ata_class_disabled(dev->class);
    1547                 :            : }
    1548                 :            : 
    1549                 :            : static inline unsigned int ata_dev_absent(const struct ata_device *dev)
    1550                 :            : {
    1551                 :            :         return ata_class_absent(dev->class);
    1552                 :            : }
    1553                 :            : 
    1554                 :            : /*
    1555                 :            :  * link helpers
    1556                 :            :  */
    1557                 :      44228 : static inline int ata_link_max_devices(const struct ata_link *link)
    1558                 :            : {
    1559   [ -  +  +  -  :      44228 :         if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS)
             -  +  +  - ]
    1560                 :            :                 return 2;
    1561                 :            :         return 1;
    1562                 :            : }
    1563                 :            : 
    1564                 :          0 : static inline int ata_link_active(struct ata_link *link)
    1565                 :            : {
    1566   [ #  #  #  #  :          0 :         return ata_tag_valid(link->active_tag) || link->sactive;
                   #  # ]
    1567                 :            : }
    1568                 :            : 
    1569                 :            : /*
    1570                 :            :  * Iterators
    1571                 :            :  *
    1572                 :            :  * ATA_LITER_* constants are used to select link iteration mode and
    1573                 :            :  * ATA_DITER_* device iteration mode.
    1574                 :            :  *
    1575                 :            :  * For a custom iteration directly using ata_{link|dev}_next(), if
    1576                 :            :  * @link or @dev, respectively, is NULL, the first element is
    1577                 :            :  * returned.  @dev and @link can be any valid device or link and the
    1578                 :            :  * next element according to the iteration mode will be returned.
    1579                 :            :  * After the last element, NULL is returned.
    1580                 :            :  */
    1581                 :            : enum ata_link_iter_mode {
    1582                 :            :         ATA_LITER_EDGE,         /* if present, PMP links only; otherwise,
    1583                 :            :                                  * host link.  no slave link */
    1584                 :            :         ATA_LITER_HOST_FIRST,   /* host link followed by PMP or slave links */
    1585                 :            :         ATA_LITER_PMP_FIRST,    /* PMP links followed by host link,
    1586                 :            :                                  * slave link still comes after host link */
    1587                 :            : };
    1588                 :            : 
    1589                 :            : enum ata_dev_iter_mode {
    1590                 :            :         ATA_DITER_ENABLED,
    1591                 :            :         ATA_DITER_ENABLED_REVERSE,
    1592                 :            :         ATA_DITER_ALL,
    1593                 :            :         ATA_DITER_ALL_REVERSE,
    1594                 :            : };
    1595                 :            : 
    1596                 :            : extern struct ata_link *ata_link_next(struct ata_link *link,
    1597                 :            :                                       struct ata_port *ap,
    1598                 :            :                                       enum ata_link_iter_mode mode);
    1599                 :            : 
    1600                 :            : extern struct ata_device *ata_dev_next(struct ata_device *dev,
    1601                 :            :                                        struct ata_link *link,
    1602                 :            :                                        enum ata_dev_iter_mode mode);
    1603                 :            : 
    1604                 :            : /*
    1605                 :            :  * Shortcut notation for iterations
    1606                 :            :  *
    1607                 :            :  * ata_for_each_link() iterates over each link of @ap according to
    1608                 :            :  * @mode.  @link points to the current link in the loop.  @link is
    1609                 :            :  * NULL after loop termination.  ata_for_each_dev() works the same way
    1610                 :            :  * except that it iterates over each device of @link.
    1611                 :            :  *
    1612                 :            :  * Note that the mode prefixes ATA_{L|D}ITER_ shouldn't need to be
    1613                 :            :  * specified when using the following shorthand notations.  Only the
    1614                 :            :  * mode itself (EDGE, HOST_FIRST, ENABLED, etc...) should be
    1615                 :            :  * specified.  This not only increases brevity but also makes it
    1616                 :            :  * impossible to use ATA_LITER_* for device iteration or vice-versa.
    1617                 :            :  */
    1618                 :            : #define ata_for_each_link(link, ap, mode) \
    1619                 :            :         for ((link) = ata_link_next(NULL, (ap), ATA_LITER_##mode); (link); \
    1620                 :            :              (link) = ata_link_next((link), (ap), ATA_LITER_##mode))
    1621                 :            : 
    1622                 :            : #define ata_for_each_dev(dev, link, mode) \
    1623                 :            :         for ((dev) = ata_dev_next(NULL, (link), ATA_DITER_##mode); (dev); \
    1624                 :            :              (dev) = ata_dev_next((dev), (link), ATA_DITER_##mode))
    1625                 :            : 
    1626                 :            : /**
    1627                 :            :  *      ata_ncq_enabled - Test whether NCQ is enabled
    1628                 :            :  *      @dev: ATA device to test for
    1629                 :            :  *
    1630                 :            :  *      LOCKING:
    1631                 :            :  *      spin_lock_irqsave(host lock)
    1632                 :            :  *
    1633                 :            :  *      RETURNS:
    1634                 :            :  *      1 if NCQ is enabled for @dev, 0 otherwise.
    1635                 :            :  */
    1636                 :      30486 : static inline int ata_ncq_enabled(struct ata_device *dev)
    1637                 :            : {
    1638   [ -  +  #  #  :      30486 :         return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
          #  #  #  #  #  
                      # ]
    1639         [ #  # ]:          0 :                               ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ;
    1640                 :            : }
    1641                 :            : 
    1642                 :          0 : static inline bool ata_fpdma_dsm_supported(struct ata_device *dev)
    1643                 :            : {
    1644   [ #  #  #  # ]:          0 :         return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
    1645         [ #  # ]:          0 :                 (dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &
    1646                 :            :                  ATA_LOG_NCQ_SEND_RECV_DSM_TRIM);
    1647                 :            : }
    1648                 :            : 
    1649                 :            : static inline bool ata_fpdma_read_log_supported(struct ata_device *dev)
    1650                 :            : {
    1651                 :            :         return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
    1652                 :            :                 (dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_RD_LOG_OFFSET] &
    1653                 :            :                  ATA_LOG_NCQ_SEND_RECV_RD_LOG_SUPPORTED);
    1654                 :            : }
    1655                 :            : 
    1656                 :          0 : static inline bool ata_fpdma_zac_mgmt_in_supported(struct ata_device *dev)
    1657                 :            : {
    1658   [ #  #  #  # ]:          0 :         return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
    1659         [ #  # ]:          0 :                 (dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_OFFSET] &
    1660                 :            :                 ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_IN_SUPPORTED);
    1661                 :            : }
    1662                 :            : 
    1663                 :          0 : static inline bool ata_fpdma_zac_mgmt_out_supported(struct ata_device *dev)
    1664                 :            : {
    1665         [ #  # ]:          0 :         return (dev->ncq_non_data_cmds[ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OFFSET] &
    1666                 :            :                 ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OUT);
    1667                 :            : }
    1668                 :            : 
    1669                 :        300 : static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
    1670                 :            : {
    1671                 :        300 :         qc->tf.ctl |= ATA_NIEN;
    1672                 :        300 : }
    1673                 :            : 
    1674                 :      71198 : static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
    1675                 :            :                                                        unsigned int tag)
    1676                 :            : {
    1677   [ +  +  +  +  :      58238 :         if (ata_tag_valid(tag))
          +  +  +  +  +  
          +  +  -  +  -  
          -  -  -  -  -  
             -  -  -  +  
                      - ]
    1678   [ +  -  +  - ]:      58448 :                 return &ap->qcmd[tag];
    1679                 :            :         return NULL;
    1680                 :            : }
    1681                 :            : 
    1682                 :      14730 : static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap,
    1683                 :            :                                                      unsigned int tag)
    1684                 :            : {
    1685   [ +  +  +  +  :       2220 :         struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
                   +  - ]
    1686                 :            : 
    1687   [ +  +  +  -  :      14730 :         if (unlikely(!qc) || !ap->ops->error_handler)
          +  -  +  -  +  
          -  -  -  -  -  
             -  -  -  - ]
    1688                 :            :                 return qc;
    1689                 :            : 
    1690   [ +  +  +  -  :      14670 :         if ((qc->flags & (ATA_QCFLAG_ACTIVE |
             +  -  -  - ]
    1691                 :            :                           ATA_QCFLAG_FAILED)) == ATA_QCFLAG_ACTIVE)
    1692                 :          0 :                 return qc;
    1693                 :            : 
    1694                 :            :         return NULL;
    1695                 :            : }
    1696                 :            : 
    1697                 :        930 : static inline unsigned int ata_qc_raw_nbytes(struct ata_queued_cmd *qc)
    1698                 :            : {
    1699         [ +  + ]:        930 :         return qc->nbytes - min(qc->extrabytes, qc->nbytes);
    1700                 :            : }
    1701                 :            : 
    1702                 :      32978 : static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
    1703                 :            : {
    1704                 :      32978 :         memset(tf, 0, sizeof(*tf));
    1705                 :            : 
    1706                 :            : #ifdef CONFIG_ATA_SFF
    1707                 :      32978 :         tf->ctl = dev->link->ap->ctl;
    1708                 :            : #else
    1709                 :            :         tf->ctl = ATA_DEVCTL_OBS;
    1710                 :            : #endif
    1711   [ -  -  -  -  :        630 :         if (dev->devno == 0)
          +  +  -  -  +  
             +  -  -  -  
                      - ]
    1712                 :      29528 :                 tf->device = ATA_DEVICE_OBS;
    1713                 :            :         else
    1714                 :       3450 :                 tf->device = ATA_DEVICE_OBS | ATA_DEV1;
    1715                 :            : }
    1716                 :            : 
    1717                 :      32348 : static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
    1718                 :            : {
    1719                 :      32348 :         qc->dma_dir = DMA_NONE;
    1720                 :      32348 :         qc->sg = NULL;
    1721                 :      32348 :         qc->flags = 0;
    1722                 :      32348 :         qc->cursg = NULL;
    1723                 :      32348 :         qc->cursg_ofs = 0;
    1724                 :      32348 :         qc->nbytes = qc->extrabytes = qc->curbytes = 0;
    1725                 :      32348 :         qc->n_elem = 0;
    1726                 :      32348 :         qc->err_mask = 0;
    1727                 :      32348 :         qc->sect_size = ATA_SECT_SIZE;
    1728                 :            : 
    1729         [ +  + ]:      32348 :         ata_tf_init(qc->dev, &qc->tf);
    1730                 :            : 
    1731                 :            :         /* init result_tf such that it indicates normal completion */
    1732                 :      32348 :         qc->result_tf.command = ATA_DRDY;
    1733                 :      32348 :         qc->result_tf.feature = 0;
    1734                 :      32348 : }
    1735                 :            : 
    1736                 :        542 : static inline int ata_try_flush_cache(const struct ata_device *dev)
    1737                 :            : {
    1738   [ +  -  -  - ]:        542 :         return ata_id_wcache_enabled(dev->id) ||
    1739   [ -  +  -  - ]:        542 :                ata_id_has_flush(dev->id) ||
    1740                 :            :                ata_id_has_flush_ext(dev->id);
    1741                 :            : }
    1742                 :            : 
    1743                 :        330 : static inline unsigned int ac_err_mask(u8 status)
    1744                 :            : {
    1745                 :        330 :         if (status & (ATA_BUSY | ATA_DRQ))
    1746                 :            :                 return AC_ERR_HSM;
    1747         [ -  + ]:        330 :         if (status & (ATA_ERR | ATA_DF))
    1748                 :            :                 return AC_ERR_DEV;
    1749                 :            :         return 0;
    1750                 :            : }
    1751                 :            : 
    1752                 :        330 : static inline unsigned int __ac_err_mask(u8 status)
    1753                 :            : {
    1754         [ +  - ]:        330 :         unsigned int mask = ac_err_mask(status);
    1755                 :          0 :         if (mask == 0)
    1756                 :          0 :                 return AC_ERR_OTHER;
    1757                 :            :         return mask;
    1758                 :            : }
    1759                 :            : 
    1760                 :      35318 : static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host)
    1761                 :            : {
    1762   [ -  -  -  -  :      35318 :         return *(struct ata_port **)&host->hostdata[0];
          +  -  -  -  -  
          -  -  -  -  -  
             -  -  -  - ]
    1763                 :            : }
    1764                 :            : 
    1765                 :        180 : static inline int ata_check_ready(u8 status)
    1766                 :            : {
    1767   [ -  +  #  # ]:        180 :         if (!(status & ATA_BUSY))
    1768                 :            :                 return 1;
    1769                 :            : 
    1770                 :            :         /* 0xff indicates either no device or device not ready */
    1771   [ #  #  #  # ]:          0 :         if (status == 0xff)
    1772                 :          0 :                 return -ENODEV;
    1773                 :            : 
    1774                 :            :         return 0;
    1775                 :            : }
    1776                 :            : 
    1777                 :        300 : static inline unsigned long ata_deadline(unsigned long from_jiffies,
    1778                 :            :                                          unsigned long timeout_msecs)
    1779                 :            : {
    1780   [ -  -  -  +  :        360 :         return from_jiffies + msecs_to_jiffies(timeout_msecs);
          -  +  +  -  -  
                -  -  - ]
    1781                 :            : }
    1782                 :            : 
    1783                 :            : /* Don't open code these in drivers as there are traps. Firstly the range may
    1784                 :            :    change in future hardware and specs, secondly 0xFF means 'no DMA' but is
    1785                 :            :    > UDMA_0. Dyma ddreigiau */
    1786                 :            : 
    1787                 :            : static inline int ata_using_mwdma(struct ata_device *adev)
    1788                 :            : {
    1789                 :            :         if (adev->dma_mode >= XFER_MW_DMA_0 && adev->dma_mode <= XFER_MW_DMA_4)
    1790                 :            :                 return 1;
    1791                 :            :         return 0;
    1792                 :            : }
    1793                 :            : 
    1794                 :            : static inline int ata_using_udma(struct ata_device *adev)
    1795                 :            : {
    1796                 :            :         if (adev->dma_mode >= XFER_UDMA_0 && adev->dma_mode <= XFER_UDMA_7)
    1797                 :            :                 return 1;
    1798                 :            :         return 0;
    1799                 :            : }
    1800                 :            : 
    1801                 :        180 : static inline int ata_dma_enabled(struct ata_device *adev)
    1802                 :            : {
    1803   [ +  -  -  + ]:        180 :         return (adev->dma_mode == 0xFF ? 0 : 1);
    1804                 :            : }
    1805                 :            : 
    1806                 :            : /**************************************************************************
    1807                 :            :  * PMP - drivers/ata/libata-pmp.c
    1808                 :            :  */
    1809                 :            : #ifdef CONFIG_SATA_PMP
    1810                 :            : 
    1811                 :            : extern const struct ata_port_operations sata_pmp_port_ops;
    1812                 :            : 
    1813                 :            : extern int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc);
    1814                 :            : extern void sata_pmp_error_handler(struct ata_port *ap);
    1815                 :            : 
    1816                 :            : #else /* CONFIG_SATA_PMP */
    1817                 :            : 
    1818                 :            : #define sata_pmp_port_ops               sata_port_ops
    1819                 :            : #define sata_pmp_qc_defer_cmd_switch    ata_std_qc_defer
    1820                 :            : #define sata_pmp_error_handler          ata_std_error_handler
    1821                 :            : 
    1822                 :            : #endif /* CONFIG_SATA_PMP */
    1823                 :            : 
    1824                 :            : 
    1825                 :            : /**************************************************************************
    1826                 :            :  * SFF - drivers/ata/libata-sff.c
    1827                 :            :  */
    1828                 :            : #ifdef CONFIG_ATA_SFF
    1829                 :            : 
    1830                 :            : extern const struct ata_port_operations ata_sff_port_ops;
    1831                 :            : extern const struct ata_port_operations ata_bmdma32_port_ops;
    1832                 :            : 
    1833                 :            : /* PIO only, sg_tablesize and dma_boundary limits can be removed */
    1834                 :            : #define ATA_PIO_SHT(drv_name)                                   \
    1835                 :            :         ATA_BASE_SHT(drv_name),                                 \
    1836                 :            :         .sg_tablesize           = LIBATA_MAX_PRD,               \
    1837                 :            :         .dma_boundary           = ATA_DMA_BOUNDARY
    1838                 :            : 
    1839                 :            : extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device);
    1840                 :            : extern u8 ata_sff_check_status(struct ata_port *ap);
    1841                 :            : extern void ata_sff_pause(struct ata_port *ap);
    1842                 :            : extern void ata_sff_dma_pause(struct ata_port *ap);
    1843                 :            : extern int ata_sff_busy_sleep(struct ata_port *ap,
    1844                 :            :                               unsigned long timeout_pat, unsigned long timeout);
    1845                 :            : extern int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline);
    1846                 :            : extern void ata_sff_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
    1847                 :            : extern void ata_sff_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
    1848                 :            : extern void ata_sff_exec_command(struct ata_port *ap,
    1849                 :            :                                  const struct ata_taskfile *tf);
    1850                 :            : extern unsigned int ata_sff_data_xfer(struct ata_queued_cmd *qc,
    1851                 :            :                         unsigned char *buf, unsigned int buflen, int rw);
    1852                 :            : extern unsigned int ata_sff_data_xfer32(struct ata_queued_cmd *qc,
    1853                 :            :                         unsigned char *buf, unsigned int buflen, int rw);
    1854                 :            : extern void ata_sff_irq_on(struct ata_port *ap);
    1855                 :            : extern void ata_sff_irq_clear(struct ata_port *ap);
    1856                 :            : extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
    1857                 :            :                             u8 status, int in_wq);
    1858                 :            : extern void ata_sff_queue_work(struct work_struct *work);
    1859                 :            : extern void ata_sff_queue_delayed_work(struct delayed_work *dwork,
    1860                 :            :                 unsigned long delay);
    1861                 :            : extern void ata_sff_queue_pio_task(struct ata_link *link, unsigned long delay);
    1862                 :            : extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);
    1863                 :            : extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);
    1864                 :            : extern unsigned int ata_sff_port_intr(struct ata_port *ap,
    1865                 :            :                                       struct ata_queued_cmd *qc);
    1866                 :            : extern irqreturn_t ata_sff_interrupt(int irq, void *dev_instance);
    1867                 :            : extern void ata_sff_lost_interrupt(struct ata_port *ap);
    1868                 :            : extern void ata_sff_freeze(struct ata_port *ap);
    1869                 :            : extern void ata_sff_thaw(struct ata_port *ap);
    1870                 :            : extern int ata_sff_prereset(struct ata_link *link, unsigned long deadline);
    1871                 :            : extern unsigned int ata_sff_dev_classify(struct ata_device *dev, int present,
    1872                 :            :                                           u8 *r_err);
    1873                 :            : extern int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,
    1874                 :            :                                     unsigned long deadline);
    1875                 :            : extern int ata_sff_softreset(struct ata_link *link, unsigned int *classes,
    1876                 :            :                              unsigned long deadline);
    1877                 :            : extern int sata_sff_hardreset(struct ata_link *link, unsigned int *class,
    1878                 :            :                                unsigned long deadline);
    1879                 :            : extern void ata_sff_postreset(struct ata_link *link, unsigned int *classes);
    1880                 :            : extern void ata_sff_drain_fifo(struct ata_queued_cmd *qc);
    1881                 :            : extern void ata_sff_error_handler(struct ata_port *ap);
    1882                 :            : extern void ata_sff_std_ports(struct ata_ioports *ioaddr);
    1883                 :            : #ifdef CONFIG_PCI
    1884                 :            : extern int ata_pci_sff_init_host(struct ata_host *host);
    1885                 :            : extern int ata_pci_sff_prepare_host(struct pci_dev *pdev,
    1886                 :            :                                     const struct ata_port_info * const * ppi,
    1887                 :            :                                     struct ata_host **r_host);
    1888                 :            : extern int ata_pci_sff_activate_host(struct ata_host *host,
    1889                 :            :                                      irq_handler_t irq_handler,
    1890                 :            :                                      struct scsi_host_template *sht);
    1891                 :            : extern int ata_pci_sff_init_one(struct pci_dev *pdev,
    1892                 :            :                 const struct ata_port_info * const * ppi,
    1893                 :            :                 struct scsi_host_template *sht, void *host_priv, int hflags);
    1894                 :            : #endif /* CONFIG_PCI */
    1895                 :            : 
    1896                 :            : #ifdef CONFIG_ATA_BMDMA
    1897                 :            : 
    1898                 :            : extern const struct ata_port_operations ata_bmdma_port_ops;
    1899                 :            : 
    1900                 :            : #define ATA_BMDMA_SHT(drv_name)                                 \
    1901                 :            :         ATA_BASE_SHT(drv_name),                                 \
    1902                 :            :         .sg_tablesize           = LIBATA_MAX_PRD,               \
    1903                 :            :         .dma_boundary           = ATA_DMA_BOUNDARY
    1904                 :            : 
    1905                 :            : extern enum ata_completion_errors ata_bmdma_qc_prep(struct ata_queued_cmd *qc);
    1906                 :            : extern unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc);
    1907                 :            : extern enum ata_completion_errors ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc);
    1908                 :            : extern unsigned int ata_bmdma_port_intr(struct ata_port *ap,
    1909                 :            :                                       struct ata_queued_cmd *qc);
    1910                 :            : extern irqreturn_t ata_bmdma_interrupt(int irq, void *dev_instance);
    1911                 :            : extern void ata_bmdma_error_handler(struct ata_port *ap);
    1912                 :            : extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
    1913                 :            : extern void ata_bmdma_irq_clear(struct ata_port *ap);
    1914                 :            : extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
    1915                 :            : extern void ata_bmdma_start(struct ata_queued_cmd *qc);
    1916                 :            : extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
    1917                 :            : extern u8 ata_bmdma_status(struct ata_port *ap);
    1918                 :            : extern int ata_bmdma_port_start(struct ata_port *ap);
    1919                 :            : extern int ata_bmdma_port_start32(struct ata_port *ap);
    1920                 :            : 
    1921                 :            : #ifdef CONFIG_PCI
    1922                 :            : extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);
    1923                 :            : extern void ata_pci_bmdma_init(struct ata_host *host);
    1924                 :            : extern int ata_pci_bmdma_prepare_host(struct pci_dev *pdev,
    1925                 :            :                                       const struct ata_port_info * const * ppi,
    1926                 :            :                                       struct ata_host **r_host);
    1927                 :            : extern int ata_pci_bmdma_init_one(struct pci_dev *pdev,
    1928                 :            :                                   const struct ata_port_info * const * ppi,
    1929                 :            :                                   struct scsi_host_template *sht,
    1930                 :            :                                   void *host_priv, int hflags);
    1931                 :            : #endif /* CONFIG_PCI */
    1932                 :            : #endif /* CONFIG_ATA_BMDMA */
    1933                 :            : 
    1934                 :            : /**
    1935                 :            :  *      ata_sff_busy_wait - Wait for a port status register
    1936                 :            :  *      @ap: Port to wait for.
    1937                 :            :  *      @bits: bits that must be clear
    1938                 :            :  *      @max: number of 10uS waits to perform
    1939                 :            :  *
    1940                 :            :  *      Waits up to max*10 microseconds for the selected bits in the port's
    1941                 :            :  *      status register to be cleared.
    1942                 :            :  *      Returns final value of status register.
    1943                 :            :  *
    1944                 :            :  *      LOCKING:
    1945                 :            :  *      Inherited from caller.
    1946                 :            :  */
    1947                 :      99534 : static inline u8 ata_sff_busy_wait(struct ata_port *ap, unsigned int bits,
    1948                 :            :                                    unsigned int max)
    1949                 :            : {
    1950                 :      99534 :         u8 status;
    1951                 :            : 
    1952                 :      99534 :         do {
    1953                 :      99534 :                 udelay(10);
    1954                 :      99534 :                 status = ap->ops->sff_check_status(ap);
    1955                 :      99534 :                 max--;
    1956   [ +  -  -  +  :      99534 :         } while (status != 0xff && (status & bits) && (max > 0));
                   -  - ]
    1957                 :            : 
    1958                 :      99534 :         return status;
    1959                 :            : }
    1960                 :            : 
    1961                 :            : /**
    1962                 :            :  *      ata_wait_idle - Wait for a port to be idle.
    1963                 :            :  *      @ap: Port to wait for.
    1964                 :            :  *
    1965                 :            :  *      Waits up to 10ms for port's BUSY and DRQ signals to clear.
    1966                 :            :  *      Returns final value of status register.
    1967                 :            :  *
    1968                 :            :  *      LOCKING:
    1969                 :            :  *      Inherited from caller.
    1970                 :            :  */
    1971                 :      97974 : static inline u8 ata_wait_idle(struct ata_port *ap)
    1972                 :            : {
    1973                 :      32978 :         u8 status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
    1974                 :            : 
    1975                 :            : #ifdef ATA_DEBUG
    1976                 :            :         if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ)))
    1977                 :            :                 ata_port_printk(ap, KERN_DEBUG, "abnormal Status 0x%X\n",
    1978                 :            :                                 status);
    1979                 :            : #endif
    1980                 :            : 
    1981         [ +  - ]:      65626 :         return status;
    1982                 :            : }
    1983                 :            : #endif /* CONFIG_ATA_SFF */
    1984                 :            : 
    1985                 :            : #endif /* __LINUX_LIBATA_H__ */

Generated by: LCOV version 1.14