Merge branch 'upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzik/libata-dev

* 'upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzik/libata-dev: (119 commits)
  [libata] struct pci_dev related cleanups
  libata: use ata_exec_internal() for PMP register access
  libata: implement ATA_PFLAG_RESETTING
  libata: add @timeout to ata_exec_internal[_sg]()
  ahci: fix notification handling
  ahci: clean up PORT_IRQ_BAD_PMP enabling
  ahci: kill leftover from enabling NCQ over PMP
  libata: wrap schedule_timeout_uninterruptible() in loop
  libata: skip suppress reporting if ATA_EHI_QUIET
  libata: clear ehi description after initial host report
  pata_jmicron: match vendor and class code only
  libata: add ST9160821AS / 3.ALD to NCQ blacklist
  pata_acpi: ACPI driver support
  libata-core: Expose gtm methods for driver use
  libata: add HDT722516DLA380 to NCQ blacklist
  libata: blacklist NCQ on Seagate Barracuda ST380817AS
  [libata] Turn on ACPI by default
  libata_scsi: Fix ATAPI transfer lengths
  libata: correct handling of SRST reset sequences
  libata: Integrate ACPI-based PATA/SATA hotplug - version 5
  ...

3 files changed, 338 insertions, 103 deletions

diff --git a/include/asm-generic/libata-portmap.h b/include/asm-generic/libata-portmap.h
index 62fb3618293d..cf14f2ff40b6 100644
--- a/include/asm-generic/libata-portmap.h
+++ b/include/asm-generic/libata-portmap.h
@@ -1,12 +1,7 @@
 #ifndef __ASM_GENERIC_LIBATA_PORTMAP_H
 #define __ASM_GENERIC_LIBATA_PORTMAP_H
 
-#define ATA_PRIMARY_CMD         0x1F0
-#define ATA_PRIMARY_CTL         0x3F6
 #define ATA_PRIMARY_IRQ(dev)    14
-
-#define ATA_SECONDARY_CMD       0x170
-#define ATA_SECONDARY_CTL       0x376
 #define ATA_SECONDARY_IRQ(dev)  15
 
 #endif
