home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / libata.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  51.3 KB  |  1,613 lines
  1. /*
  2.  *  Copyright 2003-2005 Red Hat, Inc.  All rights reserved.
  3.  *  Copyright 2003-2005 Jeff Garzik
  4.  *
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2, or (at your option)
  9.  *  any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; see the file COPYING.  If not, write to
  18.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  *
  21.  *  libata documentation is available via 'make {ps|pdf}docs',
  22.  *  as Documentation/DocBook/libata.*
  23.  *
  24.  */
  25.  
  26. #ifndef __LINUX_LIBATA_H__
  27. #define __LINUX_LIBATA_H__
  28.  
  29. #include <linux/delay.h>
  30. #include <linux/jiffies.h>
  31. #include <linux/interrupt.h>
  32. #include <linux/dma-mapping.h>
  33. #include <linux/scatterlist.h>
  34. #include <linux/io.h>
  35. #include <linux/ata.h>
  36. #include <linux/workqueue.h>
  37. #include <scsi/scsi_host.h>
  38. #include <linux/acpi.h>
  39. #include <linux/cdrom.h>
  40.  
  41. /*
  42.  * Define if arch has non-standard setup.  This is a _PCI_ standard
  43.  * not a legacy or ISA standard.
  44.  */
  45. #ifdef CONFIG_ATA_NONSTANDARD
  46. #include <asm/libata-portmap.h>
  47. #else
  48. #include <asm-generic/libata-portmap.h>
  49. #endif
  50.  
  51. /*
  52.  * compile-time options: to be removed as soon as all the drivers are
  53.  * converted to the new debugging mechanism
  54.  */
  55. #undef ATA_DEBUG        /* debugging output */
  56. #undef ATA_VERBOSE_DEBUG    /* yet more debugging output */
  57. #undef ATA_IRQ_TRAP        /* define to ack screaming irqs */
  58. #undef ATA_NDEBUG        /* define to disable quick runtime checks */
  59.  
  60.  
  61. /* note: prints function name for you */
  62. #ifdef ATA_DEBUG
  63. #define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
  64. #ifdef ATA_VERBOSE_DEBUG
  65. #define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
  66. #else
  67. #define VPRINTK(fmt, args...)
  68. #endif    /* ATA_VERBOSE_DEBUG */
  69. #else
  70. #define DPRINTK(fmt, args...)
  71. #define VPRINTK(fmt, args...)
  72. #endif    /* ATA_DEBUG */
  73.  
  74. #define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args)
  75.  
  76. /* NEW: debug levels */
  77. #define HAVE_LIBATA_MSG 1
  78.  
  79. enum {
  80.     ATA_MSG_DRV    = 0x0001,
  81.     ATA_MSG_INFO    = 0x0002,
  82.     ATA_MSG_PROBE    = 0x0004,
  83.     ATA_MSG_WARN    = 0x0008,
  84.     ATA_MSG_MALLOC    = 0x0010,
  85.     ATA_MSG_CTL    = 0x0020,
  86.     ATA_MSG_INTR    = 0x0040,
  87.     ATA_MSG_ERR    = 0x0080,
  88. };
  89.  
  90. #define ata_msg_drv(p)    ((p)->msg_enable & ATA_MSG_DRV)
  91. #define ata_msg_info(p)   ((p)->msg_enable & ATA_MSG_INFO)
  92. #define ata_msg_probe(p)  ((p)->msg_enable & ATA_MSG_PROBE)
  93. #define ata_msg_warn(p)   ((p)->msg_enable & ATA_MSG_WARN)
  94. #define ata_msg_malloc(p) ((p)->msg_enable & ATA_MSG_MALLOC)
  95. #define ata_msg_ctl(p)    ((p)->msg_enable & ATA_MSG_CTL)
  96. #define ata_msg_intr(p)   ((p)->msg_enable & ATA_MSG_INTR)
  97. #define ata_msg_err(p)    ((p)->msg_enable & ATA_MSG_ERR)
  98.  
  99. static inline u32 ata_msg_init(int dval, int default_msg_enable_bits)
  100. {
  101.     if (dval < 0 || dval >= (sizeof(u32) * 8))
  102.         return default_msg_enable_bits; /* should be 0x1 - only driver info msgs */
  103.     if (!dval)
  104.         return 0;
  105.     return (1 << dval) - 1;
  106. }
  107.  
  108. /* defines only for the constants which don't work well as enums */
  109. #define ATA_TAG_POISON        0xfafbfcfdU
  110.  
  111. enum {
  112.     /* various global constants */
  113.     LIBATA_MAX_PRD        = ATA_MAX_PRD / 2,
  114.     LIBATA_DUMB_MAX_PRD    = ATA_MAX_PRD / 4,    /* Worst case */
  115.     ATA_DEF_QUEUE        = 1,
  116.     /* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
  117.     ATA_MAX_QUEUE        = 32,
  118.     ATA_TAG_INTERNAL    = ATA_MAX_QUEUE - 1,
  119.     ATA_SHORT_PAUSE        = 16,
  120.  
  121.     ATAPI_MAX_DRAIN        = 16 << 10,
  122.  
  123.     ATA_ALL_DEVICES        = (1 << ATA_MAX_DEVICES) - 1,
  124.  
  125.     ATA_SHT_EMULATED    = 1,
  126.     ATA_SHT_CMD_PER_LUN    = 1,
  127.     ATA_SHT_THIS_ID        = -1,
  128.     ATA_SHT_USE_CLUSTERING    = 1,
  129.  
  130.     /* struct ata_device stuff */
  131.     ATA_DFLAG_LBA        = (1 << 0), /* device supports LBA */
  132.     ATA_DFLAG_LBA48        = (1 << 1), /* device supports LBA48 */
  133.     ATA_DFLAG_CDB_INTR    = (1 << 2), /* device asserts INTRQ when ready for CDB */
  134.     ATA_DFLAG_NCQ        = (1 << 3), /* device supports NCQ */
  135.     ATA_DFLAG_FLUSH_EXT    = (1 << 4), /* do FLUSH_EXT instead of FLUSH */
  136.     ATA_DFLAG_ACPI_PENDING    = (1 << 5), /* ACPI resume action pending */
  137.     ATA_DFLAG_ACPI_FAILED    = (1 << 6), /* ACPI on devcfg has failed */
  138.     ATA_DFLAG_AN        = (1 << 7), /* AN configured */
  139.     ATA_DFLAG_HIPM        = (1 << 8), /* device supports HIPM */
  140.     ATA_DFLAG_DIPM        = (1 << 9), /* device supports DIPM */
  141.     ATA_DFLAG_DMADIR    = (1 << 10), /* device requires DMADIR */
  142.     ATA_DFLAG_CFG_MASK    = (1 << 12) - 1,
  143.  
  144.     ATA_DFLAG_PIO        = (1 << 12), /* device limited to PIO mode */
  145.     ATA_DFLAG_NCQ_OFF    = (1 << 13), /* device limited to non-NCQ mode */
  146.     ATA_DFLAG_SPUNDOWN    = (1 << 14), /* XXX: for spindown_compat */
  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_INIT_MASK    = (1 << 24) - 1,
  151.  
  152.     ATA_DFLAG_DETACH    = (1 << 24),
  153.     ATA_DFLAG_DETACHED    = (1 << 25),
  154.  
  155.     ATA_DEV_UNKNOWN        = 0,    /* unknown device */
  156.     ATA_DEV_ATA        = 1,    /* ATA device */
  157.     ATA_DEV_ATA_UNSUP    = 2,    /* ATA device (unsupported) */
  158.     ATA_DEV_ATAPI        = 3,    /* ATAPI device */
  159.     ATA_DEV_ATAPI_UNSUP    = 4,    /* ATAPI device (unsupported) */
  160.     ATA_DEV_PMP        = 5,    /* SATA port multiplier */
  161.     ATA_DEV_PMP_UNSUP    = 6,    /* SATA port multiplier (unsupported) */
  162.     ATA_DEV_SEMB        = 7,    /* SEMB */
  163.     ATA_DEV_SEMB_UNSUP    = 8,    /* SEMB (unsupported) */
  164.     ATA_DEV_NONE        = 9,    /* no device */
  165.  
  166.     /* struct ata_link flags */
  167.     ATA_LFLAG_NO_HRST    = (1 << 1), /* avoid hardreset */
  168.     ATA_LFLAG_NO_SRST    = (1 << 2), /* avoid softreset */
  169.     ATA_LFLAG_ASSUME_ATA    = (1 << 3), /* assume ATA class */
  170.     ATA_LFLAG_ASSUME_SEMB    = (1 << 4), /* assume SEMB class */
  171.     ATA_LFLAG_ASSUME_CLASS    = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
  172.     ATA_LFLAG_NO_RETRY    = (1 << 5), /* don't retry this link */
  173.     ATA_LFLAG_DISABLED    = (1 << 6), /* link is disabled */
  174.     ATA_LFLAG_SW_ACTIVITY    = (1 << 7), /* keep activity stats */
  175.  
  176.     /* struct ata_port flags */
  177.     ATA_FLAG_SLAVE_POSS    = (1 << 0), /* host supports slave dev */
  178.                         /* (doesn't imply presence) */
  179.     ATA_FLAG_SATA        = (1 << 1),
  180.     ATA_FLAG_NO_LEGACY    = (1 << 2), /* no legacy mode check */
  181.     ATA_FLAG_MMIO        = (1 << 3), /* use MMIO, not PIO */
  182.     ATA_FLAG_SRST        = (1 << 4), /* (obsolete) use ATA SRST, not E.D.D. */
  183.     ATA_FLAG_SATA_RESET    = (1 << 5), /* (obsolete) use COMRESET */
  184.     ATA_FLAG_NO_ATAPI    = (1 << 6), /* No ATAPI support */
  185.     ATA_FLAG_PIO_DMA    = (1 << 7), /* PIO cmds via DMA */
  186.     ATA_FLAG_PIO_LBA48    = (1 << 8), /* Host DMA engine is LBA28 only */
  187.     ATA_FLAG_PIO_POLLING    = (1 << 9), /* use polling PIO if LLD
  188.                          * doesn't handle PIO interrupts */
  189.     ATA_FLAG_NCQ        = (1 << 10), /* host supports NCQ */
  190.     ATA_FLAG_DEBUGMSG    = (1 << 13),
  191.     ATA_FLAG_IGN_SIMPLEX    = (1 << 15), /* ignore SIMPLEX */
  192.     ATA_FLAG_NO_IORDY    = (1 << 16), /* controller lacks iordy */
  193.     ATA_FLAG_ACPI_SATA    = (1 << 17), /* need native SATA ACPI layout */
  194.     ATA_FLAG_AN        = (1 << 18), /* controller supports AN */
  195.     ATA_FLAG_PMP        = (1 << 19), /* controller supports PMP */
  196.     ATA_FLAG_IPM        = (1 << 20), /* driver can handle IPM */
  197.     ATA_FLAG_EM        = (1 << 21), /* driver supports enclosure
  198.                           * management */
  199.     ATA_FLAG_SW_ACTIVITY    = (1 << 22), /* driver supports sw activity
  200.                           * led */
  201.  
  202.     /* The following flag belongs to ap->pflags but is kept in
  203.      * ap->flags because it's referenced in many LLDs and will be
  204.      * removed in not-too-distant future.
  205.      */
  206.     ATA_FLAG_DISABLED    = (1 << 23), /* port is disabled, ignore it */
  207.  
  208.     /* bits 24:31 of ap->flags are reserved for LLD specific flags */
  209.  
  210.     /* struct ata_port pflags */
  211.     ATA_PFLAG_EH_PENDING    = (1 << 0), /* EH pending */
  212.     ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
  213.     ATA_PFLAG_FROZEN    = (1 << 2), /* port is frozen */
  214.     ATA_PFLAG_RECOVERED    = (1 << 3), /* recovery action performed */
  215.     ATA_PFLAG_LOADING    = (1 << 4), /* boot/loading probe */
  216.     ATA_PFLAG_UNLOADING    = (1 << 5), /* module is unloading */
  217.     ATA_PFLAG_SCSI_HOTPLUG    = (1 << 6), /* SCSI hotplug scheduled */
  218.     ATA_PFLAG_INITIALIZING    = (1 << 7), /* being initialized, don't touch */
  219.     ATA_PFLAG_RESETTING    = (1 << 8), /* reset in progress */
  220.  
  221.     ATA_PFLAG_SUSPENDED    = (1 << 17), /* port is suspended (power) */
  222.     ATA_PFLAG_PM_PENDING    = (1 << 18), /* PM operation pending */
  223.     ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */
  224.  
  225.     /* struct ata_queued_cmd flags */
  226.     ATA_QCFLAG_ACTIVE    = (1 << 0), /* cmd not yet ack'd to scsi lyer */
  227.     ATA_QCFLAG_DMAMAP    = (1 << 1), /* SG table is DMA mapped */
  228.     ATA_QCFLAG_IO        = (1 << 3), /* standard IO command */
  229.     ATA_QCFLAG_RESULT_TF    = (1 << 4), /* result TF requested */
  230.     ATA_QCFLAG_CLEAR_EXCL    = (1 << 5), /* clear excl_link on completion */
  231.     ATA_QCFLAG_QUIET    = (1 << 6), /* don't report device error */
  232.     ATA_QCFLAG_RETRY    = (1 << 7), /* retry after failure */
  233.  
  234.     ATA_QCFLAG_FAILED    = (1 << 16), /* cmd failed and is owned by EH */
  235.     ATA_QCFLAG_SENSE_VALID    = (1 << 17), /* sense data valid */
  236.     ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */
  237.  
  238.     /* host set flags */
  239.     ATA_HOST_SIMPLEX    = (1 << 0),    /* Host is simplex, one DMA channel per host only */
  240.     ATA_HOST_STARTED    = (1 << 1),    /* Host started */
  241.  
  242.     /* bits 24:31 of host->flags are reserved for LLD specific flags */
  243.  
  244.     /* various lengths of time */
  245.     ATA_TMOUT_BOOT        = 30000,    /* heuristic */
  246.     ATA_TMOUT_BOOT_QUICK    =  7000,    /* heuristic */
  247.     ATA_TMOUT_INTERNAL_QUICK = 5000,
  248.     ATA_TMOUT_MAX_PARK    = 30000,
  249.  
  250.     /* FIXME: GoVault needs 2s but we can't afford that without
  251.      * parallel probing.  800ms is enough for iVDR disk
  252.      * HHD424020F7SV00.  Increase to 2secs when parallel probing
  253.      * is in place.
  254.      */
  255.     ATA_TMOUT_FF_WAIT    =  800,
  256.  
  257.     /* Spec mandates to wait for ">= 2ms" before checking status
  258.      * after reset.  We wait 150ms, because that was the magic
  259.      * delay used for ATAPI devices in Hale Landis's ATADRVR, for
  260.      * the period of time between when the ATA command register is
  261.      * written, and then status is checked.  Because waiting for
  262.      * "a while" before checking status is fine, post SRST, we
  263.      * perform this magic delay here as well.
  264.      *
  265.      * Old drivers/ide uses the 2mS rule and then waits for ready.
  266.      */
  267.     ATA_WAIT_AFTER_RESET    =  150,
  268.  
  269.     /* If PMP is supported, we have to do follow-up SRST.  As some
  270.      * PMPs don't send D2H Reg FIS after hardreset, LLDs are
  271.      * advised to wait only for the following duration before
  272.      * doing SRST.
  273.      */
  274.     ATA_TMOUT_PMP_SRST_WAIT    = 5000,
  275.  
  276.     /* ATA bus states */
  277.     BUS_UNKNOWN        = 0,
  278.     BUS_DMA            = 1,
  279.     BUS_IDLE        = 2,
  280.     BUS_NOINTR        = 3,
  281.     BUS_NODATA        = 4,
  282.     BUS_TIMER        = 5,
  283.     BUS_PIO            = 6,
  284.     BUS_EDD            = 7,
  285.     BUS_IDENTIFY        = 8,
  286.     BUS_PACKET        = 9,
  287.  
  288.     /* SATA port states */
  289.     PORT_UNKNOWN        = 0,
  290.     PORT_ENABLED        = 1,
  291.     PORT_DISABLED        = 2,
  292.  
  293.     /* encoding various smaller bitmaps into a single
  294.      * unsigned long bitmap
  295.      */
  296.     ATA_NR_PIO_MODES    = 7,
  297.     ATA_NR_MWDMA_MODES    = 5,
  298.     ATA_NR_UDMA_MODES    = 8,
  299.  
  300.     ATA_SHIFT_PIO        = 0,
  301.     ATA_SHIFT_MWDMA        = ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
  302.     ATA_SHIFT_UDMA        = ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,
  303.  
  304.     /* size of buffer to pad xfers ending on unaligned boundaries */
  305.     ATA_DMA_PAD_SZ        = 4,
  306.  
  307.     /* ering size */
  308.     ATA_ERING_SIZE        = 32,
  309.  
  310.     /* return values for ->qc_defer */
  311.     ATA_DEFER_LINK        = 1,
  312.     ATA_DEFER_PORT        = 2,
  313.  
  314.     /* desc_len for ata_eh_info and context */
  315.     ATA_EH_DESC_LEN        = 80,
  316.  
  317.     /* reset / recovery action types */
  318.     ATA_EH_REVALIDATE    = (1 << 0),
  319.     ATA_EH_SOFTRESET    = (1 << 1), /* meaningful only in ->prereset */
  320.     ATA_EH_HARDRESET    = (1 << 2), /* meaningful only in ->prereset */
  321.     ATA_EH_RESET        = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
  322.     ATA_EH_ENABLE_LINK    = (1 << 3),
  323.     ATA_EH_LPM        = (1 << 4),  /* link power management action */
  324.     ATA_EH_PARK        = (1 << 5), /* unload heads and stop I/O */
  325.  
  326.     ATA_EH_PERDEV_MASK    = ATA_EH_REVALIDATE | ATA_EH_PARK,
  327.     ATA_EH_ALL_ACTIONS    = ATA_EH_REVALIDATE | ATA_EH_RESET |
  328.                   ATA_EH_ENABLE_LINK | ATA_EH_LPM,
  329.  
  330.     /* ata_eh_info->flags */
  331.     ATA_EHI_HOTPLUGGED    = (1 << 0),  /* could have been hotplugged */
  332.     ATA_EHI_NO_AUTOPSY    = (1 << 2),  /* no autopsy */
  333.     ATA_EHI_QUIET        = (1 << 3),  /* be quiet */
  334.  
  335.     ATA_EHI_DID_SOFTRESET    = (1 << 16), /* already soft-reset this port */
  336.     ATA_EHI_DID_HARDRESET    = (1 << 17), /* already soft-reset this port */
  337.     ATA_EHI_PRINTINFO    = (1 << 18), /* print configuration info */
  338.     ATA_EHI_SETMODE        = (1 << 19), /* configure transfer mode */
  339.     ATA_EHI_POST_SETMODE    = (1 << 20), /* revaildating after setmode */
  340.  
  341.     ATA_EHI_DID_RESET    = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
  342.  
  343.     /* mask of flags to transfer *to* the slave link */
  344.     ATA_EHI_TO_SLAVE_MASK    = ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET,
  345.  
  346.     /* max tries if error condition is still set after ->error_handler */
  347.     ATA_EH_MAX_TRIES    = 5,
  348.  
  349.     /* how hard are we gonna try to probe/recover devices */
  350.     ATA_PROBE_MAX_TRIES    = 3,
  351.     ATA_EH_DEV_TRIES    = 3,
  352.     ATA_EH_PMP_TRIES    = 5,
  353.     ATA_EH_PMP_LINK_TRIES    = 3,
  354.  
  355.     SATA_PMP_RW_TIMEOUT    = 3000,        /* PMP read/write timeout */
  356.  
  357.     /* This should match the actual table size of
  358.      * ata_eh_cmd_timeout_table in libata-eh.c.
  359.      */
  360.     ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 5,
  361.  
  362.     /* Horkage types. May be set by libata or controller on drives
  363.        (some horkage may be drive/controller pair dependant */
  364.  
  365.     ATA_HORKAGE_DIAGNOSTIC    = (1 << 0),    /* Failed boot diag */
  366.     ATA_HORKAGE_NODMA    = (1 << 1),    /* DMA problems */
  367.     ATA_HORKAGE_NONCQ    = (1 << 2),    /* Don't use NCQ */
  368.     ATA_HORKAGE_MAX_SEC_128    = (1 << 3),    /* Limit max sects to 128 */
  369.     ATA_HORKAGE_BROKEN_HPA    = (1 << 4),    /* Broken HPA */
  370.     ATA_HORKAGE_DISABLE    = (1 << 5),    /* Disable it */
  371.     ATA_HORKAGE_HPA_SIZE    = (1 << 6),    /* native size off by one */
  372.     ATA_HORKAGE_IPM        = (1 << 7),    /* Link PM problems */
  373.     ATA_HORKAGE_IVB        = (1 << 8),    /* cbl det validity bit bugs */
  374.     ATA_HORKAGE_STUCK_ERR    = (1 << 9),    /* stuck ERR on next PACKET */
  375.     ATA_HORKAGE_BRIDGE_OK    = (1 << 10),    /* no bridge limits */
  376.     ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands
  377.                             not multiple of 16 bytes */
  378.     ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),    /* firwmare update warning */
  379.  
  380.      /* DMA mask for user DMA control: User visible values; DO NOT
  381.         renumber */
  382.     ATA_DMA_MASK_ATA    = (1 << 0),    /* DMA on ATA Disk */
  383.     ATA_DMA_MASK_ATAPI    = (1 << 1),    /* DMA on ATAPI */
  384.     ATA_DMA_MASK_CFA    = (1 << 2),    /* DMA on CF Card */
  385.  
  386.     /* ATAPI command types */
  387.     ATAPI_READ        = 0,        /* READs */
  388.     ATAPI_WRITE        = 1,        /* WRITEs */
  389.     ATAPI_READ_CD        = 2,        /* READ CD [MSF] */
  390.     ATAPI_PASS_THRU        = 3,        /* SAT pass-thru */
  391.     ATAPI_MISC        = 4,        /* the rest */
  392.  
  393.     /* Timing constants */
  394.     ATA_TIMING_SETUP    = (1 << 0),
  395.     ATA_TIMING_ACT8B    = (1 << 1),
  396.     ATA_TIMING_REC8B    = (1 << 2),
  397.     ATA_TIMING_CYC8B    = (1 << 3),
  398.     ATA_TIMING_8BIT        = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
  399.                   ATA_TIMING_CYC8B,
  400.     ATA_TIMING_ACTIVE    = (1 << 4),
  401.     ATA_TIMING_RECOVER    = (1 << 5),
  402.     ATA_TIMING_CYCLE    = (1 << 6),
  403.     ATA_TIMING_UDMA        = (1 << 7),
  404.     ATA_TIMING_ALL        = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
  405.                   ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
  406.                   ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
  407.                   ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
  408. };
  409.  
  410. enum ata_xfer_mask {
  411.     ATA_MASK_PIO        = ((1LU << ATA_NR_PIO_MODES) - 1)
  412.                     << ATA_SHIFT_PIO,
  413.     ATA_MASK_MWDMA        = ((1LU << ATA_NR_MWDMA_MODES) - 1)
  414.                     << ATA_SHIFT_MWDMA,
  415.     ATA_MASK_UDMA        = ((1LU << ATA_NR_UDMA_MODES) - 1)
  416.                     << ATA_SHIFT_UDMA,
  417. };
  418.  
  419. enum hsm_task_states {
  420.     HSM_ST_IDLE,        /* no command on going */
  421.     HSM_ST_FIRST,        /* (waiting the device to)
  422.                    write CDB or first data block */
  423.     HSM_ST,            /* (waiting the device to) transfer data */
  424.     HSM_ST_LAST,        /* (waiting the device to) complete command */
  425.     HSM_ST_ERR,        /* error */
  426. };
  427.  
  428. enum ata_completion_errors {
  429.     AC_ERR_DEV        = (1 << 0), /* device reported error */
  430.     AC_ERR_HSM        = (1 << 1), /* host state machine violation */
  431.     AC_ERR_TIMEOUT        = (1 << 2), /* timeout */
  432.     AC_ERR_MEDIA        = (1 << 3), /* media error */
  433.     AC_ERR_ATA_BUS        = (1 << 4), /* ATA bus error */
  434.     AC_ERR_HOST_BUS        = (1 << 5), /* host bus error */
  435.     AC_ERR_SYSTEM        = (1 << 6), /* system error */
  436.     AC_ERR_INVALID        = (1 << 7), /* invalid argument */
  437.     AC_ERR_OTHER        = (1 << 8), /* unknown */
  438.     AC_ERR_NODEV_HINT    = (1 << 9), /* polling device detection hint */
  439.     AC_ERR_NCQ        = (1 << 10), /* marker for offending NCQ qc */
  440. };
  441.  
  442. /* forward declarations */
  443. struct scsi_device;
  444. struct ata_port_operations;
  445. struct ata_port;
  446. struct ata_link;
  447. struct ata_queued_cmd;
  448.  
  449. /* typedefs */
  450. typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
  451. typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);
  452. typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes,
  453.                   unsigned long deadline);
  454. typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
  455.  
  456. /*
  457.  * host pm policy: If you alter this, you also need to alter libata-scsi.c
  458.  * (for the ascii descriptions)
  459.  */
  460. enum link_pm {
  461.     NOT_AVAILABLE,
  462.     MIN_POWER,
  463.     MAX_PERFORMANCE,
  464.     MEDIUM_POWER,
  465. };
  466. extern struct device_attribute dev_attr_link_power_management_policy;
  467. extern struct device_attribute dev_attr_unload_heads;
  468. extern struct device_attribute dev_attr_em_message_type;
  469. extern struct device_attribute dev_attr_em_message;
  470. extern struct device_attribute dev_attr_sw_activity;
  471.  
  472. enum sw_activity {
  473.     OFF,
  474.     BLINK_ON,
  475.     BLINK_OFF,
  476. };
  477.  
  478. #ifdef CONFIG_ATA_SFF
  479. struct ata_ioports {
  480.     void __iomem        *cmd_addr;
  481.     void __iomem        *data_addr;
  482.     void __iomem        *error_addr;
  483.     void __iomem        *feature_addr;
  484.     void __iomem        *nsect_addr;
  485.     void __iomem        *lbal_addr;
  486.     void __iomem        *lbam_addr;
  487.     void __iomem        *lbah_addr;
  488.     void __iomem        *device_addr;
  489.     void __iomem        *status_addr;
  490.     void __iomem        *command_addr;
  491.     void __iomem        *altstatus_addr;
  492.     void __iomem        *ctl_addr;
  493.     void __iomem        *bmdma_addr;
  494.     void __iomem        *scr_addr;
  495. };
  496. #endif /* CONFIG_ATA_SFF */
  497.  
  498. struct ata_host {
  499.     spinlock_t        lock;
  500.     struct device         *dev;
  501.     void __iomem * const    *iomap;
  502.     unsigned int        n_ports;
  503.     void            *private_data;
  504.     struct ata_port_operations *ops;
  505.     unsigned long        flags;
  506. #ifdef CONFIG_ATA_ACPI
  507.     acpi_handle        acpi_handle;
  508. #endif
  509.     struct ata_port        *simplex_claimed;    /* channel owning the DMA */
  510.     struct ata_port        *ports[0];
  511. };
  512.  
  513. struct ata_queued_cmd {
  514.     struct ata_port        *ap;
  515.     struct ata_device    *dev;
  516.  
  517.     struct scsi_cmnd    *scsicmd;
  518.     void            (*scsidone)(struct scsi_cmnd *);
  519.  
  520.     struct ata_taskfile    tf;
  521.     u8            cdb[ATAPI_CDB_LEN];
  522.  
  523.     unsigned long        flags;        /* ATA_QCFLAG_xxx */
  524.     unsigned int        tag;
  525.     unsigned int        n_elem;
  526.  
  527.     int            dma_dir;
  528.  
  529.     unsigned int        sect_size;
  530.  
  531.     unsigned int        nbytes;
  532.     unsigned int        extrabytes;
  533.     unsigned int        curbytes;
  534.  
  535.     struct scatterlist    *cursg;
  536.     unsigned int        cursg_ofs;
  537.  
  538.     struct scatterlist    sgent;
  539.  
  540.     struct scatterlist    *sg;
  541.  
  542.     unsigned int        err_mask;
  543.     struct ata_taskfile    result_tf;
  544.     ata_qc_cb_t        complete_fn;
  545.  
  546.     void            *private_data;
  547.     void            *lldd_task;
  548. };
  549.  
  550. struct ata_port_stats {
  551.     unsigned long        unhandled_irq;
  552.     unsigned long        idle_irq;
  553.     unsigned long        rw_reqbuf;
  554. };
  555.  
  556. struct ata_ering_entry {
  557.     unsigned int        eflags;
  558.     unsigned int        err_mask;
  559.     u64            timestamp;
  560. };
  561.  
  562. struct ata_ering {
  563.     int            cursor;
  564.     struct ata_ering_entry    ring[ATA_ERING_SIZE];
  565. };
  566.  
  567. struct ata_device {
  568.     struct ata_link        *link;
  569.     unsigned int        devno;        /* 0 or 1 */
  570.     unsigned int        horkage;    /* List of broken features */
  571.     unsigned long        flags;        /* ATA_DFLAG_xxx */
  572.     struct scsi_device    *sdev;        /* attached SCSI device */
  573. #ifdef CONFIG_ATA_ACPI
  574.     acpi_handle        acpi_handle;
  575.     union acpi_object    *gtf_cache;
  576. #endif
  577.     /* n_sector is used as CLEAR_OFFSET, read comment above CLEAR_OFFSET */
  578.     u64            n_sectors;    /* size of device, if ATA */
  579.     unsigned int        class;        /* ATA_DEV_xxx */
  580.     unsigned long        unpark_deadline;
  581.  
  582.     u8            pio_mode;
  583.     u8            dma_mode;
  584.     u8            xfer_mode;
  585.     unsigned int        xfer_shift;    /* ATA_SHIFT_xxx */
  586.  
  587.     unsigned int        multi_count;    /* sectors count for
  588.                            READ/WRITE MULTIPLE */
  589.     unsigned int        max_sectors;    /* per-device max sectors */
  590.     unsigned int        cdb_len;
  591.  
  592.     /* per-dev xfer mask */
  593.     unsigned long        pio_mask;
  594.     unsigned long        mwdma_mask;
  595.     unsigned long        udma_mask;
  596.  
  597.     /* for CHS addressing */
  598.     u16            cylinders;    /* Number of cylinders */
  599.     u16            heads;        /* Number of heads */
  600.     u16            sectors;    /* Number of sectors per track */
  601.  
  602.     /* error history */
  603.     int            spdn_cnt;
  604.     struct ata_ering    ering;
  605.  
  606.     union {
  607.         u16        id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
  608.         u32        gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
  609.     };
  610. };
  611.  
  612. /* Offset into struct ata_device.  Fields above it are maintained
  613.  * acress device init.  Fields below are zeroed.
  614.  */
  615. #define ATA_DEVICE_CLEAR_OFFSET        offsetof(struct ata_device, n_sectors)
  616.  
  617. struct ata_eh_info {
  618.     struct ata_device    *dev;        /* offending device */
  619.     u32            serror;        /* SError from LLDD */
  620.     unsigned int        err_mask;    /* port-wide err_mask */
  621.     unsigned int        action;        /* ATA_EH_* action mask */
  622.     unsigned int        dev_action[ATA_MAX_DEVICES]; /* dev EH action */
  623.     unsigned int        flags;        /* ATA_EHI_* flags */
  624.  
  625.     unsigned int        probe_mask;
  626.  
  627.     char            desc[ATA_EH_DESC_LEN];
  628.     int            desc_len;
  629. };
  630.  
  631. struct ata_eh_context {
  632.     struct ata_eh_info    i;
  633.     int            tries[ATA_MAX_DEVICES];
  634.     int            cmd_timeout_idx[ATA_MAX_DEVICES]
  635.                            [ATA_EH_CMD_TIMEOUT_TABLE_SIZE];
  636.     unsigned int        classes[ATA_MAX_DEVICES];
  637.     unsigned int        did_probe_mask;
  638.     unsigned int        unloaded_mask;
  639.     unsigned int        saved_ncq_enabled;
  640.     u8            saved_xfer_mode[ATA_MAX_DEVICES];
  641.     /* timestamp for the last reset attempt or success */
  642.     unsigned long        last_reset;
  643. };
  644.  
  645. struct ata_acpi_drive
  646. {
  647.     u32 pio;
  648.     u32 dma;
  649. } __packed;
  650.  
  651. struct ata_acpi_gtm {
  652.     struct ata_acpi_drive drive[2];
  653.     u32 flags;
  654. } __packed;
  655.  
  656. struct ata_link {
  657.     struct ata_port        *ap;
  658.     int            pmp;        /* port multiplier port # */
  659.  
  660.     unsigned int        active_tag;    /* active tag on this link */
  661.     u32            sactive;    /* active NCQ commands */
  662.  
  663.     unsigned int        flags;        /* ATA_LFLAG_xxx */
  664.  
  665.     u32            saved_scontrol;    /* SControl on probe */
  666.     unsigned int        hw_sata_spd_limit;
  667.     unsigned int        sata_spd_limit;
  668.     unsigned int        sata_spd;    /* current SATA PHY speed */
  669.  
  670.     /* record runtime error info, protected by host_set lock */
  671.     struct ata_eh_info    eh_info;
  672.     /* EH context */
  673.     struct ata_eh_context    eh_context;
  674.  
  675.     struct ata_device    device[ATA_MAX_DEVICES];
  676. };
  677.  
  678. struct ata_port {
  679.     struct Scsi_Host    *scsi_host; /* our co-allocated scsi host */
  680.     struct ata_port_operations *ops;
  681.     spinlock_t        *lock;
  682.     unsigned long        flags;    /* ATA_FLAG_xxx */
  683.     unsigned int        pflags; /* ATA_PFLAG_xxx */
  684.     unsigned int        print_id; /* user visible unique port ID */
  685.     unsigned int        port_no; /* 0 based port no. inside the host */
  686.  
  687.     struct ata_prd        *prd;     /* our SG list */
  688.     dma_addr_t        prd_dma; /* and its DMA mapping */
  689.  
  690. #ifdef CONFIG_ATA_SFF
  691.     struct ata_ioports    ioaddr;    /* ATA cmd/ctl/dma register blocks */
  692. #endif /* CONFIG_ATA_SFF */
  693.  
  694.     u8            ctl;    /* cache of ATA control register */
  695.     u8            last_ctl;    /* Cache last written value */
  696.     unsigned int        pio_mask;
  697.     unsigned int        mwdma_mask;
  698.     unsigned int        udma_mask;
  699.     unsigned int        cbl;    /* cable type; ATA_CBL_xxx */
  700.  
  701.     struct ata_queued_cmd    qcmd[ATA_MAX_QUEUE];
  702.     unsigned long        qc_allocated;
  703.     unsigned int        qc_active;
  704.     int            nr_active_links; /* #links with active qcs */
  705.  
  706.     struct ata_link        link;        /* host default link */
  707.     struct ata_link        *slave_link;    /* see ata_slave_link_init() */
  708.  
  709.     int            nr_pmp_links;    /* nr of available PMP links */
  710.     struct ata_link        *pmp_link;    /* array of PMP links */
  711.     struct ata_link        *excl_link;    /* for PMP qc exclusion */
  712.  
  713.     struct ata_port_stats    stats;
  714.     struct ata_host        *host;
  715.     struct device         *dev;
  716.  
  717.     void            *port_task_data;
  718.     struct delayed_work    port_task;
  719.     struct delayed_work    hotplug_task;
  720.     struct work_struct    scsi_rescan_task;
  721.  
  722.     unsigned int        hsm_task_state;
  723.  
  724.     u32            msg_enable;
  725.     struct list_head    eh_done_q;
  726.     wait_queue_head_t    eh_wait_q;
  727.     int            eh_tries;
  728.     struct completion    park_req_pending;
  729.  
  730.     pm_message_t        pm_mesg;
  731.     int            *pm_result;
  732.     enum link_pm        pm_policy;
  733.  
  734.     struct timer_list    fastdrain_timer;
  735.     unsigned long        fastdrain_cnt;
  736.  
  737.     int            em_message_type;
  738.     void            *private_data;
  739.  
  740. #ifdef CONFIG_ATA_ACPI
  741.     acpi_handle        acpi_handle;
  742.     struct ata_acpi_gtm    __acpi_init_gtm; /* use ata_acpi_init_gtm() */
  743. #endif
  744.     u8            sector_buf[ATA_SECT_SIZE]; /* owned by EH */
  745. };
  746.  
  747. /* The following initializer overrides a method to NULL whether one of
  748.  * its parent has the method defined or not.  This is equivalent to
  749.  * ERR_PTR(-ENOENT).  Unfortunately, ERR_PTR doesn't render a constant
  750.  * expression and thus can't be used as an initializer.
  751.  */
  752. #define ATA_OP_NULL        (void *)(unsigned long)(-ENOENT)
  753.  
  754. struct ata_port_operations {
  755.     /*
  756.      * Command execution
  757.      */
  758.     int  (*qc_defer)(struct ata_queued_cmd *qc);
  759.     int  (*check_atapi_dma)(struct ata_queued_cmd *qc);
  760.     void (*qc_prep)(struct ata_queued_cmd *qc);
  761.     unsigned int (*qc_issue)(struct ata_queued_cmd *qc);
  762.     bool (*qc_fill_rtf)(struct ata_queued_cmd *qc);
  763.  
  764.     /*
  765.      * Configuration and exception handling
  766.      */
  767.     int  (*cable_detect)(struct ata_port *ap);
  768.     unsigned long (*mode_filter)(struct ata_device *dev, unsigned long xfer_mask);
  769.     void (*set_piomode)(struct ata_port *ap, struct ata_device *dev);
  770.     void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev);
  771.     int  (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev);
  772.     unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, u16 *id);
  773.  
  774.     void (*dev_config)(struct ata_device *dev);
  775.  
  776.     void (*freeze)(struct ata_port *ap);
  777.     void (*thaw)(struct ata_port *ap);
  778.     ata_prereset_fn_t    prereset;
  779.     ata_reset_fn_t        softreset;
  780.     ata_reset_fn_t        hardreset;
  781.     ata_postreset_fn_t    postreset;
  782.     ata_prereset_fn_t    pmp_prereset;
  783.     ata_reset_fn_t        pmp_softreset;
  784.     ata_reset_fn_t        pmp_hardreset;
  785.     ata_postreset_fn_t    pmp_postreset;
  786.     void (*error_handler)(struct ata_port *ap);
  787.     void (*post_internal_cmd)(struct ata_queued_cmd *qc);
  788.  
  789.     /*
  790.      * Optional features
  791.      */
  792.     int  (*scr_read)(struct ata_link *link, unsigned int sc_reg, u32 *val);
  793.     int  (*scr_write)(struct ata_link *link, unsigned int sc_reg, u32 val);
  794.     void (*pmp_attach)(struct ata_port *ap);
  795.     void (*pmp_detach)(struct ata_port *ap);
  796.     int  (*enable_pm)(struct ata_port *ap, enum link_pm policy);
  797.     void (*disable_pm)(struct ata_port *ap);
  798.  
  799.     /*
  800.      * Start, stop, suspend and resume
  801.      */
  802.     int  (*port_suspend)(struct ata_port *ap, pm_message_t mesg);
  803.     int  (*port_resume)(struct ata_port *ap);
  804.     int  (*port_start)(struct ata_port *ap);
  805.     void (*port_stop)(struct ata_port *ap);
  806.     void (*host_stop)(struct ata_host *host);
  807.  
  808. #ifdef CONFIG_ATA_SFF
  809.     /*
  810.      * SFF / taskfile oriented ops
  811.      */
  812.     void (*sff_dev_select)(struct ata_port *ap, unsigned int device);
  813.     u8   (*sff_check_status)(struct ata_port *ap);
  814.     u8   (*sff_check_altstatus)(struct ata_port *ap);
  815.     void (*sff_tf_load)(struct ata_port *ap, const struct ata_taskfile *tf);
  816.     void (*sff_tf_read)(struct ata_port *ap, struct ata_taskfile *tf);
  817.     void (*sff_exec_command)(struct ata_port *ap,
  818.                  const struct ata_taskfile *tf);
  819.     unsigned int (*sff_data_xfer)(struct ata_device *dev,
  820.             unsigned char *buf, unsigned int buflen, int rw);
  821.     u8   (*sff_irq_on)(struct ata_port *);
  822.     void (*sff_irq_clear)(struct ata_port *);
  823.  
  824.     void (*bmdma_setup)(struct ata_queued_cmd *qc);
  825.     void (*bmdma_start)(struct ata_queued_cmd *qc);
  826.     void (*bmdma_stop)(struct ata_queued_cmd *qc);
  827.     u8   (*bmdma_status)(struct ata_port *ap);
  828. #endif /* CONFIG_ATA_SFF */
  829.  
  830.     ssize_t (*em_show)(struct ata_port *ap, char *buf);
  831.     ssize_t (*em_store)(struct ata_port *ap, const char *message,
  832.                 size_t size);
  833.     ssize_t (*sw_activity_show)(struct ata_device *dev, char *buf);
  834.     ssize_t (*sw_activity_store)(struct ata_device *dev,
  835.                      enum sw_activity val);
  836.     /*
  837.      * Obsolete
  838.      */
  839.     void (*phy_reset)(struct ata_port *ap);
  840.     void (*eng_timeout)(struct ata_port *ap);
  841.  
  842.     /*
  843.      * ->inherits must be the last field and all the preceding
  844.      * fields must be pointers.
  845.      */
  846.     const struct ata_port_operations    *inherits;
  847. };
  848.  
  849. struct ata_port_info {
  850.     unsigned long        flags;
  851.     unsigned long        link_flags;
  852.     unsigned long        pio_mask;
  853.     unsigned long        mwdma_mask;
  854.     unsigned long        udma_mask;
  855.     struct ata_port_operations *port_ops;
  856.     void             *private_data;
  857. };
  858.  
  859. struct ata_timing {
  860.     unsigned short mode;        /* ATA mode */
  861.     unsigned short setup;        /* t1 */
  862.     unsigned short act8b;        /* t2 for 8-bit I/O */
  863.     unsigned short rec8b;        /* t2i for 8-bit I/O */
  864.     unsigned short cyc8b;        /* t0 for 8-bit I/O */
  865.     unsigned short active;        /* t2 or tD */
  866.     unsigned short recover;        /* t2i or tK */
  867.     unsigned short cycle;        /* t0 */
  868.     unsigned short udma;        /* t2CYCTYP/2 */
  869. };
  870.  
  871. /*
  872.  * Core layer - drivers/ata/libata-core.c
  873.  */
  874. extern const unsigned long sata_deb_timing_normal[];
  875. extern const unsigned long sata_deb_timing_hotplug[];
  876. extern const unsigned long sata_deb_timing_long[];
  877.  
  878. extern struct ata_port_operations ata_dummy_port_ops;
  879. extern const struct ata_port_info ata_dummy_port_info;
  880.  
  881. static inline const unsigned long *
  882. sata_ehc_deb_timing(struct ata_eh_context *ehc)
  883. {
  884.     if (ehc->i.flags & ATA_EHI_HOTPLUGGED)
  885.         return sata_deb_timing_hotplug;
  886.     else
  887.         return sata_deb_timing_normal;
  888. }
  889.  
  890. static inline int ata_port_is_dummy(struct ata_port *ap)
  891. {
  892.     return ap->ops == &ata_dummy_port_ops;
  893. }
  894.  
  895. extern void ata_port_probe(struct ata_port *);
  896. extern int sata_set_spd(struct ata_link *link);
  897. extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
  898. extern int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
  899.                 int (*check_ready)(struct ata_link *link));
  900. extern int sata_link_debounce(struct ata_link *link,
  901.             const unsigned long *params, unsigned long deadline);
  902. extern int sata_link_resume(struct ata_link *link, const unsigned long *params,
  903.                 unsigned long deadline);
  904. extern int sata_link_hardreset(struct ata_link *link,
  905.             const unsigned long *timing, unsigned long deadline,
  906.             bool *online, int (*check_ready)(struct ata_link *));
  907. extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
  908.                   unsigned long deadline);
  909. extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
  910. extern void ata_port_disable(struct ata_port *);
  911.  
  912. extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
  913. extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
  914.             const struct ata_port_info * const * ppi, int n_ports);
  915. extern int ata_slave_link_init(struct ata_port *ap);
  916. extern int ata_host_start(struct ata_host *host);
  917. extern int ata_host_register(struct ata_host *host,
  918.                  struct scsi_host_template *sht);
  919. extern int ata_host_activate(struct ata_host *host, int irq,
  920.                  irq_handler_t irq_handler, unsigned long irq_flags,
  921.                  struct scsi_host_template *sht);
  922. extern void ata_host_detach(struct ata_host *host);
  923. extern void ata_host_init(struct ata_host *, struct device *,
  924.               unsigned long, struct ata_port_operations *);
  925. extern int ata_scsi_detect(struct scsi_host_template *sht);
  926. extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
  927. extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
  928. extern void ata_sas_port_destroy(struct ata_port *);
  929. extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
  930.                        struct ata_port_info *, struct Scsi_Host *);
  931. extern int ata_sas_port_init(struct ata_port *);
  932. extern int ata_sas_port_start(struct ata_port *ap);
  933. extern void ata_sas_port_stop(struct ata_port *ap);
  934. extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *);
  935. extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
  936.                 struct ata_port *ap);
  937. extern int sata_scr_valid(struct ata_link *link);
  938. extern int sata_scr_read(struct ata_link *link, int reg, u32 *val);
  939. extern int sata_scr_write(struct ata_link *link, int reg, u32 val);
  940. extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val);
  941. extern bool ata_link_online(struct ata_link *link);
  942. extern bool ata_link_offline(struct ata_link *link);
  943. #ifdef CONFIG_PM
  944. extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
  945. extern void ata_host_resume(struct ata_host *host);
  946. #endif
  947. extern int ata_ratelimit(void);
  948. extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
  949.                  unsigned long interval, unsigned long timeout);
  950. extern int atapi_cmd_type(u8 opcode);
  951. extern void ata_tf_to_fis(const struct ata_taskfile *tf,
  952.               u8 pmp, int is_cmd, u8 *fis);
  953. extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
  954. extern unsigned long ata_pack_xfermask(unsigned long pio_mask,
  955.             unsigned long mwdma_mask, unsigned long udma_mask);
  956. extern void ata_unpack_xfermask(unsigned long xfer_mask,
  957.             unsigned long *pio_mask, unsigned long *mwdma_mask,
  958.             unsigned long *udma_mask);
  959. extern u8 ata_xfer_mask2mode(unsigned long xfer_mask);
  960. extern unsigned long ata_xfer_mode2mask(u8 xfer_mode);
  961. extern int ata_xfer_mode2shift(unsigned long xfer_mode);
  962. extern const char *ata_mode_string(unsigned long xfer_mask);
  963. extern unsigned long ata_id_xfermask(const u16 *id);
  964. extern int ata_port_start(struct ata_port *ap);
  965. extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
  966. extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
  967. extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
  968.          unsigned int n_elem);
  969. extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
  970. extern void ata_dev_disable(struct ata_device *adev);
  971. extern void ata_id_string(const u16 *id, unsigned char *s,
  972.               unsigned int ofs, unsigned int len);
  973. extern void ata_id_c_string(const u16 *id, unsigned char *s,
  974.                 unsigned int ofs, unsigned int len);
  975. extern unsigned int ata_do_dev_read_id(struct ata_device *dev,
  976.                     struct ata_taskfile *tf, u16 *id);
  977. extern void ata_qc_complete(struct ata_queued_cmd *qc);
  978. extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active);
  979. extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
  980.                   void (*done)(struct scsi_cmnd *));
  981. extern int ata_std_bios_param(struct scsi_device *sdev,
  982.                   struct block_device *bdev,
  983.                   sector_t capacity, int geom[]);
  984. extern int ata_scsi_slave_config(struct scsi_device *sdev);
  985. extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
  986. extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
  987.                        int queue_depth);
  988. extern struct ata_device *ata_dev_pair(struct ata_device *adev);
  989. extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
  990.  
  991. extern int ata_cable_40wire(struct ata_port *ap);
  992. extern int ata_cable_80wire(struct ata_port *ap);
  993. extern int ata_cable_sata(struct ata_port *ap);
  994. extern int ata_cable_ignore(struct ata_port *ap);
  995. extern int ata_cable_unknown(struct ata_port *ap);
  996.  
  997. /* Timing helpers */
  998. extern unsigned int ata_pio_need_iordy(const struct ata_device *);
  999. extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);
  1000. extern int ata_timing_compute(struct ata_device *, unsigned short,
  1001.                   struct ata_timing *, int, int);
  1002. extern void ata_timing_merge(const struct ata_timing *,
  1003.                  const struct ata_timing *, struct ata_timing *,
  1004.                  unsigned int);
  1005. extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle);
  1006.  
  1007. /* PCI */
  1008. #ifdef CONFIG_PCI
  1009. struct pci_dev;
  1010.  
  1011. struct pci_bits {
  1012.     unsigned int        reg;    /* PCI config register to read */
  1013.     unsigned int        width;    /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
  1014.     unsigned long        mask;
  1015.     unsigned long        val;
  1016. };
  1017.  
  1018. extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
  1019. extern void ata_pci_remove_one(struct pci_dev *pdev);
  1020.  
  1021. #ifdef CONFIG_PM
  1022. extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
  1023. extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
  1024. extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
  1025. extern int ata_pci_device_resume(struct pci_dev *pdev);
  1026. #endif /* CONFIG_PM */
  1027. #endif /* CONFIG_PCI */
  1028.  
  1029. /*
  1030.  * ACPI - drivers/ata/libata-acpi.c
  1031.  */
  1032. #ifdef CONFIG_ATA_ACPI
  1033. static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
  1034. {
  1035.     if (ap->pflags & ATA_PFLAG_INIT_GTM_VALID)
  1036.         return &ap->__acpi_init_gtm;
  1037.     return NULL;
  1038. }
  1039. int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm);
  1040. int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm);
  1041. unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
  1042.                     const struct ata_acpi_gtm *gtm);
  1043. int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm);
  1044. #else
  1045. static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
  1046. {
  1047.     return NULL;
  1048. }
  1049.  
  1050. static inline int ata_acpi_stm(const struct ata_port *ap,
  1051.                    struct ata_acpi_gtm *stm)
  1052. {
  1053.     return -ENOSYS;
  1054. }
  1055.  
  1056. static inline int ata_acpi_gtm(const struct ata_port *ap,
  1057.                    struct ata_acpi_gtm *stm)
  1058. {
  1059.     return -ENOSYS;
  1060. }
  1061.  
  1062. static inline unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev,
  1063.                     const struct ata_acpi_gtm *gtm)
  1064. {
  1065.     return 0;
  1066. }
  1067.  
  1068. static inline int ata_acpi_cbl_80wire(struct ata_port *ap,
  1069.                       const struct ata_acpi_gtm *gtm)
  1070. {
  1071.     return 0;
  1072. }
  1073. #endif
  1074.  
  1075. /*
  1076.  * EH - drivers/ata/libata-eh.c
  1077.  */
  1078. extern void ata_port_schedule_eh(struct ata_port *ap);
  1079. extern int ata_link_abort(struct ata_link *link);
  1080. extern int ata_port_abort(struct ata_port *ap);
  1081. extern int ata_port_freeze(struct ata_port *ap);
  1082. extern int sata_async_notification(struct ata_port *ap);
  1083.  
  1084. extern void ata_eh_freeze_port(struct ata_port *ap);
  1085. extern void ata_eh_thaw_port(struct ata_port *ap);
  1086.  
  1087. extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
  1088. extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
  1089. extern void ata_eh_analyze_ncq_error(struct ata_link *link);
  1090.  
  1091. extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
  1092.               ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
  1093.               ata_postreset_fn_t postreset);
  1094. extern void ata_std_error_handler(struct ata_port *ap);
  1095.  
  1096. /*
  1097.  * Base operations to inherit from and initializers for sht
  1098.  *
  1099.  * Operations
  1100.  *
  1101.  * base  : Common to all libata drivers.
  1102.  * sata  : SATA controllers w/ native interface.
  1103.  * pmp   : SATA controllers w/ PMP support.
  1104.  * sff   : SFF ATA controllers w/o BMDMA support.
  1105.  * bmdma : SFF ATA controllers w/ BMDMA support.
  1106.  *
  1107.  * sht initializers
  1108.  *
  1109.  * BASE  : Common to all libata drivers.  The user must set
  1110.  *       sg_tablesize and dma_boundary.
  1111.  * PIO   : SFF ATA controllers w/ only PIO support.
  1112.  * BMDMA : SFF ATA controllers w/ BMDMA support.  sg_tablesize and
  1113.  *       dma_boundary are set to BMDMA limits.
  1114.  * NCQ   : SATA controllers supporting NCQ.  The user must set
  1115.  *       sg_tablesize, dma_boundary and can_queue.
  1116.  */
  1117. extern const struct ata_port_operations ata_base_port_ops;
  1118. extern const struct ata_port_operations sata_port_ops;
  1119. extern struct device_attribute *ata_common_sdev_attrs[];
  1120.  
  1121. #define ATA_BASE_SHT(drv_name)                    \
  1122.     .module            = THIS_MODULE,            \
  1123.     .name            = drv_name,            \
  1124.     .ioctl            = ata_scsi_ioctl,        \
  1125.     .queuecommand        = ata_scsi_queuecmd,        \
  1126.     .can_queue        = ATA_DEF_QUEUE,        \
  1127.     .this_id        = ATA_SHT_THIS_ID,        \
  1128.     .cmd_per_lun        = ATA_SHT_CMD_PER_LUN,        \
  1129.     .emulated        = ATA_SHT_EMULATED,        \
  1130.     .use_clustering        = ATA_SHT_USE_CLUSTERING,    \
  1131.     .proc_name        = drv_name,            \
  1132.     .slave_configure    = ata_scsi_slave_config,    \
  1133.     .slave_destroy        = ata_scsi_slave_destroy,    \
  1134.     .bios_param        = ata_std_bios_param,        \
  1135.     .sdev_attrs        = ata_common_sdev_attrs
  1136.  
  1137. #define ATA_NCQ_SHT(drv_name)                    \
  1138.     ATA_BASE_SHT(drv_name),                    \
  1139.     .change_queue_depth    = ata_scsi_change_queue_depth
  1140.  
  1141. /*
  1142.  * PMP helpers
  1143.  */
  1144. #ifdef CONFIG_SATA_PMP
  1145. static inline bool sata_pmp_supported(struct ata_port *ap)
  1146. {
  1147.     return ap->flags & ATA_FLAG_PMP;
  1148. }
  1149.  
  1150. static inline bool sata_pmp_attached(struct ata_port *ap)
  1151. {
  1152.     return ap->nr_pmp_links != 0;
  1153. }
  1154.  
  1155. static inline int ata_is_host_link(const struct ata_link *link)
  1156. {
  1157.     return link == &link->ap->link || link == link->ap->slave_link;
  1158. }
  1159. #else /* CONFIG_SATA_PMP */
  1160. static inline bool sata_pmp_supported(struct ata_port *ap)
  1161. {
  1162.     return false;
  1163. }
  1164.  
  1165. static inline bool sata_pmp_attached(struct ata_port *ap)
  1166. {
  1167.     return false;
  1168. }
  1169.  
  1170. static inline int ata_is_host_link(const struct ata_link *link)
  1171. {
  1172.     return 1;
  1173. }
  1174. #endif /* CONFIG_SATA_PMP */
  1175.  
  1176. static inline int sata_srst_pmp(struct ata_link *link)
  1177. {
  1178.     if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
  1179.         return SATA_PMP_CTRL_PORT;
  1180.     return link->pmp;
  1181. }
  1182.  
  1183. /*
  1184.  * printk helpers
  1185.  */
  1186. #define ata_port_printk(ap, lv, fmt, args...) \
  1187.     printk("%sata%u: "fmt, lv, (ap)->print_id , ##args)
  1188.  
  1189. #define ata_link_printk(link, lv, fmt, args...) do { \
  1190.     if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link)    \
  1191.         printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id,    \
  1192.                (link)->pmp , ##args); \
  1193.     else \
  1194.         printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
  1195.     } while(0)
  1196.  
  1197. #define ata_dev_printk(dev, lv, fmt, args...) \
  1198.     printk("%sata%u.%02u: "fmt, lv, (dev)->link->ap->print_id,    \
  1199.            (dev)->link->pmp + (dev)->devno , ##args)
  1200.  
  1201. /*
  1202.  * ata_eh_info helpers
  1203.  */
  1204. extern void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
  1205.     __attribute__ ((format (printf, 2, 3)));
  1206. extern void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
  1207.     __attribute__ ((format (printf, 2, 3)));
  1208. extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
  1209.  
  1210. static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
  1211. {
  1212.     ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
  1213.     ehi->flags |= ATA_EHI_HOTPLUGGED;
  1214.     ehi->action |= ATA_EH_RESET | ATA_EH_ENABLE_LINK;
  1215.     ehi->err_mask |= AC_ERR_ATA_BUS;
  1216. }
  1217.  
  1218. /*
  1219.  * port description helpers
  1220.  */
  1221. extern void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
  1222.     __attribute__ ((format (printf, 2, 3)));
  1223. #ifdef CONFIG_PCI
  1224. extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
  1225.                    const char *name);
  1226. #endif
  1227.  
  1228. static inline unsigned int ata_tag_valid(unsigned int tag)
  1229. {
  1230.     return (tag < ATA_MAX_QUEUE) ? 1 : 0;
  1231. }
  1232.  
  1233. static inline unsigned int ata_tag_internal(unsigned int tag)
  1234. {
  1235.     return tag == ATA_TAG_INTERNAL;
  1236. }
  1237.  
  1238. /*
  1239.  * device helpers
  1240.  */
  1241. static inline unsigned int ata_class_enabled(unsigned int class)
  1242. {
  1243.     return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI ||
  1244.         class == ATA_DEV_PMP || class == ATA_DEV_SEMB;
  1245. }
  1246.  
  1247. static inline unsigned int ata_class_disabled(unsigned int class)
  1248. {
  1249.     return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP ||
  1250.         class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP;
  1251. }
  1252.  
  1253. static inline unsigned int ata_class_absent(unsigned int class)
  1254. {
  1255.     return !ata_class_enabled(class) && !ata_class_disabled(class);
  1256. }
  1257.  
  1258. static inline unsigned int ata_dev_enabled(const struct ata_device *dev)
  1259. {
  1260.     return ata_class_enabled(dev->class);
  1261. }
  1262.  
  1263. static inline unsigned int ata_dev_disabled(const struct ata_device *dev)
  1264. {
  1265.     return ata_class_disabled(dev->class);
  1266. }
  1267.  
  1268. static inline unsigned int ata_dev_absent(const struct ata_device *dev)
  1269. {
  1270.     return ata_class_absent(dev->class);
  1271. }
  1272.  
  1273. /*
  1274.  * link helpers
  1275.  */
  1276. static inline int ata_link_max_devices(const struct ata_link *link)
  1277. {
  1278.     if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS)
  1279.         return 2;
  1280.     return 1;
  1281. }
  1282.  
  1283. static inline int ata_link_active(struct ata_link *link)
  1284. {
  1285.     return ata_tag_valid(link->active_tag) || link->sactive;
  1286. }
  1287.  
  1288. extern struct ata_link *__ata_port_next_link(struct ata_port *ap,
  1289.                          struct ata_link *link,
  1290.                          bool dev_only);
  1291.  
  1292. #define __ata_port_for_each_link(link, ap) \
  1293.     for ((link) = __ata_port_next_link((ap), NULL, false); (link); \
  1294.          (link) = __ata_port_next_link((ap), (link), false))
  1295.  
  1296. #define ata_port_for_each_link(link, ap) \
  1297.     for ((link) = __ata_port_next_link((ap), NULL, true); (link); \
  1298.          (link) = __ata_port_next_link((ap), (link), true))
  1299.  
  1300. #define ata_link_for_each_dev(dev, link) \
  1301.     for ((dev) = (link)->device; \
  1302.          (dev) < (link)->device + ata_link_max_devices(link) || ((dev) = NULL); \
  1303.          (dev)++)
  1304.  
  1305. #define ata_link_for_each_dev_reverse(dev, link) \
  1306.     for ((dev) = (link)->device + ata_link_max_devices(link) - 1; \
  1307.          (dev) >= (link)->device || ((dev) = NULL); (dev)--)
  1308.  
  1309. /**
  1310.  *    ata_ncq_enabled - Test whether NCQ is enabled
  1311.  *    @dev: ATA device to test for
  1312.  *
  1313.  *    LOCKING:
  1314.  *    spin_lock_irqsave(host lock)
  1315.  *
  1316.  *    RETURNS:
  1317.  *    1 if NCQ is enabled for @dev, 0 otherwise.
  1318.  */
  1319. static inline int ata_ncq_enabled(struct ata_device *dev)
  1320. {
  1321.     return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
  1322.                   ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ;
  1323. }
  1324.  
  1325. static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
  1326. {
  1327.     qc->tf.ctl |= ATA_NIEN;
  1328. }
  1329.  
  1330. static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
  1331.                                unsigned int tag)
  1332. {
  1333.     if (likely(ata_tag_valid(tag)))
  1334.         return &ap->qcmd[tag];
  1335.     return NULL;
  1336. }
  1337.  
  1338. static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap,
  1339.                              unsigned int tag)
  1340. {
  1341.     struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
  1342.  
  1343.     if (unlikely(!qc) || !ap->ops->error_handler)
  1344.         return qc;
  1345.  
  1346.     if ((qc->flags & (ATA_QCFLAG_ACTIVE |
  1347.               ATA_QCFLAG_FAILED)) == ATA_QCFLAG_ACTIVE)
  1348.         return qc;
  1349.  
  1350.     return NULL;
  1351. }
  1352.  
  1353. static inline unsigned int ata_qc_raw_nbytes(struct ata_queued_cmd *qc)
  1354. {
  1355.     return qc->nbytes - min(qc->extrabytes, qc->nbytes);
  1356. }
  1357.  
  1358. static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
  1359. {
  1360.     memset(tf, 0, sizeof(*tf));
  1361.  
  1362.     tf->ctl = dev->link->ap->ctl;
  1363.     if (dev->devno == 0)
  1364.         tf->device = ATA_DEVICE_OBS;
  1365.     else
  1366.         tf->device = ATA_DEVICE_OBS | ATA_DEV1;
  1367. }
  1368.  
  1369. static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
  1370. {
  1371.     qc->dma_dir = DMA_NONE;
  1372.     qc->sg = NULL;
  1373.     qc->flags = 0;
  1374.     qc->cursg = NULL;
  1375.     qc->cursg_ofs = 0;
  1376.     qc->nbytes = qc->extrabytes = qc->curbytes = 0;
  1377.     qc->n_elem = 0;
  1378.     qc->err_mask = 0;
  1379.     qc->sect_size = ATA_SECT_SIZE;
  1380.  
  1381.     ata_tf_init(qc->dev, &qc->tf);
  1382.  
  1383.     /* init result_tf such that it indicates normal completion */
  1384.     qc->result_tf.command = ATA_DRDY;
  1385.     qc->result_tf.feature = 0;
  1386. }
  1387.  
  1388. static inline int ata_try_flush_cache(const struct ata_device *dev)
  1389. {
  1390.     return ata_id_wcache_enabled(dev->id) ||
  1391.            ata_id_has_flush(dev->id) ||
  1392.            ata_id_has_flush_ext(dev->id);
  1393. }
  1394.  
  1395. static inline unsigned int ac_err_mask(u8 status)
  1396. {
  1397.     if (status & (ATA_BUSY | ATA_DRQ))
  1398.         return AC_ERR_HSM;
  1399.     if (status & (ATA_ERR | ATA_DF))
  1400.         return AC_ERR_DEV;
  1401.     return 0;
  1402. }
  1403.  
  1404. static inline unsigned int __ac_err_mask(u8 status)
  1405. {
  1406.     unsigned int mask = ac_err_mask(status);
  1407.     if (mask == 0)
  1408.         return AC_ERR_OTHER;
  1409.     return mask;
  1410. }
  1411.  
  1412. static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host)
  1413. {
  1414.     return *(struct ata_port **)&host->hostdata[0];
  1415. }
  1416.  
  1417. static inline int ata_check_ready(u8 status)
  1418. {
  1419.     if (!(status & ATA_BUSY))
  1420.         return 1;
  1421.  
  1422.     /* 0xff indicates either no device or device not ready */
  1423.     if (status == 0xff)
  1424.         return -ENODEV;
  1425.  
  1426.     return 0;
  1427. }
  1428.  
  1429. static inline unsigned long ata_deadline(unsigned long from_jiffies,
  1430.                      unsigned long timeout_msecs)
  1431. {
  1432.     return from_jiffies + msecs_to_jiffies(timeout_msecs);
  1433. }
  1434.  
  1435. /* Don't open code these in drivers as there are traps. Firstly the range may
  1436.    change in future hardware and specs, secondly 0xFF means 'no DMA' but is
  1437.    > UDMA_0. Dyma ddreigiau */
  1438.  
  1439. static inline int ata_using_mwdma(struct ata_device *adev)
  1440. {
  1441.     if (adev->dma_mode >= XFER_MW_DMA_0 && adev->dma_mode <= XFER_MW_DMA_4)
  1442.         return 1;
  1443.     return 0;
  1444. }
  1445.  
  1446. static inline int ata_using_udma(struct ata_device *adev)
  1447. {
  1448.     if (adev->dma_mode >= XFER_UDMA_0 && adev->dma_mode <= XFER_UDMA_7)
  1449.         return 1;
  1450.     return 0;
  1451. }
  1452.  
  1453. static inline int ata_dma_enabled(struct ata_device *adev)
  1454. {
  1455.     return (adev->dma_mode == 0xFF ? 0 : 1);
  1456. }
  1457.  
  1458. /**************************************************************************
  1459.  * PMP - drivers/ata/libata-pmp.c
  1460.  */
  1461. #ifdef CONFIG_SATA_PMP
  1462.  
  1463. extern const struct ata_port_operations sata_pmp_port_ops;
  1464.  
  1465. extern int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc);
  1466. extern void sata_pmp_error_handler(struct ata_port *ap);
  1467.  
  1468. #else /* CONFIG_SATA_PMP */
  1469.  
  1470. #define sata_pmp_port_ops        sata_port_ops
  1471. #define sata_pmp_qc_defer_cmd_switch    ata_std_qc_defer
  1472. #define sata_pmp_error_handler        ata_std_error_handler
  1473.  
  1474. #endif /* CONFIG_SATA_PMP */
  1475.  
  1476.  
  1477. /**************************************************************************
  1478.  * SFF - drivers/ata/libata-sff.c
  1479.  */
  1480. #ifdef CONFIG_ATA_SFF
  1481.  
  1482. extern const struct ata_port_operations ata_sff_port_ops;
  1483. extern const struct ata_port_operations ata_bmdma_port_ops;
  1484.  
  1485. /* PIO only, sg_tablesize and dma_boundary limits can be removed */
  1486. #define ATA_PIO_SHT(drv_name)                    \
  1487.     ATA_BASE_SHT(drv_name),                    \
  1488.     .sg_tablesize        = LIBATA_MAX_PRD,        \
  1489.     .dma_boundary        = ATA_DMA_BOUNDARY
  1490.  
  1491. #define ATA_BMDMA_SHT(drv_name)                    \
  1492.     ATA_BASE_SHT(drv_name),                    \
  1493.     .sg_tablesize        = LIBATA_MAX_PRD,        \
  1494.     .dma_boundary        = ATA_DMA_BOUNDARY
  1495.  
  1496. extern void ata_sff_qc_prep(struct ata_queued_cmd *qc);
  1497. extern void ata_sff_dumb_qc_prep(struct ata_queued_cmd *qc);
  1498. extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device);
  1499. extern u8 ata_sff_check_status(struct ata_port *ap);
  1500. extern void ata_sff_pause(struct ata_port *ap);
  1501. extern void ata_sff_dma_pause(struct ata_port *ap);
  1502. extern int ata_sff_busy_sleep(struct ata_port *ap,
  1503.                   unsigned long timeout_pat, unsigned long timeout);
  1504. extern int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline);
  1505. extern void ata_sff_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
  1506. extern void ata_sff_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
  1507. extern void ata_sff_exec_command(struct ata_port *ap,
  1508.                  const struct ata_taskfile *tf);
  1509. extern unsigned int ata_sff_data_xfer(struct ata_device *dev,
  1510.             unsigned char *buf, unsigned int buflen, int rw);
  1511. extern unsigned int ata_sff_data_xfer_noirq(struct ata_device *dev,
  1512.             unsigned char *buf, unsigned int buflen, int rw);
  1513. extern u8 ata_sff_irq_on(struct ata_port *ap);
  1514. extern void ata_sff_irq_clear(struct ata_port *ap);
  1515. extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
  1516.                 u8 status, int in_wq);
  1517. extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);
  1518. extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);
  1519. extern unsigned int ata_sff_host_intr(struct ata_port *ap,
  1520.                       struct ata_queued_cmd *qc);
  1521. extern irqreturn_t ata_sff_interrupt(int irq, void *dev_instance);
  1522. extern void ata_sff_freeze(struct ata_port *ap);
  1523. extern void ata_sff_thaw(struct ata_port *ap);
  1524. extern int ata_sff_prereset(struct ata_link *link, unsigned long deadline);
  1525. extern unsigned int ata_sff_dev_classify(struct ata_device *dev, int present,
  1526.                       u8 *r_err);
  1527. extern int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,
  1528.                     unsigned long deadline);
  1529. extern int ata_sff_softreset(struct ata_link *link, unsigned int *classes,
  1530.                  unsigned long deadline);
  1531. extern int sata_sff_hardreset(struct ata_link *link, unsigned int *class,
  1532.                    unsigned long deadline);
  1533. extern void ata_sff_postreset(struct ata_link *link, unsigned int *classes);
  1534. extern void ata_sff_error_handler(struct ata_port *ap);
  1535. extern void ata_sff_post_internal_cmd(struct ata_queued_cmd *qc);
  1536. extern int ata_sff_port_start(struct ata_port *ap);
  1537. extern void ata_sff_std_ports(struct ata_ioports *ioaddr);
  1538. extern unsigned long ata_bmdma_mode_filter(struct ata_device *dev,
  1539.                        unsigned long xfer_mask);
  1540. extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
  1541. extern void ata_bmdma_start(struct ata_queued_cmd *qc);
  1542. extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
  1543. extern u8 ata_bmdma_status(struct ata_port *ap);
  1544. extern void ata_bus_reset(struct ata_port *ap);
  1545.  
  1546. #ifdef CONFIG_PCI
  1547. extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);
  1548. extern int ata_pci_bmdma_init(struct ata_host *host);
  1549. extern int ata_pci_sff_init_host(struct ata_host *host);
  1550. extern int ata_pci_sff_prepare_host(struct pci_dev *pdev,
  1551.                     const struct ata_port_info * const * ppi,
  1552.                     struct ata_host **r_host);
  1553. extern int ata_pci_sff_activate_host(struct ata_host *host,
  1554.                      irq_handler_t irq_handler,
  1555.                      struct scsi_host_template *sht);
  1556. extern int ata_pci_sff_init_one(struct pci_dev *pdev,
  1557.                 const struct ata_port_info * const * ppi,
  1558.                 struct scsi_host_template *sht, void *host_priv);
  1559. #endif /* CONFIG_PCI */
  1560.  
  1561. /**
  1562.  *    ata_sff_busy_wait - Wait for a port status register
  1563.  *    @ap: Port to wait for.
  1564.  *    @bits: bits that must be clear
  1565.  *    @max: number of 10uS waits to perform
  1566.  *
  1567.  *    Waits up to max*10 microseconds for the selected bits in the port's
  1568.  *    status register to be cleared.
  1569.  *    Returns final value of status register.
  1570.  *
  1571.  *    LOCKING:
  1572.  *    Inherited from caller.
  1573.  */
  1574. static inline u8 ata_sff_busy_wait(struct ata_port *ap, unsigned int bits,
  1575.                    unsigned int max)
  1576. {
  1577.     u8 status;
  1578.  
  1579.     do {
  1580.         udelay(10);
  1581.         status = ap->ops->sff_check_status(ap);
  1582.         max--;
  1583.     } while (status != 0xff && (status & bits) && (max > 0));
  1584.  
  1585.     return status;
  1586. }
  1587.  
  1588. /**
  1589.  *    ata_wait_idle - Wait for a port to be idle.
  1590.  *    @ap: Port to wait for.
  1591.  *
  1592.  *    Waits up to 10ms for port's BUSY and DRQ signals to clear.
  1593.  *    Returns final value of status register.
  1594.  *
  1595.  *    LOCKING:
  1596.  *    Inherited from caller.
  1597.  */
  1598. static inline u8 ata_wait_idle(struct ata_port *ap)
  1599. {
  1600.     u8 status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
  1601.  
  1602. #ifdef ATA_DEBUG
  1603.     if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ)))
  1604.         ata_port_printk(ap, KERN_DEBUG, "abnormal Status 0x%X\n",
  1605.                 status);
  1606. #endif
  1607.  
  1608.     return status;
  1609. }
  1610. #endif /* CONFIG_ATA_SFF */
  1611.  
  1612. #endif /* __LINUX_LIBATA_H__ */
  1613.