diff --git a/include/linux/ata.h b/include/linux/ata.h
index c043c1ccf1c5..a4f373f8b798 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -230,6 +230,12 @@ enum {
 
         SETFEATURES_SPINUP      = 0x07, /* Spin-up drive */
 
+        SETFEATURES_SATA_ENABLE = 0x10, /* Enable use of SATA feature */
+        SETFEATURES_SATA_DISABLE = 0x90, /* Disable use of SATA feature */
+
+        /* SETFEATURE Sector counts for SATA features */
+        SATA_AN                 = 0x05,  /* Asynchronous Notification */
+
         /* ATAPI stuff */
         ATAPI_PKT_DMA           = (1 << 0),
         ATAPI_DMADIR            = (1 << 2),     /* ATAPI data dir:
@@ -281,6 +287,15 @@ enum {
         SERR_PROTOCOL           = (1 << 10), /* protocol violation */
         SERR_INTERNAL           = (1 << 11), /* host internal error */
         SERR_PHYRDY_CHG         = (1 << 16), /* PHY RDY changed */
+        SERR_PHY_INT_ERR        = (1 << 17), /* PHY internal error */
+        SERR_COMM_WAKE          = (1 << 18), /* Comm wake */
+        SERR_10B_8B_ERR         = (1 << 19), /* 10b to 8b decode error */
+        SERR_DISPARITY          = (1 << 20), /* Disparity */
+        SERR_CRC                = (1 << 21), /* CRC error */
+        SERR_HANDSHAKE          = (1 << 22), /* Handshake error */
+        SERR_LINK_SEQ_ERR       = (1 << 23), /* Link sequence error */
+        SERR_TRANS_ST_ERROR     = (1 << 24), /* Transport state trans. error */
+        SERR_UNRECOG_FIS        = (1 << 25), /* Unrecognized FIS */
         SERR_DEV_XCHG           = (1 << 26), /* device exchanged */
 
         /* struct ata_taskfile flags */
@@ -341,24 +356,17 @@ struct ata_taskfile {
 };
 
 #define ata_id_is_ata(id)       (((id)[0] & (1 << 15)) == 0)
-#define ata_id_rahead_enabled(id) ((id)[85] & (1 << 6))
-#define ata_id_wcache_enabled(id) ((id)[85] & (1 << 5))
-#define ata_id_hpa_enabled(id)  ((id)[85] & (1 << 10))
-#define ata_id_has_fua(id)      ((id)[84] & (1 << 6))
-#define ata_id_has_flush(id)    ((id)[83] & (1 << 12))
-#define ata_id_has_flush_ext(id) ((id)[83] & (1 << 13))
-#define ata_id_has_lba48(id)    ((id)[83] & (1 << 10))
-#define ata_id_has_hpa(id)      ((id)[82] & (1 << 10))
-#define ata_id_has_wcache(id)   ((id)[82] & (1 << 5))
-#define ata_id_has_pm(id)       ((id)[82] & (1 << 3))
 #define ata_id_has_lba(id)      ((id)[49] & (1 << 9))
 #define ata_id_has_dma(id)      ((id)[49] & (1 << 8))
 #define ata_id_has_ncq(id)      ((id)[76] & (1 << 8))
 #define ata_id_queue_depth(id)  (((id)[75] & 0x1f) + 1)
 #define ata_id_removeable(id)   ((id)[0] & (1 << 7))
-#define ata_id_has_dword_io(id) ((id)[50] & (1 << 0))
+#define ata_id_has_dword_io(id) ((id)[48] & (1 << 0))
+#define ata_id_has_atapi_AN(id) \
+        ( (((id)[76] != 0x0000) && ((id)[76] != 0xffff)) && \
+          ((id)[78] & (1 << 5)) )
 #define ata_id_iordy_disable(id) ((id)[49] & (1 << 10))
-#define ata_id_has_iordy(id) ((id)[49] & (1 << 9))
+#define ata_id_has_iordy(id) ((id)[49] & (1 << 11))
 #define ata_id_u32(id,n)        \
         (((u32) (id)[(n) + 1] << 16) | ((u32) (id)[(n)]))
 #define ata_id_u64(id,n)        \
@@ -369,6 +377,90 @@ struct ata_taskfile {
 
 #define ata_id_cdb_intr(id)     (((id)[0] & 0x60) == 0x20)
 
+static inline int ata_id_has_fua(const u16 *id)
+{
+        if ((id[84] & 0xC000) != 0x4000)
+                return 0;
+        return id[84] & (1 << 6);
+}
+
+static inline int ata_id_has_flush(const u16 *id)
+{
+        if ((id[83] & 0xC000) != 0x4000)
+                return 0;
+        return id[83] & (1 << 12);
+}
+
+static inline int ata_id_has_flush_ext(const u16 *id)
+{
+        if ((id[83] & 0xC000) != 0x4000)
+                return 0;
+        return id[83] & (1 << 13);
+}
+
+static inline int ata_id_has_lba48(const u16 *id)
+{
+        if ((id[83] & 0xC000) != 0x4000)
+                return 0;
+        return id[83] & (1 << 10);
+}
+
+static inline int ata_id_hpa_enabled(const u16 *id)
+{
+        /* Yes children, word 83 valid bits cover word 82 data */
+        if ((id[83] & 0xC000) != 0x4000)
+                return 0;
+        /* And 87 covers 85-87 */
+        if ((id[87] & 0xC000) != 0x4000)
+                return 0;
+        /* Check command sets enabled as well as supported */
+        if ((id[85] & ( 1 << 10)) == 0)
+                return 0;
+        return id[82] & (1 << 10);
+}
+
+static inline int ata_id_has_wcache(const u16 *id)
+{
+        /* Yes children, word 83 valid bits cover word 82 data */
+        if ((id[83] & 0xC000) != 0x4000)
+                return 0;
+        return id[82] & (1 << 5);
+}
+
+static inline int ata_id_has_pm(const u16 *id)
+{
+        if ((id[83] & 0xC000) != 0x4000)
+                return 0;
+        return id[82] & (1 << 3);
+}
+
+static inline int ata_id_rahead_enabled(const u16 *id)
+{
+        if ((id[87] & 0xC000) != 0x4000)
+                return 0;
+        return id[85] & (1 << 6);
+}
+
+static inline int ata_id_wcache_enabled(const u16 *id)
+{
+        if ((id[87] & 0xC000) != 0x4000)
+                return 0;
+        return id[85] & (1 << 5);
+}
+
+/**
+ *      ata_id_major_version    -       get ATA level of drive
+ *      @id: Identify data
+ *
+ *      Caveats:
+ *              ATA-1 considers identify optional
+ *              ATA-2 introduces mandatory identify
+ *              ATA-3 introduces word 80 and accurate reporting
+ *
+ *      The practical impact of this is that ata_id_major_version cannot
+ *      reliably report on drives below ATA3. 
+ */
+
 static inline unsigned int ata_id_major_version(const u16 *id)
 {
         unsigned int mver;
diff --git a/include/linux/libata.h b/include/linux/libata.h
index a67bb9075e9b..229a9ff9f924 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -28,7 +28,6 @@
 
 #include <linux/delay.h>
 #include <linux/interrupt.h>
-#include <linux/pci.h>
 #include <linux/dma-mapping.h>
 #include <asm/scatterlist.h>
 #include <linux/io.h>
@@ -107,12 +106,6 @@ static inline u32 ata_msg_init(int dval, int default_msg_enable_bits)
 /* defines only for the constants which don't work well as enums */
 #define ATA_TAG_POISON          0xfafbfcfdU
 
-/* move to PCI layer? */
-static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
-{
-        return &pdev->dev;
-}
-
 enum {
         /* various global constants */
         LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
@@ -139,11 +132,12 @@ enum {
         ATA_DFLAG_FLUSH_EXT     = (1 << 4), /* do FLUSH_EXT instead of FLUSH */
         ATA_DFLAG_ACPI_PENDING  = (1 << 5), /* ACPI resume action pending */
         ATA_DFLAG_ACPI_FAILED   = (1 << 6), /* ACPI on devcfg has failed */
-        ATA_DFLAG_CFG_MASK      = (1 << 8) - 1,
+        ATA_DFLAG_AN            = (1 << 7), /* AN configured */
+        ATA_DFLAG_CFG_MASK      = (1 << 12) - 1,
 
-        ATA_DFLAG_PIO           = (1 << 8), /* device limited to PIO mode */
-        ATA_DFLAG_NCQ_OFF       = (1 << 9), /* device limited to non-NCQ mode */
-        ATA_DFLAG_SPUNDOWN      = (1 << 10), /* XXX: for spindown_compat */
+        ATA_DFLAG_PIO           = (1 << 12), /* device limited to PIO mode */
+        ATA_DFLAG_NCQ_OFF       = (1 << 13), /* device limited to non-NCQ mode */
+        ATA_DFLAG_SPUNDOWN      = (1 << 14), /* XXX: for spindown_compat */
         ATA_DFLAG_INIT_MASK     = (1 << 16) - 1,
 
         ATA_DFLAG_DETACH        = (1 << 16),
@@ -154,7 +148,22 @@ enum {
         ATA_DEV_ATA_UNSUP       = 2,    /* ATA device (unsupported) */
         ATA_DEV_ATAPI           = 3,    /* ATAPI device */
         ATA_DEV_ATAPI_UNSUP     = 4,    /* ATAPI device (unsupported) */
-        ATA_DEV_NONE            = 5,    /* no device */
+        ATA_DEV_PMP             = 5,    /* SATA port multiplier */
+        ATA_DEV_PMP_UNSUP       = 6,    /* SATA port multiplier (unsupported) */
+        ATA_DEV_SEMB            = 7,    /* SEMB */
+        ATA_DEV_SEMB_UNSUP      = 8,    /* SEMB (unsupported) */
+        ATA_DEV_NONE            = 9,    /* no device */
+
+        /* struct ata_link flags */
+        ATA_LFLAG_HRST_TO_RESUME = (1 << 0), /* hardreset to resume link */
+        ATA_LFLAG_SKIP_D2H_BSY  = (1 << 1), /* can't wait for the first D2H
+                                             * Register FIS clearing BSY */
+        ATA_LFLAG_NO_SRST       = (1 << 2), /* avoid softreset */
+        ATA_LFLAG_ASSUME_ATA    = (1 << 3), /* assume ATA class */
+        ATA_LFLAG_ASSUME_SEMB   = (1 << 4), /* assume SEMB class */
+        ATA_LFLAG_ASSUME_CLASS  = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
+        ATA_LFLAG_NO_RETRY      = (1 << 5), /* don't retry this link */
+        ATA_LFLAG_DISABLED      = (1 << 6), /* link is disabled */
 
         /* struct ata_port flags */
         ATA_FLAG_SLAVE_POSS     = (1 << 0), /* host supports slave dev */
@@ -170,13 +179,12 @@ enum {
         ATA_FLAG_PIO_POLLING    = (1 << 9), /* use polling PIO if LLD
                                              * doesn't handle PIO interrupts */
         ATA_FLAG_NCQ            = (1 << 10), /* host supports NCQ */
-        ATA_FLAG_HRST_TO_RESUME = (1 << 11), /* hardreset to resume phy */
-        ATA_FLAG_SKIP_D2H_BSY   = (1 << 12), /* can't wait for the first D2H
-                                              * Register FIS clearing BSY */
         ATA_FLAG_DEBUGMSG       = (1 << 13),
         ATA_FLAG_IGN_SIMPLEX    = (1 << 15), /* ignore SIMPLEX */
         ATA_FLAG_NO_IORDY       = (1 << 16), /* controller lacks iordy */
         ATA_FLAG_ACPI_SATA      = (1 << 17), /* need native SATA ACPI layout */
+        ATA_FLAG_AN             = (1 << 18), /* controller supports AN */
+        ATA_FLAG_PMP            = (1 << 19), /* controller supports PMP */
 
         /* The following flag belongs to ap->pflags but is kept in
          * ap->flags because it's referenced in many LLDs and will be
@@ -195,6 +203,7 @@ enum {
         ATA_PFLAG_UNLOADING     = (1 << 5), /* module is unloading */
         ATA_PFLAG_SCSI_HOTPLUG  = (1 << 6), /* SCSI hotplug scheduled */
         ATA_PFLAG_INITIALIZING  = (1 << 7), /* being initialized, don't touch */
+        ATA_PFLAG_RESETTING     = (1 << 8), /* reset in progress */
 
         ATA_PFLAG_SUSPENDED     = (1 << 17), /* port is suspended (power) */
         ATA_PFLAG_PM_PENDING    = (1 << 18), /* PM operation pending */
@@ -207,6 +216,7 @@ enum {
         ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
         ATA_QCFLAG_IO           = (1 << 3), /* standard IO command */
         ATA_QCFLAG_RESULT_TF    = (1 << 4), /* result TF requested */
+        ATA_QCFLAG_CLEAR_EXCL   = (1 << 5), /* clear excl_link on completion */
 
         ATA_QCFLAG_FAILED       = (1 << 16), /* cmd failed and is owned by EH */
         ATA_QCFLAG_SENSE_VALID  = (1 << 17), /* sense data valid */
@@ -263,6 +273,10 @@ enum {
         /* ering size */
         ATA_ERING_SIZE          = 32,
 
+        /* return values for ->qc_defer */
+        ATA_DEFER_LINK          = 1,
+        ATA_DEFER_PORT          = 2,
+
         /* desc_len for ata_eh_info and context */
         ATA_EH_DESC_LEN         = 80,
 
@@ -270,6 +284,7 @@ enum {
         ATA_EH_REVALIDATE       = (1 << 0),
         ATA_EH_SOFTRESET        = (1 << 1),
         ATA_EH_HARDRESET        = (1 << 2),
+        ATA_EH_ENABLE_LINK      = (1 << 3),
 
         ATA_EH_RESET_MASK       = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
         ATA_EH_PERDEV_MASK      = ATA_EH_REVALIDATE,
@@ -289,12 +304,16 @@ enum {
         ATA_EHI_DID_RESET       = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
         ATA_EHI_RESET_MODIFIER_MASK = ATA_EHI_RESUME_LINK,
 
-        /* max repeat if error condition is still set after ->error_handler */
-        ATA_EH_MAX_REPEAT       = 5,
+        /* max tries if error condition is still set after ->error_handler */
+        ATA_EH_MAX_TRIES        = 5,
 
         /* how hard are we gonna try to probe/recover devices */
         ATA_PROBE_MAX_TRIES     = 3,
         ATA_EH_DEV_TRIES        = 3,
+        ATA_EH_PMP_TRIES        = 5,
+        ATA_EH_PMP_LINK_TRIES   = 3,
+
+        SATA_PMP_SCR_TIMEOUT    = 250,
 
         /* Horkage types. May be set by libata or controller on drives
            (some horkage may be drive/controller pair dependant */
@@ -304,6 +323,14 @@ enum {
         ATA_HORKAGE_NONCQ       = (1 << 2),     /* Don't use NCQ */
         ATA_HORKAGE_MAX_SEC_128 = (1 << 3),     /* Limit max sects to 128 */
         ATA_HORKAGE_BROKEN_HPA  = (1 << 4),     /* Broken HPA */
+        ATA_HORKAGE_SKIP_PM     = (1 << 5),     /* Skip PM operations */
+        ATA_HORKAGE_HPA_SIZE    = (1 << 6),     /* native size off by one */
+
+         /* DMA mask for user DMA control: User visible values; DO NOT 
+            renumber */
+        ATA_DMA_MASK_ATA        = (1 << 0),     /* DMA on ATA Disk */
+        ATA_DMA_MASK_ATAPI      = (1 << 1),     /* DMA on ATAPI */
+        ATA_DMA_MASK_CFA        = (1 << 2),     /* DMA on CF Card */
 };
 
 enum hsm_task_states {
@@ -333,14 +360,15 @@ enum ata_completion_errors {
 struct scsi_device;
 struct ata_port_operations;
 struct ata_port;
+struct ata_link;
 struct ata_queued_cmd;
 
 /* typedefs */
 typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
-typedef int (*ata_prereset_fn_t)(struct ata_port *ap, unsigned long deadline);
-typedef int (*ata_reset_fn_t)(struct ata_port *ap, unsigned int *classes,
+typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);
+typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes,
                               unsigned long deadline);
-typedef void (*ata_postreset_fn_t)(struct ata_port *ap, unsigned int *classes);
+typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
 
 struct ata_ioports {
         void __iomem            *cmd_addr;
@@ -363,8 +391,6 @@ struct ata_ioports {
 struct ata_host {
         spinlock_t              lock;
         struct device           *dev;
-        unsigned long           irq;
-        unsigned long           irq2;
         void __iomem * const    *iomap;
         unsigned int            n_ports;
         void                    *private_data;
@@ -436,7 +462,7 @@ struct ata_ering {
 };
 
 struct ata_device {
-        struct ata_port         *ap;
+        struct ata_link         *link;
         unsigned int            devno;          /* 0 or 1 */
         unsigned long           flags;          /* ATA_DFLAG_xxx */
         unsigned int            horkage;        /* List of broken features */
@@ -447,7 +473,12 @@ struct ata_device {
         /* n_sector is used as CLEAR_OFFSET, read comment above CLEAR_OFFSET */
         u64                     n_sectors;      /* size of device, if ATA */
         unsigned int            class;          /* ATA_DEV_xxx */
-        u16                     id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
+
+        union {
+                u16             id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
+                u32             gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
+        };
+
         u8                      pio_mode;
         u8                      dma_mode;
         u8                      xfer_mode;
@@ -510,6 +541,27 @@ struct ata_acpi_gtm {
         u32 flags;
 } __packed;
 
+struct ata_link {
+        struct ata_port         *ap;
+        int                     pmp;            /* port multiplier port # */
+
+        unsigned int            active_tag;     /* active tag on this link */
+        u32                     sactive;        /* active NCQ commands */
+
+        unsigned int            flags;          /* ATA_LFLAG_xxx */
+
+        unsigned int            hw_sata_spd_limit;
+        unsigned int            sata_spd_limit;
+        unsigned int            sata_spd;       /* current SATA PHY speed */
+
+        /* record runtime error info, protected by host_set lock */
+        struct ata_eh_info      eh_info;
+        /* EH context */
+        struct ata_eh_context   eh_context;
+
+        struct ata_device       device[ATA_MAX_DEVICES];
+};
+
 struct ata_port {
         struct Scsi_Host        *scsi_host; /* our co-allocated scsi host */
         const struct ata_port_operations *ops;
@@ -533,23 +585,17 @@ struct ata_port {
         unsigned int            mwdma_mask;
         unsigned int            udma_mask;
         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
-        unsigned int            hw_sata_spd_limit;
-        unsigned int            sata_spd_limit; /* SATA PHY speed limit */
-        unsigned int            sata_spd;       /* current SATA PHY speed */
-
-        /* record runtime error info, protected by host lock */
-        struct ata_eh_info      eh_info;
-        /* EH context owned by EH */
-        struct ata_eh_context   eh_context;
-
-        struct ata_device       device[ATA_MAX_DEVICES];
 
         struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
         unsigned long           qc_allocated;
         unsigned int            qc_active;
+        int                     nr_active_links; /* #links with active qcs */
+
+        struct ata_link         link;   /* host default link */
 
-        unsigned int            active_tag;
-        u32                     sactive;
+        int                     nr_pmp_links;   /* nr of available PMP links */
+        struct ata_link         *pmp_link;      /* array of PMP links */
+        struct ata_link         *excl_link;     /* for PMP qc exclusion */
 
         struct ata_port_stats   stats;
         struct ata_host         *host;
@@ -565,6 +611,7 @@ struct ata_port {
         u32                     msg_enable;
         struct list_head        eh_done_q;
         wait_queue_head_t       eh_wait_q;
+        int                     eh_tries;
 
         pm_message_t            pm_mesg;
         int                     *pm_result;
@@ -582,8 +629,6 @@ struct ata_port {
 };
 
 struct ata_port_operations {
-        void (*port_disable) (struct ata_port *);
-
         void (*dev_config) (struct ata_device *);
 
         void (*set_piomode) (struct ata_port *, struct ata_device *);
@@ -599,7 +644,7 @@ struct ata_port_operations {
         void (*dev_select)(struct ata_port *ap, unsigned int device);
 
         void (*phy_reset) (struct ata_port *ap); /* obsolete */
-        int  (*set_mode) (struct ata_port *ap, struct ata_device **r_failed_dev);
+        int  (*set_mode) (struct ata_link *link, struct ata_device **r_failed_dev);
 
         int (*cable_detect) (struct ata_port *ap);
 
@@ -610,9 +655,14 @@ struct ata_port_operations {
 
         void (*data_xfer) (struct ata_device *, unsigned char *, unsigned int, int);
 
+        int (*qc_defer) (struct ata_queued_cmd *qc);
         void (*qc_prep) (struct ata_queued_cmd *qc);
         unsigned int (*qc_issue) (struct ata_queued_cmd *qc);
 
+        /* port multiplier */
+        void (*pmp_attach) (struct ata_port *ap);
+        void (*pmp_detach) (struct ata_port *ap);
+
         /* Error handlers.  ->error_handler overrides ->eng_timeout and
          * indicates that new-style EH is in place.
          */
@@ -626,7 +676,6 @@ struct ata_port_operations {
         irq_handler_t irq_handler;
         void (*irq_clear) (struct ata_port *);
         u8 (*irq_on) (struct ata_port *);
-        u8 (*irq_ack) (struct ata_port *ap, unsigned int chk_drq);
 
         int (*scr_read) (struct ata_port *ap, unsigned int sc_reg, u32 *val);
         int (*scr_write) (struct ata_port *ap, unsigned int sc_reg, u32 val);
@@ -646,6 +695,7 @@ struct ata_port_operations {
 struct ata_port_info {
         struct scsi_host_template       *sht;
         unsigned long           flags;
+        unsigned long           link_flags;
         unsigned long           pio_mask;
         unsigned long           mwdma_mask;
         unsigned long           udma_mask;
@@ -689,38 +739,27 @@ static inline int ata_port_is_dummy(struct ata_port *ap)
         return ap->ops == &ata_dummy_port_ops;
 }
 
-extern void sata_print_link_status(struct ata_port *ap);
+extern void sata_print_link_status(struct ata_link *link);
 extern void ata_port_probe(struct ata_port *);
 extern void __sata_phy_reset(struct ata_port *ap);
 extern void sata_phy_reset(struct ata_port *ap);
 extern void ata_bus_reset(struct ata_port *ap);
-extern int sata_set_spd(struct ata_port *ap);
-extern int sata_phy_debounce(struct ata_port *ap, const unsigned long *param,
-                             unsigned long deadline);
-extern int sata_phy_resume(struct ata_port *ap, const unsigned long *param,
-                           unsigned long deadline);
-extern int ata_std_prereset(struct ata_port *ap, unsigned long deadline);
-extern int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
+extern int sata_set_spd(struct ata_link *link);
+extern int sata_link_debounce(struct ata_link *link,
+                        const unsigned long *params, unsigned long deadline);
+extern int sata_link_resume(struct ata_link *link, const unsigned long *params,
+                            unsigned long deadline);
+extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
+extern int ata_std_softreset(struct ata_link *link, unsigned int *classes,
                              unsigned long deadline);
-extern int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
-                               unsigned long deadline);
-extern int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
+extern int sata_link_hardreset(struct ata_link *link,
+                        const unsigned long *timing, unsigned long deadline);
+extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
                               unsigned long deadline);
-extern void ata_std_postreset(struct ata_port *ap, unsigned int *classes);
+extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
 extern void ata_port_disable(struct ata_port *);
 extern void ata_std_ports(struct ata_ioports *ioaddr);
-#ifdef CONFIG_PCI
-extern int ata_pci_init_one (struct pci_dev *pdev,
-                             const struct ata_port_info * const * ppi);
-extern void ata_pci_remove_one (struct pci_dev *pdev);
-#ifdef CONFIG_PM
-extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
-extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
-extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
-extern int ata_pci_device_resume(struct pci_dev *pdev);
-#endif
-extern int ata_pci_clear_simplex(struct pci_dev *pdev);
-#endif /* CONFIG_PCI */
+
 extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
 extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
                         const struct ata_port_info * const * ppi, int n_ports);
@@ -746,12 +785,12 @@ extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *);
 extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
                             struct ata_port *ap);
 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
-extern int sata_scr_valid(struct ata_port *ap);
-extern int sata_scr_read(struct ata_port *ap, int reg, u32 *val);
-extern int sata_scr_write(struct ata_port *ap, int reg, u32 val);
-extern int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val);
-extern int ata_port_online(struct ata_port *ap);
-extern int ata_port_offline(struct ata_port *ap);
+extern int sata_scr_valid(struct ata_link *link);
+extern int sata_scr_read(struct ata_link *link, int reg, u32 *val);
+extern int sata_scr_write(struct ata_link *link, int reg, u32 val);
+extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val);
+extern int ata_link_online(struct ata_link *link);
+extern int ata_link_offline(struct ata_link *link);
 #ifdef CONFIG_PM
 extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
 extern void ata_host_resume(struct ata_host *host);
@@ -765,7 +804,8 @@ extern void ata_port_queue_task(struct ata_port *ap, work_func_t fn,
 extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
                              unsigned long interval_msec,
                              unsigned long timeout_msec);
-extern unsigned int ata_dev_try_classify(struct ata_port *, unsigned int, u8 *);
+extern unsigned int ata_dev_try_classify(struct ata_device *dev, int present,
+                                         u8 *r_err);
 
 /*
  * Default driver ops implementations
@@ -787,6 +827,7 @@ extern void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
                           unsigned int buflen, int write_data);
 extern void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
                                 unsigned int buflen, int write_data);
+extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
 extern void ata_dumb_qc_prep(struct ata_queued_cmd *qc);
 extern void ata_qc_prep(struct ata_queued_cmd *qc);
 extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
@@ -830,11 +871,8 @@ extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
 extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
                                        int queue_depth);
 extern struct ata_device *ata_dev_pair(struct ata_device *adev);
-extern int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev);
+extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
 extern u8 ata_irq_on(struct ata_port *ap);
-extern u8 ata_dummy_irq_on(struct ata_port *ap);
-extern u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq);
-extern u8 ata_dummy_irq_ack(struct ata_port *ap, unsigned int chk_drq);
 
 extern int ata_cable_40wire(struct ata_port *ap);
 extern int ata_cable_80wire(struct ata_port *ap);
@@ -869,8 +907,29 @@ enum {
                                   ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
 };
 
+/* libata-acpi.c */
+#ifdef CONFIG_ATA_ACPI
+extern int ata_acpi_cbl_80wire(struct ata_port *ap);
+int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm);
+int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *stm);
+#else
+static inline int ata_acpi_cbl_80wire(struct ata_port *ap) { return 0; }
+#endif
 
 #ifdef CONFIG_PCI
+struct pci_dev;
+
+extern int ata_pci_init_one (struct pci_dev *pdev,
+                             const struct ata_port_info * const * ppi);
+extern void ata_pci_remove_one (struct pci_dev *pdev);
+#ifdef CONFIG_PM
+extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
+extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
+extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
+extern int ata_pci_device_resume(struct pci_dev *pdev);
+#endif
+extern int ata_pci_clear_simplex(struct pci_dev *pdev);
+
 struct pci_bits {
         unsigned int            reg;    /* PCI config register to read */
         unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
@@ -888,13 +947,29 @@ extern unsigned long ata_pci_default_filter(struct ata_device *, unsigned long);
 #endif /* CONFIG_PCI */
 
 /*
+ * PMP
+ */
+extern int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc);
+extern int sata_pmp_std_prereset(struct ata_link *link, unsigned long deadline);
+extern int sata_pmp_std_hardreset(struct ata_link *link, unsigned int *class,
+                                  unsigned long deadline);
+extern void sata_pmp_std_postreset(struct ata_link *link, unsigned int *class);
+extern void sata_pmp_do_eh(struct ata_port *ap,
+                ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
+                ata_reset_fn_t hardreset, ata_postreset_fn_t postreset,
+                ata_prereset_fn_t pmp_prereset, ata_reset_fn_t pmp_softreset,
+                ata_reset_fn_t pmp_hardreset, ata_postreset_fn_t pmp_postreset);
+
+/*
  * EH
  */
 extern void ata_eng_timeout(struct ata_port *ap);
 
 extern void ata_port_schedule_eh(struct ata_port *ap);
+extern int ata_link_abort(struct ata_link *link);
 extern int ata_port_abort(struct ata_port *ap);
 extern int ata_port_freeze(struct ata_port *ap);
+extern int sata_async_notification(struct ata_port *ap);
 
 extern void ata_eh_freeze_port(struct ata_port *ap);
 extern void ata_eh_thaw_port(struct ata_port *ap);
@@ -912,14 +987,25 @@ extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
 #define ata_port_printk(ap, lv, fmt, args...) \
         printk(lv"ata%u: "fmt, (ap)->print_id , ##args)
 
+#define ata_link_printk(link, lv, fmt, args...) do { \
+        if ((link)->ap->nr_pmp_links) \
+                printk(lv"ata%u.%02u: "fmt, (link)->ap->print_id, \
+                       (link)->pmp , ##args); \
+        else \
+                printk(lv"ata%u: "fmt, (link)->ap->print_id , ##args); \
+        } while(0)
+
 #define ata_dev_printk(dev, lv, fmt, args...) \
-        printk(lv"ata%u.%02u: "fmt, (dev)->ap->print_id, (dev)->devno , ##args)
+        printk(lv"ata%u.%02u: "fmt, (dev)->link->ap->print_id, \
+               (dev)->link->pmp + (dev)->devno , ##args)
 
 /*
  * ata_eh_info helpers
  */
-extern void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
-extern void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
+extern void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
 extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
 
 static inline void ata_ehi_schedule_probe(struct ata_eh_info *ehi)
@@ -933,10 +1019,21 @@ static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
 {
         ata_ehi_schedule_probe(ehi);
         ehi->flags |= ATA_EHI_HOTPLUGGED;
+        ehi->action |= ATA_EH_ENABLE_LINK;
         ehi->err_mask |= AC_ERR_ATA_BUS;
 }
 
 /*
+ * port description helpers
+ */
+extern void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+#ifdef CONFIG_PCI
+extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
+                               const char *name);
+#endif
+
+/*
  * qc helpers
  */
 static inline int
@@ -991,12 +1088,14 @@ static inline unsigned int ata_tag_internal(unsigned int tag)
  */
 static inline unsigned int ata_class_enabled(unsigned int class)
 {
-        return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI;
+        return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI ||
+                class == ATA_DEV_PMP || class == ATA_DEV_SEMB;
 }
 
 static inline unsigned int ata_class_disabled(unsigned int class)
 {
-        return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP;
+        return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP ||
+                class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP;
 }
 
 static inline unsigned int ata_class_absent(unsigned int class)
@@ -1020,15 +1119,62 @@ static inline unsigned int ata_dev_absent(const struct ata_device *dev)
 }
 
 /*
- * port helpers
+ * link helpers
  */
-static inline int ata_port_max_devices(const struct ata_port *ap)
+static inline int ata_is_host_link(const struct ata_link *link)
+{
+        return link == &link->ap->link;
+}
+
+static inline int ata_link_max_devices(const struct ata_link *link)
 {
-        if (ap->flags & ATA_FLAG_SLAVE_POSS)
+        if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS)
                 return 2;
         return 1;
 }
 
+static inline int ata_link_active(struct ata_link *link)
+{
+        return ata_tag_valid(link->active_tag) || link->sactive;
+}
+
+static inline struct ata_link *ata_port_first_link(struct ata_port *ap)
+{
+        if (ap->nr_pmp_links)
+                return ap->pmp_link;
+        return &ap->link;
+}
+
+static inline struct ata_link *ata_port_next_link(struct ata_link *link)
+{
+        struct ata_port *ap = link->ap;
+
+        if (link == &ap->link) {
+                if (!ap->nr_pmp_links)
+                        return NULL;
+                return ap->pmp_link;
+        }
+
+        if (++link - ap->pmp_link < ap->nr_pmp_links)
+                return link;
+        return NULL;
+}
+
+#define __ata_port_for_each_link(lk, ap) \
+        for ((lk) = &(ap)->link; (lk); (lk) = ata_port_next_link(lk))
+
+#define ata_port_for_each_link(link, ap) \
+        for ((link) = ata_port_first_link(ap); (link); \
+             (link) = ata_port_next_link(link))
+
+#define ata_link_for_each_dev(dev, link) \
+        for ((dev) = (link)->device; \
+             (dev) < (link)->device + ata_link_max_devices(link) || ((dev) = NULL); \
+             (dev)++)
+
+#define ata_link_for_each_dev_reverse(dev, link) \
+        for ((dev) = (link)->device + ata_link_max_devices(link) - 1; \
+             (dev) >= (link)->device || ((dev) = NULL); (dev)--)
 
 static inline u8 ata_chk_status(struct ata_port *ap)
 {
@@ -1110,9 +1256,11 @@ static inline u8 ata_wait_idle(struct ata_port *ap)
 {
         u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
 
+#ifdef ATA_DEBUG
         if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ)))
-                DPRINTK("ATA: abnormal status 0x%X on port 0x%p\n",
-                        status, ap->ioaddr.status_addr);
+                ata_port_printk(ap, KERN_DEBUG, "abnormal Status 0x%X\n",
+                                status);
+#endif
 
         return status;
 }
@@ -1149,7 +1297,7 @@ static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
 {
         memset(tf, 0, sizeof(*tf));
 
-        tf->ctl = dev->ap->ctl;
+        tf->ctl = dev->link->ap->ctl;
         if (dev->devno == 0)
                 tf->device = ATA_DEVICE_OBS;
         else