82 files changed, 7866 insertions, 2064 deletions

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 9cbc82e37ed0..c323778270ff 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -865,6 +865,10 @@ and is between 256 and 4096 characters. It is defined in the file
         lasi=           [HW,SCSI] PARISC LASI driver for the 53c700 chip
                         Format: addr:<io>,irq:<irq>
 
+        libata.noacpi   [LIBATA] Disables use of ACPI in libata suspend/resume
+                        when set.
+                        Format: <int>
+
         load_ramdisk=   [RAM] List of ramdisks to load from floppy
                         See Documentation/ramdisk.txt.
 
@@ -1085,10 +1089,6 @@ and is between 256 and 4096 characters. It is defined in the file
                         emulation library even if a 387 maths coprocessor
                         is present.
 
-        noacpi          [LIBATA] Disables use of ACPI in libata suspend/resume
-                        when set.
-                        Format: <int>
-
         noaliencache    [MM, NUMA, SLAB] Disables the allocation of alien
                         caches in the slab allocator.  Saves per-node memory,
                         but will impact performance.
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index d8046a113c37..4672066167e3 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -173,6 +173,15 @@ config SATA_INIC162X
         help
           This option enables support for Initio 162x Serial ATA.
 
+config PATA_ACPI
+        tristate "ACPI firmware driver for PATA"
+        depends on ATA_ACPI
+        help
+          This option enables an ACPI method driver which drives
+          motherboard PATA controller interfaces through the ACPI
+          firmware in the BIOS. This driver can sometimes handle
+          otherwise unsupported hardware.
+
 config PATA_ALI
         tristate "ALi PATA support (Experimental)"
         depends on PCI && EXPERIMENTAL
@@ -192,16 +201,25 @@ config PATA_AMD
           If unsure, say N.
 
 config PATA_ARTOP
-        tristate "ARTOP 6210/6260 PATA support (Experimental)"
-        depends on PCI && EXPERIMENTAL
+        tristate "ARTOP 6210/6260 PATA support"
+        depends on PCI
         help
           This option enables support for ARTOP PATA controllers.
 
           If unsure, say N.
 
+config PATA_AT32
+        tristate "Atmel AVR32 PATA support (Experimental)"
+        depends on AVR32 && PLATFORM_AT32AP && EXPERIMENTAL
+        help
+          This option enables support for the IDE devices on the
+          Atmel AT32AP platform.
+
+          If unsure, say N.
+
 config PATA_ATIIXP
-        tristate "ATI PATA support (Experimental)"
-        depends on PCI && EXPERIMENTAL
+        tristate "ATI PATA support"
+        depends on PCI
         help
           This option enables support for the ATI ATA interfaces
           found on the many ATI chipsets.
@@ -219,8 +237,8 @@ config PATA_CMD640_PCI
           If unsure, say N.
 
 config PATA_CMD64X
-        tristate "CMD64x PATA support (Very Experimental)"
-        depends on PCI&& EXPERIMENTAL
+        tristate "CMD64x PATA support"
+        depends on PCI
         help
           This option enables support for the CMD64x series chips
           except for the CMD640.
@@ -282,8 +300,8 @@ config ATA_GENERIC
           If unsure, say N.
 
 config PATA_HPT366
-        tristate "HPT 366/368 PATA support (Experimental)"
-        depends on PCI && EXPERIMENTAL
+        tristate "HPT 366/368 PATA support"
+        depends on PCI
         help
           This option enables support for the HPT 366 and 368
           PATA controllers via the new ATA layer.
@@ -432,6 +450,15 @@ config PATA_NS87410
 
           If unsure, say N.
 
+config PATA_NS87415
+        tristate "Nat Semi NS87415 PATA support (Experimental)"
+        depends on PCI && EXPERIMENTAL
+        help
+          This option enables support for the National Semiconductor
+          NS87415 PCI-IDE controller.
+
+          If unsure, say N.
+
 config PATA_OPTI
         tristate "OPTI621/6215 PATA support (Very Experimental)"
         depends on PCI && EXPERIMENTAL
@@ -596,4 +623,20 @@ config PATA_SCC
 
           If unsure, say N.
 
+config PATA_BF54X
+        tristate "Blackfin 54x ATAPI support"
+        depends on BF542 || BF548 || BF549
+        help
+          This option enables support for the built-in ATAPI controller on
+          Blackfin 54x family chips.
+
+          If unsure, say N.
+
+config PATA_BF54X_DMA
+        bool "DMA mode"
+        depends on PATA_BF54X
+        default y
+        help
+          Enable DMA mode for Blackfin ATAPI controller.
+
 endif # ATA
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index 8149c68ac2c7..2a63645003eb 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_PDC_ADMA)		+= pdc_adma.o
 obj-$(CONFIG_PATA_ALI)          += pata_ali.o
 obj-$(CONFIG_PATA_AMD)          += pata_amd.o
 obj-$(CONFIG_PATA_ARTOP)        += pata_artop.o
+obj-$(CONFIG_PATA_AT32)         += pata_at32.o
 obj-$(CONFIG_PATA_ATIIXP)       += pata_atiixp.o
 obj-$(CONFIG_PATA_CMD640_PCI)   += pata_cmd640.o
 obj-$(CONFIG_PATA_CMD64X)       += pata_cmd64x.o
@@ -39,6 +40,7 @@ obj-$(CONFIG_PATA_IT8213)	+= pata_it8213.o
 obj-$(CONFIG_PATA_JMICRON)      += pata_jmicron.o
 obj-$(CONFIG_PATA_NETCELL)      += pata_netcell.o
 obj-$(CONFIG_PATA_NS87410)      += pata_ns87410.o
+obj-$(CONFIG_PATA_NS87415)      += pata_ns87415.o
 obj-$(CONFIG_PATA_OPTI)         += pata_opti.o
 obj-$(CONFIG_PATA_OPTIDMA)      += pata_optidma.o
 obj-$(CONFIG_PATA_MPC52xx)      += pata_mpc52xx.o
@@ -61,12 +63,16 @@ obj-$(CONFIG_PATA_SIS)		+= pata_sis.o
 obj-$(CONFIG_PATA_TRIFLEX)      += pata_triflex.o
 obj-$(CONFIG_PATA_IXP4XX_CF)    += pata_ixp4xx_cf.o
 obj-$(CONFIG_PATA_SCC)          += pata_scc.o
+obj-$(CONFIG_PATA_BF54X)        += pata_bf54x.o
 obj-$(CONFIG_PATA_PLATFORM)     += pata_platform.o
 obj-$(CONFIG_PATA_ICSIDE)       += pata_icside.o
+# Should be last but two libata driver
+obj-$(CONFIG_PATA_ACPI)         += pata_acpi.o
 # Should be last but one libata driver
 obj-$(CONFIG_ATA_GENERIC)       += ata_generic.o
 # Should be last libata driver
 obj-$(CONFIG_PATA_LEGACY)       += pata_legacy.o
 
-libata-objs     := libata-core.o libata-scsi.o libata-sff.o libata-eh.o
+libata-objs     := libata-core.o libata-scsi.o libata-sff.o libata-eh.o \
+                   libata-pmp.o
 libata-$(CONFIG_ATA_ACPI)       += libata-acpi.o
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index c16820325d7b..10bc3f64c453 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -46,7 +46,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME        "ahci"
-#define DRV_VERSION     "2.3"
+#define DRV_VERSION     "3.0"
 
 
 enum {
@@ -77,11 +77,10 @@ enum {
         RX_FIS_UNK              = 0x60, /* offset of Unknown FIS data */
 
         board_ahci              = 0,
-        board_ahci_pi           = 1,
-        board_ahci_vt8251       = 2,
-        board_ahci_ign_iferr    = 3,
-        board_ahci_sb600        = 4,
-        board_ahci_mv           = 5,
+        board_ahci_vt8251       = 1,
+        board_ahci_ign_iferr    = 2,
+        board_ahci_sb600        = 3,
+        board_ahci_mv           = 4,
 
         /* global controller registers */
         HOST_CAP                = 0x00, /* host capabilities */
@@ -97,6 +96,7 @@ enum {
 
         /* HOST_CAP bits */
         HOST_CAP_SSC            = (1 << 14), /* Slumber capable */
+        HOST_CAP_PMP            = (1 << 17), /* Port Multiplier support */
         HOST_CAP_CLO            = (1 << 24), /* Command List Override support */
         HOST_CAP_SSS            = (1 << 27), /* Staggered Spin-up */
         HOST_CAP_SNTF           = (1 << 29), /* SNotification register */
@@ -144,7 +144,8 @@ enum {
                                   PORT_IRQ_IF_ERR |
                                   PORT_IRQ_CONNECT |
                                   PORT_IRQ_PHYRDY |
-                                  PORT_IRQ_UNK_FIS,
+                                  PORT_IRQ_UNK_FIS |
+                                  PORT_IRQ_BAD_PMP,
         PORT_IRQ_ERROR          = PORT_IRQ_FREEZE |
                                   PORT_IRQ_TF_ERR |
                                   PORT_IRQ_HBUS_DATA_ERR,
@@ -154,6 +155,7 @@ enum {
 
         /* PORT_CMD bits */
         PORT_CMD_ATAPI          = (1 << 24), /* Device is ATAPI */
+        PORT_CMD_PMP            = (1 << 17), /* PMP attached */
         PORT_CMD_LIST_ON        = (1 << 15), /* cmd list DMA engine running */
         PORT_CMD_FIS_ON         = (1 << 14), /* FIS DMA engine running */
         PORT_CMD_FIS_RX         = (1 << 4), /* Enable FIS receive DMA engine */
@@ -167,19 +169,22 @@ enum {
         PORT_CMD_ICC_PARTIAL    = (0x2 << 28), /* Put i/f in partial state */
         PORT_CMD_ICC_SLUMBER    = (0x6 << 28), /* Put i/f in slumber state */
 
+        /* hpriv->flags bits */
+        AHCI_HFLAG_NO_NCQ               = (1 << 0),
+        AHCI_HFLAG_IGN_IRQ_IF_ERR       = (1 << 1), /* ignore IRQ_IF_ERR */
+        AHCI_HFLAG_IGN_SERR_INTERNAL    = (1 << 2), /* ignore SERR_INTERNAL */
+        AHCI_HFLAG_32BIT_ONLY           = (1 << 3), /* force 32bit */
+        AHCI_HFLAG_MV_PATA              = (1 << 4), /* PATA port */
+        AHCI_HFLAG_NO_MSI               = (1 << 5), /* no PCI MSI */
+        AHCI_HFLAG_NO_PMP               = (1 << 6), /* no PMP */
+
         /* ap->flags bits */
-        AHCI_FLAG_NO_NCQ                = (1 << 24),
-        AHCI_FLAG_IGN_IRQ_IF_ERR        = (1 << 25), /* ignore IRQ_IF_ERR */
-        AHCI_FLAG_HONOR_PI              = (1 << 26), /* honor PORTS_IMPL */
-        AHCI_FLAG_IGN_SERR_INTERNAL     = (1 << 27), /* ignore SERR_INTERNAL */
-        AHCI_FLAG_32BIT_ONLY            = (1 << 28), /* force 32bit */
-        AHCI_FLAG_MV_PATA               = (1 << 29), /* PATA port */
-        AHCI_FLAG_NO_MSI                = (1 << 30), /* no PCI MSI */
+        AHCI_FLAG_NO_HOTPLUG            = (1 << 24), /* ignore PxSERR.DIAG.N */
 
         AHCI_FLAG_COMMON                = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                           ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
-                                          ATA_FLAG_SKIP_D2H_BSY |
-                                          ATA_FLAG_ACPI_SATA,
+                                          ATA_FLAG_ACPI_SATA | ATA_FLAG_AN,
+        AHCI_LFLAG_COMMON               = ATA_LFLAG_SKIP_D2H_BSY,
 };
 
 struct ahci_cmd_hdr {
@@ -198,6 +203,7 @@ struct ahci_sg {
 };
 
 struct ahci_host_priv {
+        unsigned int            flags;          /* AHCI_HFLAG_* */
         u32                     cap;            /* cap to use */
         u32                     port_map;       /* port map to use */
         u32                     saved_cap;      /* saved initial cap */
@@ -205,6 +211,7 @@ struct ahci_host_priv {
 };
 
 struct ahci_port_priv {
+        struct ata_link         *active_link;
         struct ahci_cmd_hdr     *cmd_slot;
         dma_addr_t              cmd_slot_dma;
         void                    *cmd_tbl;
@@ -215,6 +222,7 @@ struct ahci_port_priv {
         unsigned int            ncq_saw_d2h:1;
         unsigned int            ncq_saw_dmas:1;
         unsigned int            ncq_saw_sdb:1;
+        u32                     intr_mask;      /* interrupts to enable */
 };
 
 static int ahci_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
@@ -229,6 +237,8 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc);
 static u8 ahci_check_status(struct ata_port *ap);
 static void ahci_freeze(struct ata_port *ap);
 static void ahci_thaw(struct ata_port *ap);
+static void ahci_pmp_attach(struct ata_port *ap);
+static void ahci_pmp_detach(struct ata_port *ap);
 static void ahci_error_handler(struct ata_port *ap);
 static void ahci_vt8251_error_handler(struct ata_port *ap);
 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc);
@@ -262,20 +272,17 @@ static struct scsi_host_template ahci_sht = {
 };
 
 static const struct ata_port_operations ahci_ops = {
-        .port_disable           = ata_port_disable,
-
         .check_status           = ahci_check_status,
         .check_altstatus        = ahci_check_status,
         .dev_select             = ata_noop_dev_select,
 
         .tf_read                = ahci_tf_read,
 
+        .qc_defer               = sata_pmp_qc_defer_cmd_switch,
         .qc_prep                = ahci_qc_prep,
         .qc_issue               = ahci_qc_issue,
 
         .irq_clear              = ahci_irq_clear,
-        .irq_on                 = ata_dummy_irq_on,
-        .irq_ack                = ata_dummy_irq_ack,
 
         .scr_read               = ahci_scr_read,
         .scr_write              = ahci_scr_write,
@@ -286,6 +293,9 @@ static const struct ata_port_operations ahci_ops = {
         .error_handler          = ahci_error_handler,
         .post_internal_cmd      = ahci_post_internal_cmd,
 
+        .pmp_attach             = ahci_pmp_attach,
+        .pmp_detach             = ahci_pmp_detach,
+
 #ifdef CONFIG_PM
         .port_suspend           = ahci_port_suspend,
         .port_resume            = ahci_port_resume,
@@ -296,20 +306,17 @@ static const struct ata_port_operations ahci_ops = {
 };
 
 static const struct ata_port_operations ahci_vt8251_ops = {
-        .port_disable           = ata_port_disable,
-
         .check_status           = ahci_check_status,
         .check_altstatus        = ahci_check_status,
         .dev_select             = ata_noop_dev_select,
 
         .tf_read                = ahci_tf_read,
 
+        .qc_defer               = sata_pmp_qc_defer_cmd_switch,
         .qc_prep                = ahci_qc_prep,
         .qc_issue               = ahci_qc_issue,
 
         .irq_clear              = ahci_irq_clear,
-        .irq_on                 = ata_dummy_irq_on,
-        .irq_ack                = ata_dummy_irq_ack,
 
         .scr_read               = ahci_scr_read,
         .scr_write              = ahci_scr_write,
@@ -320,6 +327,9 @@ static const struct ata_port_operations ahci_vt8251_ops = {
         .error_handler          = ahci_vt8251_error_handler,
         .post_internal_cmd      = ahci_post_internal_cmd,
 
+        .pmp_attach             = ahci_pmp_attach,
+        .pmp_detach             = ahci_pmp_detach,
+
 #ifdef CONFIG_PM
         .port_suspend           = ahci_port_suspend,
         .port_resume            = ahci_port_resume,
@@ -329,53 +339,52 @@ static const struct ata_port_operations ahci_vt8251_ops = {
         .port_stop              = ahci_port_stop,
 };
 
+#define AHCI_HFLAGS(flags)      .private_data   = (void *)(flags)
+
 static const struct ata_port_info ahci_port_info[] = {
         /* board_ahci */
         {
                 .flags          = AHCI_FLAG_COMMON,
-                .pio_mask       = 0x1f, /* pio0-4 */
-                .udma_mask      = ATA_UDMA6,
-                .port_ops       = &ahci_ops,
-        },
-        /* board_ahci_pi */
-        {
-                .flags          = AHCI_FLAG_COMMON | AHCI_FLAG_HONOR_PI,
+                .link_flags     = AHCI_LFLAG_COMMON,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
         /* board_ahci_vt8251 */
         {
-                .flags          = AHCI_FLAG_COMMON | ATA_FLAG_HRST_TO_RESUME |
-                                  AHCI_FLAG_NO_NCQ,
+                AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_PMP),
+                .flags          = AHCI_FLAG_COMMON,
+                .link_flags     = AHCI_LFLAG_COMMON | ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_vt8251_ops,
         },
         /* board_ahci_ign_iferr */
         {
-                .flags          = AHCI_FLAG_COMMON | AHCI_FLAG_IGN_IRQ_IF_ERR,
+                AHCI_HFLAGS     (AHCI_HFLAG_IGN_IRQ_IF_ERR),
+                .flags          = AHCI_FLAG_COMMON,
+                .link_flags     = AHCI_LFLAG_COMMON,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
         /* board_ahci_sb600 */
         {
-                .flags          = AHCI_FLAG_COMMON |
-                                  AHCI_FLAG_IGN_SERR_INTERNAL |
-                                  AHCI_FLAG_32BIT_ONLY,
+                AHCI_HFLAGS     (AHCI_HFLAG_IGN_SERR_INTERNAL |
+                                 AHCI_HFLAG_32BIT_ONLY | AHCI_HFLAG_NO_PMP),
+                .flags          = AHCI_FLAG_COMMON,
+                .link_flags     = AHCI_LFLAG_COMMON,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
         /* board_ahci_mv */
         {
-                .sht            = &ahci_sht,
+                AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_MSI |
+                                 AHCI_HFLAG_MV_PATA),
                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
-                                  ATA_FLAG_SKIP_D2H_BSY | AHCI_FLAG_HONOR_PI |
-                                  AHCI_FLAG_NO_NCQ | AHCI_FLAG_NO_MSI |
-                                  AHCI_FLAG_MV_PATA,
+                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA,
+                .link_flags     = AHCI_LFLAG_COMMON,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
@@ -394,23 +403,25 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, 0x2682), board_ahci }, /* ESB2 */
         { PCI_VDEVICE(INTEL, 0x2683), board_ahci }, /* ESB2 */
         { PCI_VDEVICE(INTEL, 0x27c6), board_ahci }, /* ICH7-M DH */
-        { PCI_VDEVICE(INTEL, 0x2821), board_ahci_pi }, /* ICH8 */
-        { PCI_VDEVICE(INTEL, 0x2822), board_ahci_pi }, /* ICH8 */
-        { PCI_VDEVICE(INTEL, 0x2824), board_ahci_pi }, /* ICH8 */
-        { PCI_VDEVICE(INTEL, 0x2829), board_ahci_pi }, /* ICH8M */
-        { PCI_VDEVICE(INTEL, 0x282a), board_ahci_pi }, /* ICH8M */
-        { PCI_VDEVICE(INTEL, 0x2922), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2923), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2924), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2925), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2927), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x2929), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x292a), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x292b), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x292c), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x292f), board_ahci_pi }, /* ICH9M */
-        { PCI_VDEVICE(INTEL, 0x294d), board_ahci_pi }, /* ICH9 */
-        { PCI_VDEVICE(INTEL, 0x294e), board_ahci_pi }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x2821), board_ahci }, /* ICH8 */
+        { PCI_VDEVICE(INTEL, 0x2822), board_ahci }, /* ICH8 */
+        { PCI_VDEVICE(INTEL, 0x2824), board_ahci }, /* ICH8 */
+        { PCI_VDEVICE(INTEL, 0x2829), board_ahci }, /* ICH8M */
+        { PCI_VDEVICE(INTEL, 0x282a), board_ahci }, /* ICH8M */
+        { PCI_VDEVICE(INTEL, 0x2922), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2923), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2924), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2925), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2927), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x2929), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x292a), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x292b), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x292c), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x292f), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x294d), board_ahci }, /* ICH9 */
+        { PCI_VDEVICE(INTEL, 0x294e), board_ahci }, /* ICH9M */
+        { PCI_VDEVICE(INTEL, 0x502a), board_ahci }, /* Tolapai */
+        { PCI_VDEVICE(INTEL, 0x502b), board_ahci }, /* Tolapai */
 
         /* JMicron 360/1/3/5/6, match class to avoid IDE function */
         { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
@@ -474,6 +485,14 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(NVIDIA, 0x0ad9), board_ahci },            /* MCP77 */
         { PCI_VDEVICE(NVIDIA, 0x0ada), board_ahci },            /* MCP77 */
         { PCI_VDEVICE(NVIDIA, 0x0adb), board_ahci },            /* MCP77 */
+        { PCI_VDEVICE(NVIDIA, 0x0ab8), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0ab9), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0aba), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abb), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abc), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abd), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abe), board_ahci },            /* MCP79 */
+        { PCI_VDEVICE(NVIDIA, 0x0abf), board_ahci },            /* MCP79 */
 
         /* SiS */
         { PCI_VDEVICE(SI, 0x1184), board_ahci }, /* SiS 966 */
@@ -524,7 +543,6 @@ static inline void __iomem *ahci_port_base(struct ata_port *ap)
 /**
  *      ahci_save_initial_config - Save and fixup initial config values
  *      @pdev: target PCI device
- *      @pi: associated ATA port info
  *      @hpriv: host private area to store config values
  *
  *      Some registers containing configuration info might be setup by
@@ -538,7 +556,6 @@ static inline void __iomem *ahci_port_base(struct ata_port *ap)
  *      None.
  */
 static void ahci_save_initial_config(struct pci_dev *pdev,
-                                     const struct ata_port_info *pi,
                                      struct ahci_host_priv *hpriv)
 {
         void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR];
@@ -552,26 +569,22 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
         hpriv->saved_port_map = port_map = readl(mmio + HOST_PORTS_IMPL);
 
         /* some chips have errata preventing 64bit use */
-        if ((cap & HOST_CAP_64) && (pi->flags & AHCI_FLAG_32BIT_ONLY)) {
+        if ((cap & HOST_CAP_64) && (hpriv->flags & AHCI_HFLAG_32BIT_ONLY)) {
                 dev_printk(KERN_INFO, &pdev->dev,
                            "controller can't do 64bit DMA, forcing 32bit\n");
                 cap &= ~HOST_CAP_64;
         }
 
-        if ((cap & HOST_CAP_NCQ) && (pi->flags & AHCI_FLAG_NO_NCQ)) {
+        if ((cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_NO_NCQ)) {
                 dev_printk(KERN_INFO, &pdev->dev,
                            "controller can't do NCQ, turning off CAP_NCQ\n");
                 cap &= ~HOST_CAP_NCQ;
         }
 
-        /* fixup zero port_map */
-        if (!port_map) {
-                port_map = (1 << ahci_nr_ports(cap)) - 1;
-                dev_printk(KERN_WARNING, &pdev->dev,
-                           "PORTS_IMPL is zero, forcing 0x%x\n", port_map);
-
-                /* write the fixed up value to the PI register */
-                hpriv->saved_port_map = port_map;
+        if ((cap && HOST_CAP_PMP) && (hpriv->flags & AHCI_HFLAG_NO_PMP)) {
+                dev_printk(KERN_INFO, &pdev->dev,
+                           "controller can't do PMP, turning off CAP_PMP\n");
+                cap &= ~HOST_CAP_PMP;
         }
 
         /*
@@ -579,7 +592,7 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
          * is asserted through the standard AHCI port
          * presence register, as bit 4 (counting from 0)
          */
-        if (pi->flags & AHCI_FLAG_MV_PATA) {
+        if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
                 dev_printk(KERN_ERR, &pdev->dev,
                            "MV_AHCI HACK: port_map %x -> %x\n",
                            hpriv->port_map,
@@ -589,7 +602,7 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
         }
 
         /* cross check port_map and cap.n_ports */
-        if (pi->flags & AHCI_FLAG_HONOR_PI) {
+        if (port_map) {
                 u32 tmp_port_map = port_map;
                 int n_ports = ahci_nr_ports(cap);
 
@@ -600,17 +613,26 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
                         }
                 }
 
-                /* Whine if inconsistent.  No need to update cap.
-                 * port_map is used to determine number of ports.
+                /* If n_ports and port_map are inconsistent, whine and
+                 * clear port_map and let it be generated from n_ports.
                  */
-                if (n_ports || tmp_port_map)
+                if (n_ports || tmp_port_map) {
                         dev_printk(KERN_WARNING, &pdev->dev,
                                    "nr_ports (%u) and implemented port map "
-                                   "(0x%x) don't match\n",
+                                   "(0x%x) don't match, using nr_ports\n",
                                    ahci_nr_ports(cap), port_map);
-        } else {
-                /* fabricate port_map from cap.nr_ports */
+                        port_map = 0;
+                }
+        }
+
+        /* fabricate port_map from cap.nr_ports */
+        if (!port_map) {
                 port_map = (1 << ahci_nr_ports(cap)) - 1;
+                dev_printk(KERN_WARNING, &pdev->dev,
+                           "forcing PORTS_IMPL to 0x%x\n", port_map);
+
+                /* write the fixed up value to the PI register */
+                hpriv->saved_port_map = port_map;
         }
 
         /* record values to use during operation */
@@ -836,8 +858,14 @@ static int ahci_reset_controller(struct ata_host *host)
         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
         u32 tmp;
 
-        /* global controller reset */
+        /* we must be in AHCI mode, before using anything
+         * AHCI-specific, such as HOST_RESET.
+         */
         tmp = readl(mmio + HOST_CTL);
+        if (!(tmp & HOST_AHCI_EN))
+                writel(tmp | HOST_AHCI_EN, mmio + HOST_CTL);
+
+        /* global controller reset */
         if ((tmp & HOST_RESET) == 0) {
                 writel(tmp | HOST_RESET, mmio + HOST_CTL);
                 readl(mmio + HOST_CTL); /* flush */
@@ -904,13 +932,14 @@ static void ahci_port_init(struct pci_dev *pdev, struct ata_port *ap,
 
 static void ahci_init_controller(struct ata_host *host)
 {
+        struct ahci_host_priv *hpriv = host->private_data;
         struct pci_dev *pdev = to_pci_dev(host->dev);
         void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
         int i;
         void __iomem *port_mmio;
         u32 tmp;
 
-        if (host->ports[0]->flags & AHCI_FLAG_MV_PATA) {
+        if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
                 port_mmio = __ahci_port_base(host, 4);
 
                 writel(0, port_mmio + PORT_IRQ_MASK);
@@ -1042,9 +1071,10 @@ static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp,
         return 0;
 }
 
-static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
+static int ahci_do_softreset(struct ata_link *link, unsigned int *class,
                              int pmp, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         const char *reason = NULL;
         unsigned long now, msecs;
         struct ata_taskfile tf;
@@ -1052,7 +1082,7 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
 
         DPRINTK("ENTER\n");
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 DPRINTK("PHY reports no device\n");
                 *class = ATA_DEV_NONE;
                 return 0;
@@ -1061,10 +1091,10 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
         /* prepare for SRST (AHCI-1.1 10.4.1) */
         rc = ahci_kick_engine(ap, 1);
         if (rc)
-                ata_port_printk(ap, KERN_WARNING,
+                ata_link_printk(link, KERN_WARNING,
                                 "failed to reset engine (errno=%d)", rc);
 
-        ata_tf_init(ap->device, &tf);
+        ata_tf_init(link->device, &tf);
 
         /* issue the first D2H Register FIS */
         msecs = 0;
@@ -1109,19 +1139,25 @@ static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
         return 0;
 
  fail:
-        ata_port_printk(ap, KERN_ERR, "softreset failed (%s)\n", reason);
+        ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason);
         return rc;
 }
 
-static int ahci_softreset(struct ata_port *ap, unsigned int *class,
+static int ahci_softreset(struct ata_link *link, unsigned int *class,
                           unsigned long deadline)
 {
-        return ahci_do_softreset(ap, class, 0, deadline);
+        int pmp = 0;
+
+        if (link->ap->flags & ATA_FLAG_PMP)
+                pmp = SATA_PMP_CTRL_PORT;
+
+        return ahci_do_softreset(link, class, pmp, deadline);
 }
 
-static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
+static int ahci_hardreset(struct ata_link *link, unsigned int *class,
                           unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct ahci_port_priv *pp = ap->private_data;
         u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
         struct ata_taskfile tf;
@@ -1132,26 +1168,27 @@ static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
         ahci_stop_engine(ap);
 
         /* clear D2H reception area to properly wait for D2H FIS */
-        ata_tf_init(ap->device, &tf);
+        ata_tf_init(link->device, &tf);
         tf.command = 0x80;
         ata_tf_to_fis(&tf, 0, 0, d2h_fis);
 
-        rc = sata_std_hardreset(ap, class, deadline);
+        rc = sata_std_hardreset(link, class, deadline);
 
         ahci_start_engine(ap);
 
-        if (rc == 0 && ata_port_online(ap))
+        if (rc == 0 && ata_link_online(link))
                 *class = ahci_dev_classify(ap);
-        if (*class == ATA_DEV_UNKNOWN)
+        if (rc != -EAGAIN && *class == ATA_DEV_UNKNOWN)
                 *class = ATA_DEV_NONE;
 
         DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class);
         return rc;
 }
 
-static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
+static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class,
                                  unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         u32 serror;
         int rc;
 
@@ -1159,7 +1196,7 @@ static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
 
         ahci_stop_engine(ap);
 
-        rc = sata_port_hardreset(ap, sata_ehc_deb_timing(&ap->eh_context),
+        rc = sata_link_hardreset(link, sata_ehc_deb_timing(&link->eh_context),
                                  deadline);
 
         /* vt8251 needs SError cleared for the port to operate */
@@ -1176,12 +1213,13 @@ static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
         return rc ?: -EAGAIN;
 }
 
-static void ahci_postreset(struct ata_port *ap, unsigned int *class)
+static void ahci_postreset(struct ata_link *link, unsigned int *class)
 {
+        struct ata_port *ap = link->ap;
         void __iomem *port_mmio = ahci_port_base(ap);
         u32 new_tmp, tmp;
 
-        ata_std_postreset(ap, class);
+        ata_std_postreset(link, class);
 
         /* Make sure port's ATAPI bit is set appropriately */
         new_tmp = tmp = readl(port_mmio + PORT_CMD);
@@ -1195,6 +1233,12 @@ static void ahci_postreset(struct ata_port *ap, unsigned int *class)
         }
 }
 
+static int ahci_pmp_softreset(struct ata_link *link, unsigned int *class,
+                              unsigned long deadline)
+{
+        return ahci_do_softreset(link, class, link->pmp, deadline);
+}
+
 static u8 ahci_check_status(struct ata_port *ap)
 {
         void __iomem *mmio = ap->ioaddr.cmd_addr;
@@ -1253,7 +1297,7 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
          */
         cmd_tbl = pp->cmd_tbl + qc->tag * AHCI_CMD_TBL_SZ;
 
-        ata_tf_to_fis(&qc->tf, 0, 1, cmd_tbl);
+        ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, cmd_tbl);
         if (is_atapi) {
                 memset(cmd_tbl + AHCI_CMD_TBL_CDB, 0, 32);
                 memcpy(cmd_tbl + AHCI_CMD_TBL_CDB, qc->cdb, qc->dev->cdb_len);
@@ -1266,7 +1310,7 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
         /*
          * Fill in command slot information.
          */
-        opts = cmd_fis_len | n_elem << 16;
+        opts = cmd_fis_len | n_elem << 16 | (qc->dev->link->pmp << 12);
         if (qc->tf.flags & ATA_TFLAG_WRITE)
                 opts |= AHCI_CMD_WRITE;
         if (is_atapi)
@@ -1277,66 +1321,87 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
 
 static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
 {
+        struct ahci_host_priv *hpriv = ap->host->private_data;
         struct ahci_port_priv *pp = ap->private_data;
-        struct ata_eh_info *ehi = &ap->eh_info;
-        unsigned int err_mask = 0, action = 0;
-        struct ata_queued_cmd *qc;
+        struct ata_eh_info *host_ehi = &ap->link.eh_info;
+        struct ata_link *link = NULL;
+        struct ata_queued_cmd *active_qc;
+        struct ata_eh_info *active_ehi;
         u32 serror;
 
-        ata_ehi_clear_desc(ehi);
+        /* determine active link */
+        ata_port_for_each_link(link, ap)
+                if (ata_link_active(link))
+                        break;
+        if (!link)
+                link = &ap->link;
+
+        active_qc = ata_qc_from_tag(ap, link->active_tag);
+        active_ehi = &link->eh_info;
+
+        /* record irq stat */
+        ata_ehi_clear_desc(host_ehi);
+        ata_ehi_push_desc(host_ehi, "irq_stat 0x%08x", irq_stat);
 
         /* AHCI needs SError cleared; otherwise, it might lock up */
         ahci_scr_read(ap, SCR_ERROR, &serror);
         ahci_scr_write(ap, SCR_ERROR, serror);
-
-        /* analyze @irq_stat */
-        ata_ehi_push_desc(ehi, "irq_stat 0x%08x", irq_stat);
+        host_ehi->serror |= serror;
 
         /* some controllers set IRQ_IF_ERR on device errors, ignore it */
-        if (ap->flags & AHCI_FLAG_IGN_IRQ_IF_ERR)
+        if (hpriv->flags & AHCI_HFLAG_IGN_IRQ_IF_ERR)
                 irq_stat &= ~PORT_IRQ_IF_ERR;
 
         if (irq_stat & PORT_IRQ_TF_ERR) {
-                err_mask |= AC_ERR_DEV;
-                if (ap->flags & AHCI_FLAG_IGN_SERR_INTERNAL)
-                        serror &= ~SERR_INTERNAL;
+                /* If qc is active, charge it; otherwise, the active
+                 * link.  There's no active qc on NCQ errors.  It will
+                 * be determined by EH by reading log page 10h.
+                 */
+                if (active_qc)
+                        active_qc->err_mask |= AC_ERR_DEV;
+                else
+                        active_ehi->err_mask |= AC_ERR_DEV;
+
+                if (hpriv->flags & AHCI_HFLAG_IGN_SERR_INTERNAL)
+                        host_ehi->serror &= ~SERR_INTERNAL;
+        }
+
+        if (irq_stat & PORT_IRQ_UNK_FIS) {
+                u32 *unk = (u32 *)(pp->rx_fis + RX_FIS_UNK);
+
+                active_ehi->err_mask |= AC_ERR_HSM;
+                active_ehi->action |= ATA_EH_SOFTRESET;
+                ata_ehi_push_desc(active_ehi,
+                                  "unknown FIS %08x %08x %08x %08x" ,
+                                  unk[0], unk[1], unk[2], unk[3]);
+        }
+
+        if (ap->nr_pmp_links && (irq_stat & PORT_IRQ_BAD_PMP)) {
+                active_ehi->err_mask |= AC_ERR_HSM;
+                active_ehi->action |= ATA_EH_SOFTRESET;
+                ata_ehi_push_desc(active_ehi, "incorrect PMP");
         }
 
         if (irq_stat & (PORT_IRQ_HBUS_ERR | PORT_IRQ_HBUS_DATA_ERR)) {
-                err_mask |= AC_ERR_HOST_BUS;
-                action |= ATA_EH_SOFTRESET;
+                host_ehi->err_mask |= AC_ERR_HOST_BUS;
+                host_ehi->action |= ATA_EH_SOFTRESET;
+                ata_ehi_push_desc(host_ehi, "host bus error");
         }
 
         if (irq_stat & PORT_IRQ_IF_ERR) {
-                err_mask |= AC_ERR_ATA_BUS;
-                action |= ATA_EH_SOFTRESET;
-                ata_ehi_push_desc(ehi, "interface fatal error");
+                host_ehi->err_mask |= AC_ERR_ATA_BUS;
+                host_ehi->action |= ATA_EH_SOFTRESET;
+                ata_ehi_push_desc(host_ehi, "interface fatal error");
         }
 
         if (irq_stat & (PORT_IRQ_CONNECT | PORT_IRQ_PHYRDY)) {
-                ata_ehi_hotplugged(ehi);
-                ata_ehi_push_desc(ehi, "%s", irq_stat & PORT_IRQ_CONNECT ?
+                ata_ehi_hotplugged(host_ehi);
+                ata_ehi_push_desc(host_ehi, "%s",
+                        irq_stat & PORT_IRQ_CONNECT ?
                         "connection status changed" : "PHY RDY changed");
         }
 
-        if (irq_stat & PORT_IRQ_UNK_FIS) {
-                u32 *unk = (u32 *)(pp->rx_fis + RX_FIS_UNK);
-
-                err_mask |= AC_ERR_HSM;
-                action |= ATA_EH_SOFTRESET;
-                ata_ehi_push_desc(ehi, "unknown FIS %08x %08x %08x %08x",
-                                  unk[0], unk[1], unk[2], unk[3]);
-        }
-
         /* okay, let's hand over to EH */
-        ehi->serror |= serror;
-        ehi->action |= action;
-
-        qc = ata_qc_from_tag(ap, ap->active_tag);
-        if (qc)
-                qc->err_mask |= err_mask;
-        else
-                ehi->err_mask |= err_mask;
 
         if (irq_stat & PORT_IRQ_FREEZE)
                 ata_port_freeze(ap);
@@ -1347,25 +1412,64 @@ static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
 static void ahci_port_intr(struct ata_port *ap)
 {
         void __iomem *port_mmio = ap->ioaddr.cmd_addr;
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
         struct ahci_port_priv *pp = ap->private_data;
+        struct ahci_host_priv *hpriv = ap->host->private_data;
+        int resetting = !!(ap->pflags & ATA_PFLAG_RESETTING);
         u32 status, qc_active;
         int rc, known_irq = 0;
 
         status = readl(port_mmio + PORT_IRQ_STAT);
         writel(status, port_mmio + PORT_IRQ_STAT);
 
+        /* ignore BAD_PMP while resetting */
+        if (unlikely(resetting))
+                status &= ~PORT_IRQ_BAD_PMP;
+
         if (unlikely(status & PORT_IRQ_ERROR)) {
                 ahci_error_intr(ap, status);
                 return;
         }
 
-        if (ap->sactive)
+        if (status & PORT_IRQ_SDB_FIS) {
+                /* If SNotification is available, leave notification
+                 * handling to sata_async_notification().  If not,
+                 * emulate it by snooping SDB FIS RX area.
+                 *
+                 * Snooping FIS RX area is probably cheaper than
+                 * poking SNotification but some constrollers which
+                 * implement SNotification, ICH9 for example, don't
+                 * store AN SDB FIS into receive area.
+                 */
+                if (hpriv->cap & HOST_CAP_SNTF)
+                        sata_async_notification(ap);
+                else {
+                        /* If the 'N' bit in word 0 of the FIS is set,
+                         * we just received asynchronous notification.
+                         * Tell libata about it.
+                         */
+                        const __le32 *f = pp->rx_fis + RX_FIS_SDB;
+                        u32 f0 = le32_to_cpu(f[0]);
+
+                        if (f0 & (1 << 15))
+                                sata_async_notification(ap);
+                }
+        }
+
+        /* pp->active_link is valid iff any command is in flight */
+        if (ap->qc_active && pp->active_link->sactive)
                 qc_active = readl(port_mmio + PORT_SCR_ACT);
         else
                 qc_active = readl(port_mmio + PORT_CMD_ISSUE);
 
         rc = ata_qc_complete_multiple(ap, qc_active, NULL);
+
+        /* If resetting, spurious or invalid completions are expected,
+         * return unconditionally.
+         */
+        if (resetting)
+                return;
+
         if (rc > 0)
                 return;
         if (rc < 0) {
@@ -1380,7 +1484,7 @@ static void ahci_port_intr(struct ata_port *ap)
         /* if !NCQ, ignore.  No modern ATA device has broken HSM
          * implementation for non-NCQ commands.
          */
-        if (!ap->sactive)
+        if (!ap->link.sactive)
                 return;
 
         if (status & PORT_IRQ_D2H_REG_FIS) {
@@ -1433,7 +1537,7 @@ static void ahci_port_intr(struct ata_port *ap)
         if (!known_irq)
                 ata_port_printk(ap, KERN_INFO, "spurious interrupt "
                                 "(irq_stat 0x%x active_tag 0x%x sactive 0x%x)\n",
-                                status, ap->active_tag, ap->sactive);
+                                status, ap->link.active_tag, ap->link.sactive);
 }
 
 static void ahci_irq_clear(struct ata_port *ap)
@@ -1498,6 +1602,13 @@ static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
         void __iomem *port_mmio = ahci_port_base(ap);
+        struct ahci_port_priv *pp = ap->private_data;
+
+        /* Keep track of the currently active link.  It will be used
+         * in completion path to determine whether NCQ phase is in
+         * progress.
+         */
+        pp->active_link = qc->dev->link;
 
         if (qc->tf.protocol == ATA_PROT_NCQ)
                 writel(1 << qc->tag, port_mmio + PORT_SCR_ACT);
@@ -1520,6 +1631,7 @@ static void ahci_thaw(struct ata_port *ap)
         void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR];
         void __iomem *port_mmio = ahci_port_base(ap);
         u32 tmp;
+        struct ahci_port_priv *pp = ap->private_data;
 
         /* clear IRQ */
         tmp = readl(port_mmio + PORT_IRQ_STAT);
@@ -1527,7 +1639,7 @@ static void ahci_thaw(struct ata_port *ap)
         writel(1 << ap->port_no, mmio + HOST_IRQ_STAT);
 
         /* turn IRQ back on */
-        writel(DEF_PORT_IRQ, port_mmio + PORT_IRQ_MASK);
+        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
 }
 
 static void ahci_error_handler(struct ata_port *ap)
@@ -1539,8 +1651,10 @@ static void ahci_error_handler(struct ata_port *ap)
         }
 
         /* perform recovery */
-        ata_do_eh(ap, ata_std_prereset, ahci_softreset, ahci_hardreset,
-                  ahci_postreset);
+        sata_pmp_do_eh(ap, ata_std_prereset, ahci_softreset,
+                       ahci_hardreset, ahci_postreset,
+                       sata_pmp_std_prereset, ahci_pmp_softreset,
+                       sata_pmp_std_hardreset, sata_pmp_std_postreset);
 }
 
 static void ahci_vt8251_error_handler(struct ata_port *ap)
@@ -1565,11 +1679,44 @@ static void ahci_post_internal_cmd(struct ata_queued_cmd *qc)
                 ahci_kick_engine(ap, 1);
 }
 
+static void ahci_pmp_attach(struct ata_port *ap)
+{
+        void __iomem *port_mmio = ahci_port_base(ap);
+        struct ahci_port_priv *pp = ap->private_data;
+        u32 cmd;
+
+        cmd = readl(port_mmio + PORT_CMD);
+        cmd |= PORT_CMD_PMP;
+        writel(cmd, port_mmio + PORT_CMD);
+
+        pp->intr_mask |= PORT_IRQ_BAD_PMP;
+        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
+}
+
+static void ahci_pmp_detach(struct ata_port *ap)
+{
+        void __iomem *port_mmio = ahci_port_base(ap);
+        struct ahci_port_priv *pp = ap->private_data;
+        u32 cmd;
+
+        cmd = readl(port_mmio + PORT_CMD);
+        cmd &= ~PORT_CMD_PMP;
+        writel(cmd, port_mmio + PORT_CMD);
+
+        pp->intr_mask &= ~PORT_IRQ_BAD_PMP;
+        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
+}
+
 static int ahci_port_resume(struct ata_port *ap)
 {
         ahci_power_up(ap);
         ahci_start_port(ap);
 
+        if (ap->nr_pmp_links)
+                ahci_pmp_attach(ap);
+        else
+                ahci_pmp_detach(ap);
+
         return 0;
 }
 
@@ -1681,6 +1828,12 @@ static int ahci_port_start(struct ata_port *ap)
         pp->cmd_tbl = mem;
         pp->cmd_tbl_dma = mem_dma;
 
+        /*
+         * Save off initial list of interrupts to be enabled.
+         * This could be changed later
+         */
+        pp->intr_mask = DEF_PORT_IRQ;
+
         ap->private_data = pp;
 
         /* engage engines, captain */
@@ -1830,20 +1983,24 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc)
                 return rc;
 
-        if ((pi.flags & AHCI_FLAG_NO_MSI) || pci_enable_msi(pdev))
-                pci_intx(pdev, 1);
-
         hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
         if (!hpriv)
                 return -ENOMEM;
+        hpriv->flags |= (unsigned long)pi.private_data;
+
+        if ((hpriv->flags & AHCI_HFLAG_NO_MSI) || pci_enable_msi(pdev))
+                pci_intx(pdev, 1);
 
         /* save initial config */
-        ahci_save_initial_config(pdev, &pi, hpriv);
+        ahci_save_initial_config(pdev, hpriv);
 
         /* prepare host */
         if (hpriv->cap & HOST_CAP_NCQ)
                 pi.flags |= ATA_FLAG_NCQ;
 
+        if (hpriv->cap & HOST_CAP_PMP)
+                pi.flags |= ATA_FLAG_PMP;
+
         host = ata_host_alloc_pinfo(&pdev->dev, ppi, fls(hpriv->port_map));
         if (!host)
                 return -ENOMEM;
@@ -1854,6 +2011,10 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 struct ata_port *ap = host->ports[i];
                 void __iomem *port_mmio = ahci_port_base(ap);
 
+                ata_port_pbar_desc(ap, AHCI_PCI_BAR, -1, "abar");
+                ata_port_pbar_desc(ap, AHCI_PCI_BAR,
+                                   0x100 + ap->port_no * 0x80, "port");
+
                 /* standard SATA port setup */
                 if (hpriv->port_map & (1 << i))
                         ap->ioaddr.cmd_addr = port_mmio;
diff --git a/drivers/ata/ata_generic.c b/drivers/ata/ata_generic.c
index 945466954724..90329982bef7 100644
--- a/drivers/ata/ata_generic.c
+++ b/drivers/ata/ata_generic.c
@@ -34,7 +34,7 @@
 
 /**
  *      generic_set_mode        -       mode setting
- *      @ap: interface to set up
+ *      @link: link to set up
  *      @unused: returned device on error
  *
  *      Use a non standard set_mode function. We don't want to be tuned.
@@ -43,24 +43,24 @@
  *      and respect them.
  */
 
-static int generic_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int generic_set_mode(struct ata_link *link, struct ata_device **unused)
 {
+        struct ata_port *ap = link->ap;
         int dma_enabled = 0;
-        int i;
+        struct ata_device *dev;
 
         /* Bits 5 and 6 indicate if DMA is active on master/slave */
         if (ap->ioaddr.bmdma_addr)
                 dma_enabled = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         /* We don't really care */
                         dev->pio_mode = XFER_PIO_0;
                         dev->dma_mode = XFER_MW_DMA_0;
                         /* We do need the right mode information for DMA or PIO
                            and this comes from the current configuration flags */
-                        if (dma_enabled & (1 << (5 + i))) {
+                        if (dma_enabled & (1 << (5 + dev->devno))) {
                                 ata_id_to_dma_mode(dev, XFER_MW_DMA_0);
                                 dev->flags &= ~ATA_DFLAG_PIO;
                         } else {
@@ -95,7 +95,6 @@ static struct scsi_host_template generic_sht = {
 static struct ata_port_operations generic_port_ops = {
         .set_mode       = generic_set_mode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -121,9 +120,8 @@ static struct ata_port_operations generic_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int all_generic_ide;             /* Set to claim all devices */
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index 92c2d5082bef..e783e678acf5 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -123,7 +123,6 @@ enum {
         ich_pata_33             = 1,    /* ICH up to UDMA 33 only */
         ich_pata_66             = 2,    /* ICH up to 66 Mhz */
         ich_pata_100            = 3,    /* ICH up to UDMA 100 */
-        ich_pata_133            = 4,    /* ICH up to UDMA 133 */
         ich5_sata               = 5,
         ich6_sata               = 6,
         ich6_sata_ahci          = 7,
@@ -199,7 +198,7 @@ static const struct pci_device_id piix_pci_tbl[] = {
         { 0x8086, 0x24CA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         { 0x8086, 0x24CB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* Intel ICH5 */
-        { 0x8086, 0x24DB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_133 },
+        { 0x8086, 0x24DB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* C-ICH (i810E2) */
         { 0x8086, 0x245B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* ESB (855GME/875P + 6300ESB) UDMA 100  */
@@ -207,7 +206,7 @@ static const struct pci_device_id piix_pci_tbl[] = {
         /* ICH6 (and 6) (i915) UDMA 100 */
         { 0x8086, 0x266F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* ICH7/7-R (i945, i975) UDMA 100*/
-        { 0x8086, 0x27DF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_133 },
+        { 0x8086, 0x27DF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         { 0x8086, 0x269E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* ICH8 Mobile PATA Controller */
         { 0x8086, 0x2850, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
@@ -290,7 +289,6 @@ static struct scsi_host_template piix_sht = {
 };
 
 static const struct ata_port_operations piix_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = piix_set_piomode,
         .set_dmamode            = piix_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -318,13 +316,11 @@ static const struct ata_port_operations piix_pata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations ich_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = piix_set_piomode,
         .set_dmamode            = ich_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -352,14 +348,11 @@ static const struct ata_port_operations ich_pata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations piix_sata_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -382,7 +375,6 @@ static const struct ata_port_operations piix_sata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
@@ -445,15 +437,15 @@ static const struct piix_map_db ich8_map_db = {
 };
 
 static const struct piix_map_db tolapai_map_db = {
-        .mask = 0x3,
-        .port_enable = 0x3,
-        .map = {
-                /* PM   PS   SM   SS       MAP */
-                {  P0,  NA,  P1,  NA }, /* 00b */
-                {  RV,  RV,  RV,  RV }, /* 01b */
-                {  RV,  RV,  RV,  RV }, /* 10b */
-                {  RV,  RV,  RV,  RV },
-        },
+        .mask = 0x3,
+        .port_enable = 0x3,
+        .map = {
+                /* PM   PS   SM   SS       MAP */
+                {  P0,  NA,  P1,  NA }, /* 00b */
+                {  RV,  RV,  RV,  RV }, /* 01b */
+                {  RV,  RV,  RV,  RV }, /* 10b */
+                {  RV,  RV,  RV,  RV },
+        },
 };
 
 static const struct piix_map_db *piix_map_db_table[] = {
@@ -466,7 +458,7 @@ static const struct piix_map_db *piix_map_db_table[] = {
 };
 
 static struct ata_port_info piix_port_info[] = {
-        /* piix_pata_33: 0:  PIIX4 at 33MHz */
+        [piix_pata_33] =        /* PIIX4 at 33MHz */
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS,
@@ -476,7 +468,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_pata_ops,
         },
 
-        /* ich_pata_33: 1       ICH0 - ICH at 33Mhz*/
+        [ich_pata_33] =         /* ICH0 - ICH at 33Mhz*/
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS,
@@ -485,7 +477,8 @@ static struct ata_port_info piix_port_info[] = {
                 .udma_mask      = ATA_UDMA2, /* UDMA33 */
                 .port_ops       = &ich_pata_ops,
         },
-        /* ich_pata_66: 2       ICH controllers up to 66MHz */
+
+        [ich_pata_66] =         /* ICH controllers up to 66MHz */
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS,
@@ -495,7 +488,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &ich_pata_ops,
         },
 
-        /* ich_pata_100: 3 */
+        [ich_pata_100] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,
@@ -505,17 +498,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &ich_pata_ops,
         },
 
-        /* ich_pata_133: 4      ICH with full UDMA6 */
-        {
-                .sht            = &piix_sht,
-                .flags          = PIIX_PATA_FLAGS | PIIX_FLAG_CHECKINTR,
-                .pio_mask       = 0x1f, /* pio 0-4 */
-                .mwdma_mask     = 0x06, /* Check: maybe 0x07  */
-                .udma_mask      = ATA_UDMA6, /* UDMA133 */
-                .port_ops       = &ich_pata_ops,
-        },
-
-        /* ich5_sata: 5 */
+        [ich5_sata] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS,
@@ -525,7 +508,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* ich6_sata: 6 */
+        [ich6_sata] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR,
@@ -535,7 +518,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* ich6_sata_ahci: 7 */
+        [ich6_sata_ahci] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR |
@@ -546,7 +529,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* ich6m_sata_ahci: 8 */
+        [ich6m_sata_ahci] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR |
@@ -557,7 +540,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* ich8_sata_ahci: 9 */
+        [ich8_sata_ahci] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR |
@@ -568,7 +551,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_sata_ops,
         },
 
-        /* piix_pata_mwdma: 10:  PIIX3 MWDMA only */
+        [piix_pata_mwdma] =     /* PIIX3 MWDMA only */
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_PATA_FLAGS,
@@ -577,7 +560,7 @@ static struct ata_port_info piix_port_info[] = {
                 .port_ops       = &piix_pata_ops,
         },
 
-        /* tolapai_sata_ahci: 11: */
+        [tolapai_sata_ahci] =
         {
                 .sht            = &piix_sht,
                 .flags          = PIIX_SATA_FLAGS | PIIX_FLAG_SCR |
@@ -615,6 +598,7 @@ static const struct ich_laptop ich_laptop[] = {
         { 0x27DF, 0x0005, 0x0280 },     /* ICH7 on Acer 5602WLMi */
         { 0x27DF, 0x1025, 0x0110 },     /* ICH7 on Acer 3682WLMi */
         { 0x27DF, 0x1043, 0x1267 },     /* ICH7 on Asus W5F */
+        { 0x27DF, 0x103C, 0x30A1 },     /* ICH7 on HP Compaq nc2400 */
         { 0x24CA, 0x1025, 0x0061 },     /* ICH4 on ACER Aspire 2023WLMi */
         /* end marker */
         { 0, }
@@ -657,19 +641,20 @@ static int ich_pata_cable_detect(struct ata_port *ap)
 
 /**
  *      piix_pata_prereset - prereset for PATA host controller
- *      @ap: Target port
+ *      @link: Target link
  *      @deadline: deadline jiffies for the operation
  *
  *      LOCKING:
  *      None (inherited from caller).
  */
-static int piix_pata_prereset(struct ata_port *ap, unsigned long deadline)
+static int piix_pata_prereset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &piix_enable_bits[ap->port_no]))
                 return -ENOENT;
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static void piix_pata_error_handler(struct ata_port *ap)
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index c059f78ad944..3f7533589041 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -14,6 +14,7 @@
 #include <linux/acpi.h>
 #include <linux/libata.h>
 #include <linux/pci.h>
+#include <scsi/scsi_device.h>
 #include "libata.h"
 
 #include <acpi/acpi_bus.h>
@@ -40,11 +41,40 @@ static int is_pci_dev(struct device *dev)
         return (dev->bus == &pci_bus_type);
 }
 
-static void ata_acpi_associate_sata_port(struct ata_port *ap)
+/**
+ * ata_acpi_associate_sata_port - associate SATA port with ACPI objects
+ * @ap: target SATA port
+ *
+ * Look up ACPI objects associated with @ap and initialize acpi_handle
+ * fields of @ap, the port and devices accordingly.
+ *
+ * LOCKING:
+ * EH context.
+ *
+ * RETURNS:
+ * 0 on success, -errno on failure.
+ */
+void ata_acpi_associate_sata_port(struct ata_port *ap)
 {
-        acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
+        WARN_ON(!(ap->flags & ATA_FLAG_ACPI_SATA));
+
+        if (!ap->nr_pmp_links) {
+                acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
+
+                ap->link.device->acpi_handle =
+                        acpi_get_child(ap->host->acpi_handle, adr);
+        } else {
+                struct ata_link *link;
+
+                ap->link.device->acpi_handle = NULL;
 
-        ap->device->acpi_handle = acpi_get_child(ap->host->acpi_handle, adr);
+                ata_port_for_each_link(link, ap) {
+                        acpi_integer adr = SATA_ADR(ap->port_no, link->pmp);
+
+                        link->device->acpi_handle =
+                                acpi_get_child(ap->host->acpi_handle, adr);
+                }
+        }
 }
 
 static void ata_acpi_associate_ide_port(struct ata_port *ap)
@@ -60,12 +90,53 @@ static void ata_acpi_associate_ide_port(struct ata_port *ap)
                 max_devices++;
 
         for (i = 0; i < max_devices; i++) {
-                struct ata_device *dev = &ap->device[i];
+                struct ata_device *dev = &ap->link.device[i];
 
                 dev->acpi_handle = acpi_get_child(ap->acpi_handle, i);
         }
 }
 
+static void ata_acpi_handle_hotplug (struct ata_port *ap, struct kobject *kobj,
+                                     u32 event)
+{
+        char event_string[12];
+        char *envp[] = { event_string, NULL };
+        struct ata_eh_info *ehi = &ap->link.eh_info;
+
+        if (event == 0 || event == 1) {
+               unsigned long flags;
+               spin_lock_irqsave(ap->lock, flags);
+               ata_ehi_clear_desc(ehi);
+               ata_ehi_push_desc(ehi, "ACPI event");
+               ata_ehi_hotplugged(ehi);
+               ata_port_freeze(ap);
+               spin_unlock_irqrestore(ap->lock, flags);
+        }
+
+        if (kobj) {
+                sprintf(event_string, "BAY_EVENT=%d", event);
+                kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
+        }
+}
+
+static void ata_acpi_dev_notify(acpi_handle handle, u32 event, void *data)
+{
+        struct ata_device *dev = data;
+        struct kobject *kobj = NULL;
+
+        if (dev->sdev)
+                kobj = &dev->sdev->sdev_gendev.kobj;
+
+        ata_acpi_handle_hotplug (dev->link->ap, kobj, event);
+}
+
+static void ata_acpi_ap_notify(acpi_handle handle, u32 event, void *data)
+{
+        struct ata_port *ap = data;
+
+        ata_acpi_handle_hotplug (ap, &ap->dev->kobj, event);
+}
+
 /**
  * ata_acpi_associate - associate ATA host with ACPI objects
  * @host: target ATA host
@@ -81,7 +152,7 @@ static void ata_acpi_associate_ide_port(struct ata_port *ap)
  */
 void ata_acpi_associate(struct ata_host *host)
 {
-        int i;
+        int i, j;
 
         if (!is_pci_dev(host->dev) || libata_noacpi)
                 return;
@@ -97,6 +168,22 @@ void ata_acpi_associate(struct ata_host *host)
                         ata_acpi_associate_sata_port(ap);
                 else
                         ata_acpi_associate_ide_port(ap);
+
+                if (ap->acpi_handle)
+                        acpi_install_notify_handler (ap->acpi_handle,
+                                                     ACPI_SYSTEM_NOTIFY,
+                                                     ata_acpi_ap_notify,
+                                                     ap);
+
+                for (j = 0; j < ata_link_max_devices(&ap->link); j++) {
+                        struct ata_device *dev = &ap->link.device[j];
+
+                        if (dev->acpi_handle)
+                                acpi_install_notify_handler (dev->acpi_handle,
+                                                             ACPI_SYSTEM_NOTIFY,
+                                                             ata_acpi_dev_notify,
+                                                             dev);
+                }
         }
 }
 
@@ -113,7 +200,7 @@ void ata_acpi_associate(struct ata_host *host)
  * RETURNS:
  * 0 on success, -ENOENT if _GTM doesn't exist, -errno on failure.
  */
-static int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
+int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
 {
         struct acpi_buffer output = { .length = ACPI_ALLOCATE_BUFFER };
         union acpi_object *out_obj;
@@ -157,6 +244,8 @@ static int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
         return rc;
 }
 
+EXPORT_SYMBOL_GPL(ata_acpi_gtm);
+
 /**
  * ata_acpi_stm - execute _STM
  * @ap: target ATA port
@@ -170,7 +259,7 @@ static int ata_acpi_gtm(const struct ata_port *ap, struct ata_acpi_gtm *gtm)
  * RETURNS:
  * 0 on success, -ENOENT if _STM doesn't exist, -errno on failure.
  */
-static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
+int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
 {
         acpi_status status;
         struct acpi_object_list         input;
@@ -182,10 +271,10 @@ static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
         /* Buffers for id may need byteswapping ? */
         in_params[1].type = ACPI_TYPE_BUFFER;
         in_params[1].buffer.length = 512;
-        in_params[1].buffer.pointer = (u8 *)ap->device[0].id;
+        in_params[1].buffer.pointer = (u8 *)ap->link.device[0].id;
         in_params[2].type = ACPI_TYPE_BUFFER;
         in_params[2].buffer.length = 512;
-        in_params[2].buffer.pointer = (u8 *)ap->device[1].id;
+        in_params[2].buffer.pointer = (u8 *)ap->link.device[1].id;
 
         input.count = 3;
         input.pointer = in_params;
@@ -202,6 +291,8 @@ static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
         return 0;
 }
 
+EXPORT_SYMBOL_GPL(ata_acpi_stm);
+
 /**
  * ata_dev_get_GTF - get the drive bootup default taskfile settings
  * @dev: target ATA device
@@ -226,7 +317,7 @@ static int ata_acpi_stm(const struct ata_port *ap, struct ata_acpi_gtm *stm)
 static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
                            void **ptr_to_free)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         acpi_status status;
         struct acpi_buffer output;
         union acpi_object *out_obj;
@@ -296,6 +387,44 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
 }
 
 /**
+ * ata_acpi_cbl_80wire          -       Check for 80 wire cable
+ * @ap: Port to check
+ *
+ * Return 1 if the ACPI mode data for this port indicates the BIOS selected
+ * an 80wire mode.
+ */
+
+int ata_acpi_cbl_80wire(struct ata_port *ap)
+{
+        struct ata_acpi_gtm gtm;
+        int valid = 0;
+        
+        /* No _GTM data, no information */
+        if (ata_acpi_gtm(ap, &gtm) < 0)
+                return 0;
+                
+        /* Split timing, DMA enabled */
+        if ((gtm.flags & 0x11) == 0x11 && gtm.drive[0].dma < 55)
+                valid |= 1;
+        if ((gtm.flags & 0x14) == 0x14 && gtm.drive[1].dma < 55)
+                valid |= 2;
+        /* Shared timing, DMA enabled */
+        if ((gtm.flags & 0x11) == 0x01 && gtm.drive[0].dma < 55)
+                valid |= 1;
+        if ((gtm.flags & 0x14) == 0x04 && gtm.drive[0].dma < 55)
+                valid |= 2;
+
+        /* Drive check */
+        if ((valid & 1) && ata_dev_enabled(&ap->link.device[0]))
+                return 1;
+        if ((valid & 2) && ata_dev_enabled(&ap->link.device[1]))
+                return 1;
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(ata_acpi_cbl_80wire);
+
+/**
  * taskfile_load_raw - send taskfile registers to host controller
  * @dev: target ATA device
  * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
@@ -320,7 +449,7 @@ static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
 static int taskfile_load_raw(struct ata_device *dev,
                               const struct ata_acpi_gtf *gtf)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         struct ata_taskfile tf, rtf;
         unsigned int err_mask;
 
@@ -349,7 +478,7 @@ static int taskfile_load_raw(struct ata_device *dev,
                                tf.lbal, tf.lbam, tf.lbah, tf.device);
 
         rtf = tf;
-        err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0);
+        err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0, 0);
         if (err_mask) {
                 ata_dev_printk(dev, KERN_ERR,
                         "ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed "
@@ -424,7 +553,7 @@ static int ata_acpi_exec_tfs(struct ata_device *dev)
  */
 static int ata_acpi_push_id(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         int err;
         acpi_status status;
         struct acpi_object_list input;
@@ -508,7 +637,7 @@ int ata_acpi_on_suspend(struct ata_port *ap)
  */
 void ata_acpi_on_resume(struct ata_port *ap)
 {
-        int i;
+        struct ata_device *dev;
 
         if (ap->acpi_handle && (ap->pflags & ATA_PFLAG_GTM_VALID)) {
                 BUG_ON(ap->flags & ATA_FLAG_ACPI_SATA);
@@ -518,8 +647,8 @@ void ata_acpi_on_resume(struct ata_port *ap)
         }
 
         /* schedule _GTF */
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ap->device[i].flags |= ATA_DFLAG_ACPI_PENDING;
+        ata_link_for_each_dev(dev, &ap->link)
+                dev->flags |= ATA_DFLAG_ACPI_PENDING;
 }
 
 /**
@@ -538,8 +667,8 @@ void ata_acpi_on_resume(struct ata_port *ap)
  */
 int ata_acpi_on_devcfg(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = dev->link->ap;
+        struct ata_eh_context *ehc = &ap->link.eh_context;
         int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
         int rc;
 
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 772be09b4689..b05384a8c326 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -59,8 +59,6 @@
 
 #include "libata.h"
 
-#define DRV_VERSION     "2.21"  /* must be exactly four chars */
-
 
 /* debounce timing parameters in msecs { interval, duration, timeout } */
 const unsigned long sata_deb_timing_normal[]            = {   5,  100, 2000 };
@@ -70,6 +68,7 @@ const unsigned long sata_deb_timing_long[]		= { 100, 2000, 5000 };
 static unsigned int ata_dev_init_params(struct ata_device *dev,
                                         u16 heads, u16 sectors);
 static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
+static unsigned int ata_dev_set_AN(struct ata_device *dev, u8 enable);
 static void ata_dev_xfermask(struct ata_device *dev);
 static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
 
@@ -86,6 +85,10 @@ int atapi_dmadir = 0;
 module_param(atapi_dmadir, int, 0444);
 MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
 
+int atapi_passthru16 = 1;
+module_param(atapi_passthru16, int, 0444);
+MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)");
+
 int libata_fua = 0;
 module_param_named(fua, libata_fua, int, 0444);
 MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
@@ -94,13 +97,17 @@ static int ata_ignore_hpa = 0;
 module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
 MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");
 
+static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA;
+module_param_named(dma, libata_dma_mask, int, 0444);
+MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");
+
 static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ;
 module_param(ata_probe_timeout, int, 0444);
 MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
 
-int libata_noacpi = 1;
+int libata_noacpi = 0;
 module_param_named(noacpi, libata_noacpi, int, 0444);
-MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in suspend/resume when set");
+MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set");
 
 MODULE_AUTHOR("Jeff Garzik");
 MODULE_DESCRIPTION("Library module for ATA devices");
@@ -235,7 +242,7 @@ static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev)
         if (dev->flags & ATA_DFLAG_PIO) {
                 tf->protocol = ATA_PROT_PIO;
                 index = dev->multi_count ? 0 : 8;
-        } else if (lba48 && (dev->ap->flags & ATA_FLAG_PIO_LBA48)) {
+        } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
                 /* Unable to use DMA due to host limitation */
                 tf->protocol = ATA_PROT_PIO;
                 index = dev->multi_count ? 0 : 8;
@@ -604,7 +611,7 @@ static const char *sata_spd_string(unsigned int spd)
 void ata_dev_disable(struct ata_device *dev)
 {
         if (ata_dev_enabled(dev)) {
-                if (ata_msg_drv(dev->ap))
+                if (ata_msg_drv(dev->link->ap))
                         ata_dev_printk(dev, KERN_WARNING, "disabled\n");
                 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 |
                                              ATA_DNXFER_QUIET);
@@ -667,37 +674,57 @@ static unsigned int ata_devchk(struct ata_port *ap, unsigned int device)
  *      None.
  *
  *      RETURNS:
- *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
- *      the event of failure.
+ *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP or
+ *      %ATA_DEV_UNKNOWN the event of failure.
  */
-
 unsigned int ata_dev_classify(const struct ata_taskfile *tf)
 {
         /* Apple's open source Darwin code hints that some devices only
          * put a proper signature into the LBA mid/high registers,
          * So, we only check those.  It's sufficient for uniqueness.
+         *
+         * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate
+         * signatures for ATA and ATAPI devices attached on SerialATA,
+         * 0x3c/0xc3 and 0x69/0x96 respectively.  However, SerialATA
+         * spec has never mentioned about using different signatures
+         * for ATA/ATAPI devices.  Then, Serial ATA II: Port
+         * Multiplier specification began to use 0x69/0x96 to identify
+         * port multpliers and 0x3c/0xc3 to identify SEMB device.
+         * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and
+         * 0x69/0x96 shortly and described them as reserved for
+         * SerialATA.
+         *
+         * We follow the current spec and consider that 0x69/0x96
+         * identifies a port multiplier and 0x3c/0xc3 a SEMB device.
          */
-
-        if (((tf->lbam == 0) && (tf->lbah == 0)) ||
-            ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
+        if ((tf->lbam == 0) && (tf->lbah == 0)) {
                 DPRINTK("found ATA device by sig\n");
                 return ATA_DEV_ATA;
         }
 
-        if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
-            ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
+        if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) {
                 DPRINTK("found ATAPI device by sig\n");
                 return ATA_DEV_ATAPI;
         }
 
+        if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) {
+                DPRINTK("found PMP device by sig\n");
+                return ATA_DEV_PMP;
+        }
+
+        if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
+                printk("ata: SEMB device ignored\n");
+                return ATA_DEV_SEMB_UNSUP; /* not yet */
+        }
+
         DPRINTK("unknown device\n");
         return ATA_DEV_UNKNOWN;
 }
 
 /**
  *      ata_dev_try_classify - Parse returned ATA device signature
- *      @ap: ATA channel to examine
- *      @device: Device to examine (starting at zero)
+ *      @dev: ATA device to classify (starting at zero)
+ *      @present: device seems present
  *      @r_err: Value of error register on completion
  *
  *      After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
@@ -715,15 +742,15 @@ unsigned int ata_dev_classify(const struct ata_taskfile *tf)
  *      RETURNS:
  *      Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
  */
-
-unsigned int
-ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
+unsigned int ata_dev_try_classify(struct ata_device *dev, int present,
+                                  u8 *r_err)
 {
+        struct ata_port *ap = dev->link->ap;
         struct ata_taskfile tf;
         unsigned int class;
         u8 err;
 
-        ap->ops->dev_select(ap, device);
+        ap->ops->dev_select(ap, dev->devno);
 
         memset(&tf, 0, sizeof(tf));
 
@@ -733,12 +760,12 @@ ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
                 *r_err = err;
 
         /* see if device passed diags: if master then continue and warn later */
-        if (err == 0 && device == 0)
+        if (err == 0 && dev->devno == 0)
                 /* diagnostic fail : do nothing _YET_ */
-                ap->device[device].horkage |= ATA_HORKAGE_DIAGNOSTIC;
+                dev->horkage |= ATA_HORKAGE_DIAGNOSTIC;
         else if (err == 1)
                 /* do nothing */ ;
-        else if ((device == 0) && (err == 0x81))
+        else if ((dev->devno == 0) && (err == 0x81))
                 /* do nothing */ ;
         else
                 return ATA_DEV_NONE;
@@ -746,10 +773,20 @@ ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
         /* determine if device is ATA or ATAPI */
         class = ata_dev_classify(&tf);
 
-        if (class == ATA_DEV_UNKNOWN)
-                return ATA_DEV_NONE;
-        if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
-                return ATA_DEV_NONE;
+        if (class == ATA_DEV_UNKNOWN) {
+                /* If the device failed diagnostic, it's likely to
+                 * have reported incorrect device signature too.
+                 * Assume ATA device if the device seems present but
+                 * device signature is invalid with diagnostic
+                 * failure.
+                 */
+                if (present && (dev->horkage & ATA_HORKAGE_DIAGNOSTIC))
+                        class = ATA_DEV_ATA;
+                else
+                        class = ATA_DEV_NONE;
+        } else if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
+                class = ATA_DEV_NONE;
+
         return class;
 }
 
@@ -816,6 +853,21 @@ void ata_id_c_string(const u16 *id, unsigned char *s,
         *p = '\0';
 }
 
+static u64 ata_id_n_sectors(const u16 *id)
+{
+        if (ata_id_has_lba(id)) {
+                if (ata_id_has_lba48(id))
+                        return ata_id_u64(id, 100);
+                else
+                        return ata_id_u32(id, 60);
+        } else {
+                if (ata_id_current_chs_valid(id))
+                        return ata_id_u32(id, 57);
+                else
+                        return id[1] * id[3] * id[6];
+        }
+}
+
 static u64 ata_tf_to_lba48(struct ata_taskfile *tf)
 {
         u64 sectors = 0;
@@ -843,129 +895,110 @@ static u64 ata_tf_to_lba(struct ata_taskfile *tf)
 }
 
 /**
- *      ata_read_native_max_address_ext -       LBA48 native max query
- *      @dev: Device to query
+ *      ata_read_native_max_address - Read native max address
+ *      @dev: target device
+ *      @max_sectors: out parameter for the result native max address
  *
- *      Perform an LBA48 size query upon the device in question. Return the
- *      actual LBA48 size or zero if the command fails.
- */
-
-static u64 ata_read_native_max_address_ext(struct ata_device *dev)
-{
-        unsigned int err;
-        struct ata_taskfile tf;
-
-        ata_tf_init(dev, &tf);
-
-        tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
-        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48 | ATA_TFLAG_ISADDR;
-        tf.protocol |= ATA_PROT_NODATA;
-        tf.device |= 0x40;
-
-        err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
-        if (err)
-                return 0;
-
-        return ata_tf_to_lba48(&tf);
-}
-
-/**
- *      ata_read_native_max_address     -       LBA28 native max query
- *      @dev: Device to query
+ *      Perform an LBA48 or LBA28 native size query upon the device in
+ *      question.
  *
- *      Performa an LBA28 size query upon the device in question. Return the
- *      actual LBA28 size or zero if the command fails.
+ *      RETURNS:
+ *      0 on success, -EACCES if command is aborted by the drive.
+ *      -EIO on other errors.
  */
-
-static u64 ata_read_native_max_address(struct ata_device *dev)
+static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
 {
-        unsigned int err;
+        unsigned int err_mask;
         struct ata_taskfile tf;
+        int lba48 = ata_id_has_lba48(dev->id);
 
         ata_tf_init(dev, &tf);
 
-        tf.command = ATA_CMD_READ_NATIVE_MAX;
+        /* always clear all address registers */
         tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
+
+        if (lba48) {
+                tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
+                tf.flags |= ATA_TFLAG_LBA48;
+        } else
+                tf.command = ATA_CMD_READ_NATIVE_MAX;
+
         tf.protocol |= ATA_PROT_NODATA;
-        tf.device |= 0x40;
+        tf.device |= ATA_LBA;
 
-        err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
-        if (err)
-                return 0;
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
+        if (err_mask) {
+                ata_dev_printk(dev, KERN_WARNING, "failed to read native "
+                               "max address (err_mask=0x%x)\n", err_mask);
+                if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
+                        return -EACCES;
+                return -EIO;
+        }
 
-        return ata_tf_to_lba(&tf);
+        if (lba48)
+                *max_sectors = ata_tf_to_lba48(&tf);
+        else
+                *max_sectors = ata_tf_to_lba(&tf);
+        if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
+                (*max_sectors)--;
+        return 0;
 }
 
 /**
- *      ata_set_native_max_address_ext  -       LBA48 native max set
- *      @dev: Device to query
+ *      ata_set_max_sectors - Set max sectors
+ *      @dev: target device
  *      @new_sectors: new max sectors value to set for the device
  *
- *      Perform an LBA48 size set max upon the device in question. Return the
- *      actual LBA48 size or zero if the command fails.
+ *      Set max sectors of @dev to @new_sectors.
+ *
+ *      RETURNS:
+ *      0 on success, -EACCES if command is aborted or denied (due to
+ *      previous non-volatile SET_MAX) by the drive.  -EIO on other
+ *      errors.
  */
-
-static u64 ata_set_native_max_address_ext(struct ata_device *dev, u64 new_sectors)
+static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
 {
-        unsigned int err;
+        unsigned int err_mask;
         struct ata_taskfile tf;
+        int lba48 = ata_id_has_lba48(dev->id);
 
         new_sectors--;
 
         ata_tf_init(dev, &tf);
 
-        tf.command = ATA_CMD_SET_MAX_EXT;
-        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48 | ATA_TFLAG_ISADDR;
-        tf.protocol |= ATA_PROT_NODATA;
-        tf.device |= 0x40;
-
-        tf.lbal = (new_sectors >> 0) & 0xff;
-        tf.lbam = (new_sectors >> 8) & 0xff;
-        tf.lbah = (new_sectors >> 16) & 0xff;
-
-        tf.hob_lbal = (new_sectors >> 24) & 0xff;
-        tf.hob_lbam = (new_sectors >> 32) & 0xff;
-        tf.hob_lbah = (new_sectors >> 40) & 0xff;
-
-        err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
-        if (err)
-                return 0;
-
-        return ata_tf_to_lba48(&tf);
-}
-
-/**
- *      ata_set_native_max_address      -       LBA28 native max set
- *      @dev: Device to query
- *      @new_sectors: new max sectors value to set for the device
- *
- *      Perform an LBA28 size set max upon the device in question. Return the
- *      actual LBA28 size or zero if the command fails.
- */
+        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
 
-static u64 ata_set_native_max_address(struct ata_device *dev, u64 new_sectors)
-{
-        unsigned int err;
-        struct ata_taskfile tf;
+        if (lba48) {
+                tf.command = ATA_CMD_SET_MAX_EXT;
+                tf.flags |= ATA_TFLAG_LBA48;
 
-        new_sectors--;
+                tf.hob_lbal = (new_sectors >> 24) & 0xff;
+                tf.hob_lbam = (new_sectors >> 32) & 0xff;
+                tf.hob_lbah = (new_sectors >> 40) & 0xff;
+        } else {
+                tf.command = ATA_CMD_SET_MAX;
 
-        ata_tf_init(dev, &tf);
+                tf.device |= (new_sectors >> 24) & 0xf;
+        }
 
-        tf.command = ATA_CMD_SET_MAX;
-        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
         tf.protocol |= ATA_PROT_NODATA;
+        tf.device |= ATA_LBA;
 
         tf.lbal = (new_sectors >> 0) & 0xff;
         tf.lbam = (new_sectors >> 8) & 0xff;
         tf.lbah = (new_sectors >> 16) & 0xff;
-        tf.device |= ((new_sectors >> 24) & 0x0f) | 0x40;
 
-        err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
-        if (err)
-                return 0;
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
+        if (err_mask) {
+                ata_dev_printk(dev, KERN_WARNING, "failed to set "
+                               "max address (err_mask=0x%x)\n", err_mask);
+                if (err_mask == AC_ERR_DEV &&
+                    (tf.feature & (ATA_ABORTED | ATA_IDNF)))
+                        return -EACCES;
+                return -EIO;
+        }
 
-        return ata_tf_to_lba(&tf);
+        return 0;
 }
 
 /**
@@ -975,60 +1008,93 @@ static u64 ata_set_native_max_address(struct ata_device *dev, u64 new_sectors)
  *      Read the size of an LBA28 or LBA48 disk with HPA features and resize
  *      it if required to the full size of the media. The caller must check
  *      the drive has the HPA feature set enabled.
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
  */
-
-static u64 ata_hpa_resize(struct ata_device *dev)
+static int ata_hpa_resize(struct ata_device *dev)
 {
-        u64 sectors = dev->n_sectors;
-        u64 hpa_sectors;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
+        int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
+        u64 sectors = ata_id_n_sectors(dev->id);
+        u64 native_sectors;
+        int rc;
 
-        if (ata_id_has_lba48(dev->id))
-                hpa_sectors = ata_read_native_max_address_ext(dev);
-        else
-                hpa_sectors = ata_read_native_max_address(dev);
+        /* do we need to do it? */
+        if (dev->class != ATA_DEV_ATA ||
+            !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) ||
+            (dev->horkage & ATA_HORKAGE_BROKEN_HPA))
+                return 0;
 
-        if (hpa_sectors > sectors) {
-                ata_dev_printk(dev, KERN_INFO,
-                        "Host Protected Area detected:\n"
-                        "\tcurrent size: %lld sectors\n"
-                        "\tnative size: %lld sectors\n",
-                        (long long)sectors, (long long)hpa_sectors);
-
-                if (ata_ignore_hpa) {
-                        if (ata_id_has_lba48(dev->id))
-                                hpa_sectors = ata_set_native_max_address_ext(dev, hpa_sectors);
-                        else
-                                hpa_sectors = ata_set_native_max_address(dev,
-                                                                hpa_sectors);
-
-                        if (hpa_sectors) {
-                                ata_dev_printk(dev, KERN_INFO, "native size "
-                                        "increased to %lld sectors\n",
-                                        (long long)hpa_sectors);
-                                return hpa_sectors;
-                        }
+        /* read native max address */
+        rc = ata_read_native_max_address(dev, &native_sectors);
+        if (rc) {
+                /* If HPA isn't going to be unlocked, skip HPA
+                 * resizing from the next try.
+                 */
+                if (!ata_ignore_hpa) {
+                        ata_dev_printk(dev, KERN_WARNING, "HPA support seems "
+                                       "broken, will skip HPA handling\n");
+                        dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
+
+                        /* we can continue if device aborted the command */
+                        if (rc == -EACCES)
+                                rc = 0;
                 }
-        } else if (hpa_sectors < sectors)
-                ata_dev_printk(dev, KERN_WARNING, "%s 1: hpa sectors (%lld) "
-                               "is smaller than sectors (%lld)\n", __FUNCTION__,
-                               (long long)hpa_sectors, (long long)sectors);
 
-        return sectors;
-}
+                return rc;
+        }
 
-static u64 ata_id_n_sectors(const u16 *id)
-{
-        if (ata_id_has_lba(id)) {
-                if (ata_id_has_lba48(id))
-                        return ata_id_u64(id, 100);
-                else
-                        return ata_id_u32(id, 60);
-        } else {
-                if (ata_id_current_chs_valid(id))
-                        return ata_id_u32(id, 57);
-                else
-                        return id[1] * id[3] * id[6];
+        /* nothing to do? */
+        if (native_sectors <= sectors || !ata_ignore_hpa) {
+                if (!print_info || native_sectors == sectors)
+                        return 0;
+
+                if (native_sectors > sectors)
+                        ata_dev_printk(dev, KERN_INFO,
+                                "HPA detected: current %llu, native %llu\n",
+                                (unsigned long long)sectors,
+                                (unsigned long long)native_sectors);
+                else if (native_sectors < sectors)
+                        ata_dev_printk(dev, KERN_WARNING,
+                                "native sectors (%llu) is smaller than "
+                                "sectors (%llu)\n",
+                                (unsigned long long)native_sectors,
+                                (unsigned long long)sectors);
+                return 0;
         }
+
+        /* let's unlock HPA */
+        rc = ata_set_max_sectors(dev, native_sectors);
+        if (rc == -EACCES) {
+                /* if device aborted the command, skip HPA resizing */
+                ata_dev_printk(dev, KERN_WARNING, "device aborted resize "
+                               "(%llu -> %llu), skipping HPA handling\n",
+                               (unsigned long long)sectors,
+                               (unsigned long long)native_sectors);
+                dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
+                return 0;
+        } else if (rc)
+                return rc;
+
+        /* re-read IDENTIFY data */
+        rc = ata_dev_reread_id(dev, 0);
+        if (rc) {
+                ata_dev_printk(dev, KERN_ERR, "failed to re-read IDENTIFY "
+                               "data after HPA resizing\n");
+                return rc;
+        }
+
+        if (print_info) {
+                u64 new_sectors = ata_id_n_sectors(dev->id);
+                ata_dev_printk(dev, KERN_INFO,
+                        "HPA unlocked: %llu -> %llu, native %llu\n",
+                        (unsigned long long)sectors,
+                        (unsigned long long)new_sectors,
+                        (unsigned long long)native_sectors);
+        }
+
+        return 0;
 }
 
 /**
@@ -1150,7 +1216,7 @@ void ata_dev_select(struct ata_port *ap, unsigned int device,
         ap->ops->dev_select(ap, device);
 
         if (wait) {
-                if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
+                if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI)
                         msleep(150);
                 ata_wait_idle(ap);
         }
@@ -1328,6 +1394,7 @@ static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
  *      @dma_dir: Data tranfer direction of the command
  *      @sg: sg list for the data buffer of the command
  *      @n_elem: Number of sg entries
+ *      @timeout: Timeout in msecs (0 for default)
  *
  *      Executes libata internal command with timeout.  @tf contains
  *      command on entry and result on return.  Timeout and error
@@ -1344,13 +1411,15 @@ static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
 unsigned ata_exec_internal_sg(struct ata_device *dev,
                               struct ata_taskfile *tf, const u8 *cdb,
                               int dma_dir, struct scatterlist *sg,
-                              unsigned int n_elem)
+                              unsigned int n_elem, unsigned long timeout)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
         u8 command = tf->command;
         struct ata_queued_cmd *qc;
         unsigned int tag, preempted_tag;
         u32 preempted_sactive, preempted_qc_active;
+        int preempted_nr_active_links;
         DECLARE_COMPLETION_ONSTACK(wait);
         unsigned long flags;
         unsigned int err_mask;
@@ -1386,12 +1455,14 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
         qc->dev = dev;
         ata_qc_reinit(qc);
 
-        preempted_tag = ap->active_tag;
-        preempted_sactive = ap->sactive;
+        preempted_tag = link->active_tag;
+        preempted_sactive = link->sactive;
         preempted_qc_active = ap->qc_active;
-        ap->active_tag = ATA_TAG_POISON;
-        ap->sactive = 0;
+        preempted_nr_active_links = ap->nr_active_links;
+        link->active_tag = ATA_TAG_POISON;
+        link->sactive = 0;
         ap->qc_active = 0;
+        ap->nr_active_links = 0;
 
         /* prepare & issue qc */
         qc->tf = *tf;
@@ -1416,7 +1487,10 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
 
         spin_unlock_irqrestore(ap->lock, flags);
 
-        rc = wait_for_completion_timeout(&wait, ata_probe_timeout);
+        if (!timeout)
+                timeout = ata_probe_timeout * 1000 / HZ;
+
+        rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
 
         ata_port_flush_task(ap);
 
@@ -1467,9 +1541,10 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
         err_mask = qc->err_mask;
 
         ata_qc_free(qc);
-        ap->active_tag = preempted_tag;
-        ap->sactive = preempted_sactive;
+        link->active_tag = preempted_tag;
+        link->sactive = preempted_sactive;
         ap->qc_active = preempted_qc_active;
+        ap->nr_active_links = preempted_nr_active_links;
 
         /* XXX - Some LLDDs (sata_mv) disable port on command failure.
          * Until those drivers are fixed, we detect the condition
@@ -1500,6 +1575,7 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
  *      @dma_dir: Data tranfer direction of the command
  *      @buf: Data buffer of the command
  *      @buflen: Length of data buffer
+ *      @timeout: Timeout in msecs (0 for default)
  *
  *      Wrapper around ata_exec_internal_sg() which takes simple
  *      buffer instead of sg list.
@@ -1512,7 +1588,8 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
  */
 unsigned ata_exec_internal(struct ata_device *dev,
                            struct ata_taskfile *tf, const u8 *cdb,
-                           int dma_dir, void *buf, unsigned int buflen)
+                           int dma_dir, void *buf, unsigned int buflen,
+                           unsigned long timeout)
 {
         struct scatterlist *psg = NULL, sg;
         unsigned int n_elem = 0;
@@ -1524,7 +1601,8 @@ unsigned ata_exec_internal(struct ata_device *dev,
                 n_elem++;
         }
 
-        return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem);
+        return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem,
+                                    timeout);
 }
 
 /**
@@ -1551,7 +1629,7 @@ unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
         tf.flags |= ATA_TFLAG_DEVICE;
         tf.protocol = ATA_PROT_NODATA;
 
-        return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
+        return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
 }
 
 /**
@@ -1566,7 +1644,7 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
 {
         /* Controller doesn't support  IORDY. Probably a pointless check
            as the caller should know this */
-        if (adev->ap->flags & ATA_FLAG_NO_IORDY)
+        if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
                 return 0;
         /* PIO3 and higher it is mandatory */
         if (adev->pio_mode > XFER_PIO_2)
@@ -1613,6 +1691,9 @@ static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
  *      devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
  *      for pre-ATA4 drives.
  *
+ *      FIXME: ATA_CMD_ID_ATA is optional for early drives and right
+ *      now we abort if we hit that case. 
+ *
  *      LOCKING:
  *      Kernel thread context (may sleep)
  *
@@ -1622,7 +1703,7 @@ static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
 int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
                     unsigned int flags, u16 *id)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         unsigned int class = *p_class;
         struct ata_taskfile tf;
         unsigned int err_mask = 0;
@@ -1663,7 +1744,7 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
         tf.flags |= ATA_TFLAG_POLLING;
 
         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
-                                     id, sizeof(id[0]) * ATA_ID_WORDS);
+                                     id, sizeof(id[0]) * ATA_ID_WORDS, 0);
         if (err_mask) {
                 if (err_mask & AC_ERR_NODEV_HINT) {
                         DPRINTK("ata%u.%d: NODEV after polling detection\n",
@@ -1722,7 +1803,8 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
                 tf.feature = SETFEATURES_SPINUP;
                 tf.protocol = ATA_PROT_NODATA;
                 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
-                err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
+                err_mask = ata_exec_internal(dev, &tf, NULL,
+                                             DMA_NONE, NULL, 0, 0);
                 if (err_mask && id[2] != 0x738c) {
                         rc = -EIO;
                         reason = "SPINUP failed";
@@ -1740,10 +1822,13 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
                 /*
                  * The exact sequence expected by certain pre-ATA4 drives is:
                  * SRST RESET
-                 * IDENTIFY
-                 * INITIALIZE DEVICE PARAMETERS
+                 * IDENTIFY (optional in early ATA)
+                 * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)
                  * anything else..
                  * Some drives were very specific about that exact sequence.
+                 *
+                 * Note that ATA4 says lba is mandatory so the second check
+                 * shoud never trigger.
                  */
                 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
                         err_mask = ata_dev_init_params(dev, id[3], id[6]);
@@ -1774,13 +1859,14 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
 
 static inline u8 ata_dev_knobble(struct ata_device *dev)
 {
-        return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
+        struct ata_port *ap = dev->link->ap;
+        return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
 }
 
 static void ata_dev_config_ncq(struct ata_device *dev,
                                char *desc, size_t desc_sz)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
 
         if (!ata_id_has_ncq(dev->id)) {
@@ -1817,8 +1903,8 @@ static void ata_dev_config_ncq(struct ata_device *dev,
  */
 int ata_dev_configure(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = dev->link->ap;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
         int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
         const u16 *id = dev->id;
         unsigned int xfer_mask;
@@ -1844,6 +1930,11 @@ int ata_dev_configure(struct ata_device *dev)
         if (rc)
                 return rc;
 
+        /* massage HPA, do it early as it might change IDENTIFY data */
+        rc = ata_hpa_resize(dev);
+        if (rc)
+                return rc;
+
         /* print device capabilities */
         if (ata_msg_probe(ap))
                 ata_dev_printk(dev, KERN_DEBUG,
@@ -1911,10 +2002,6 @@ int ata_dev_configure(struct ata_device *dev)
                                         dev->flags |= ATA_DFLAG_FLUSH_EXT;
                         }
 
-                        if (!(dev->horkage & ATA_HORKAGE_BROKEN_HPA) &&
-                            ata_id_hpa_enabled(dev->id))
-                                dev->n_sectors = ata_hpa_resize(dev);
-
                         /* config NCQ */
                         ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
 
@@ -1963,7 +2050,9 @@ int ata_dev_configure(struct ata_device *dev)
 
         /* ATAPI-specific feature tests */
         else if (dev->class == ATA_DEV_ATAPI) {
-                char *cdb_intr_string = "";
+                const char *cdb_intr_string = "";
+                const char *atapi_an_string = "";
+                u32 sntf;
 
                 rc = atapi_cdb_len(id);
                 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
@@ -1975,6 +2064,28 @@ int ata_dev_configure(struct ata_device *dev)
                 }
                 dev->cdb_len = (unsigned int) rc;
 
+                /* Enable ATAPI AN if both the host and device have
+                 * the support.  If PMP is attached, SNTF is required
+                 * to enable ATAPI AN to discern between PHY status
+                 * changed notifications and ATAPI ANs.
+                 */
+                if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
+                    (!ap->nr_pmp_links ||
+                     sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
+                        unsigned int err_mask;
+
+                        /* issue SET feature command to turn this on */
+                        err_mask = ata_dev_set_AN(dev, SETFEATURES_SATA_ENABLE);
+                        if (err_mask)
+                                ata_dev_printk(dev, KERN_ERR,
+                                        "failed to enable ATAPI AN "
+                                        "(err_mask=0x%x)\n", err_mask);
+                        else {
+                                dev->flags |= ATA_DFLAG_AN;
+                                atapi_an_string = ", ATAPI AN";
+                        }
+                }
+
                 if (ata_id_cdb_intr(dev->id)) {
                         dev->flags |= ATA_DFLAG_CDB_INTR;
                         cdb_intr_string = ", CDB intr";
@@ -1983,10 +2094,10 @@ int ata_dev_configure(struct ata_device *dev)
                 /* print device info to dmesg */
                 if (ata_msg_drv(ap) && print_info)
                         ata_dev_printk(dev, KERN_INFO,
-                                       "ATAPI: %s, %s, max %s%s\n",
+                                       "ATAPI: %s, %s, max %s%s%s\n",
                                        modelbuf, fwrevbuf,
                                        ata_mode_string(xfer_mask),
-                                       cdb_intr_string);
+                                       cdb_intr_string, atapi_an_string);
         }
 
         /* determine max_sectors */
@@ -2103,21 +2214,19 @@ int ata_bus_probe(struct ata_port *ap)
 {
         unsigned int classes[ATA_MAX_DEVICES];
         int tries[ATA_MAX_DEVICES];
-        int i, rc;
+        int rc;
         struct ata_device *dev;
 
         ata_port_probe(ap);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                tries[i] = ATA_PROBE_MAX_TRIES;
+        ata_link_for_each_dev(dev, &ap->link)
+                tries[dev->devno] = ATA_PROBE_MAX_TRIES;
 
  retry:
         /* reset and determine device classes */
         ap->ops->phy_reset(ap);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
+        ata_link_for_each_dev(dev, &ap->link) {
                 if (!(ap->flags & ATA_FLAG_DISABLED) &&
                     dev->class != ATA_DEV_UNKNOWN)
                         classes[dev->devno] = dev->class;
@@ -2132,18 +2241,16 @@ int ata_bus_probe(struct ata_port *ap)
         /* after the reset the device state is PIO 0 and the controller
            state is undefined. Record the mode */
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ap->device[i].pio_mode = XFER_PIO_0;
+        ata_link_for_each_dev(dev, &ap->link)
+                dev->pio_mode = XFER_PIO_0;
 
         /* read IDENTIFY page and configure devices. We have to do the identify
            specific sequence bass-ackwards so that PDIAG- is released by
            the slave device */
 
-        for (i = ATA_MAX_DEVICES - 1; i >=  0; i--) {
-                dev = &ap->device[i];
-
-                if (tries[i])
-                        dev->class = classes[i];
+        ata_link_for_each_dev(dev, &ap->link) {
+                if (tries[dev->devno])
+                        dev->class = classes[dev->devno];
 
                 if (!ata_dev_enabled(dev))
                         continue;
@@ -2158,33 +2265,42 @@ int ata_bus_probe(struct ata_port *ap)
         if (ap->ops->cable_detect)
                 ap->cbl = ap->ops->cable_detect(ap);
 
+        /* We may have SATA bridge glue hiding here irrespective of the
+           reported cable types and sensed types */
+        ata_link_for_each_dev(dev, &ap->link) {
+                if (!ata_dev_enabled(dev))
+                        continue;
+                /* SATA drives indicate we have a bridge. We don't know which
+                   end of the link the bridge is which is a problem */
+                if (ata_id_is_sata(dev->id))
+                        ap->cbl = ATA_CBL_SATA;
+        }
+
         /* After the identify sequence we can now set up the devices. We do
            this in the normal order so that the user doesn't get confused */
 
-        for(i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
+        ata_link_for_each_dev(dev, &ap->link) {
                 if (!ata_dev_enabled(dev))
                         continue;
 
-                ap->eh_context.i.flags |= ATA_EHI_PRINTINFO;
+                ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;
                 rc = ata_dev_configure(dev);
-                ap->eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
+                ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
                 if (rc)
                         goto fail;
         }
 
         /* configure transfer mode */
-        rc = ata_set_mode(ap, &dev);
+        rc = ata_set_mode(&ap->link, &dev);
         if (rc)
                 goto fail;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                if (ata_dev_enabled(&ap->device[i]))
+        ata_link_for_each_dev(dev, &ap->link)
+                if (ata_dev_enabled(dev))
                         return 0;
 
         /* no device present, disable port */
         ata_port_disable(ap);
-        ap->ops->port_disable(ap);
         return -ENODEV;
 
  fail:
@@ -2204,7 +2320,7 @@ int ata_bus_probe(struct ata_port *ap)
                         /* This is the last chance, better to slow
                          * down than lose it.
                          */
-                        sata_down_spd_limit(ap);
+                        sata_down_spd_limit(&ap->link);
                         ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
                 }
         }
@@ -2233,28 +2349,28 @@ void ata_port_probe(struct ata_port *ap)
 
 /**
  *      sata_print_link_status - Print SATA link status
- *      @ap: SATA port to printk link status about
+ *      @link: SATA link to printk link status about
  *
  *      This function prints link speed and status of a SATA link.
  *
  *      LOCKING:
  *      None.
  */
-void sata_print_link_status(struct ata_port *ap)
+void sata_print_link_status(struct ata_link *link)
 {
         u32 sstatus, scontrol, tmp;
 
-        if (sata_scr_read(ap, SCR_STATUS, &sstatus))
+        if (sata_scr_read(link, SCR_STATUS, &sstatus))
                 return;
-        sata_scr_read(ap, SCR_CONTROL, &scontrol);
+        sata_scr_read(link, SCR_CONTROL, &scontrol);
 
-        if (ata_port_online(ap)) {
+        if (ata_link_online(link)) {
                 tmp = (sstatus >> 4) & 0xf;
-                ata_port_printk(ap, KERN_INFO,
+                ata_link_printk(link, KERN_INFO,
                                 "SATA link up %s (SStatus %X SControl %X)\n",
                                 sata_spd_string(tmp), sstatus, scontrol);
         } else {
-                ata_port_printk(ap, KERN_INFO,
+                ata_link_printk(link, KERN_INFO,
                                 "SATA link down (SStatus %X SControl %X)\n",
                                 sstatus, scontrol);
         }
@@ -2274,32 +2390,33 @@ void sata_print_link_status(struct ata_port *ap)
  */
 void __sata_phy_reset(struct ata_port *ap)
 {
-        u32 sstatus;
+        struct ata_link *link = &ap->link;
         unsigned long timeout = jiffies + (HZ * 5);
+        u32 sstatus;
 
         if (ap->flags & ATA_FLAG_SATA_RESET) {
                 /* issue phy wake/reset */
-                sata_scr_write_flush(ap, SCR_CONTROL, 0x301);
+                sata_scr_write_flush(link, SCR_CONTROL, 0x301);
                 /* Couldn't find anything in SATA I/II specs, but
                  * AHCI-1.1 10.4.2 says at least 1 ms. */
                 mdelay(1);
         }
         /* phy wake/clear reset */
-        sata_scr_write_flush(ap, SCR_CONTROL, 0x300);
+        sata_scr_write_flush(link, SCR_CONTROL, 0x300);
 
         /* wait for phy to become ready, if necessary */
         do {
                 msleep(200);
-                sata_scr_read(ap, SCR_STATUS, &sstatus);
+                sata_scr_read(link, SCR_STATUS, &sstatus);
                 if ((sstatus & 0xf) != 1)
                         break;
         } while (time_before(jiffies, timeout));
 
         /* print link status */
-        sata_print_link_status(ap);
+        sata_print_link_status(link);
 
         /* TODO: phy layer with polling, timeouts, etc. */
-        if (!ata_port_offline(ap))
+        if (!ata_link_offline(link))
                 ata_port_probe(ap);
         else
                 ata_port_disable(ap);
@@ -2344,8 +2461,8 @@ void sata_phy_reset(struct ata_port *ap)
 
 struct ata_device *ata_dev_pair(struct ata_device *adev)
 {
-        struct ata_port *ap = adev->ap;
-        struct ata_device *pair = &ap->device[1 - adev->devno];
+        struct ata_link *link = adev->link;
+        struct ata_device *pair = &link->device[1 - adev->devno];
         if (!ata_dev_enabled(pair))
                 return NULL;
         return pair;
@@ -2366,16 +2483,16 @@ struct ata_device *ata_dev_pair(struct ata_device *adev)
 
 void ata_port_disable(struct ata_port *ap)
 {
-        ap->device[0].class = ATA_DEV_NONE;
-        ap->device[1].class = ATA_DEV_NONE;
+        ap->link.device[0].class = ATA_DEV_NONE;
+        ap->link.device[1].class = ATA_DEV_NONE;
         ap->flags |= ATA_FLAG_DISABLED;
 }
 
 /**
  *      sata_down_spd_limit - adjust SATA spd limit downward
- *      @ap: Port to adjust SATA spd limit for
+ *      @link: Link to adjust SATA spd limit for
  *
- *      Adjust SATA spd limit of @ap downward.  Note that this
+ *      Adjust SATA spd limit of @link downward.  Note that this
  *      function only adjusts the limit.  The change must be applied
  *      using sata_set_spd().
  *
@@ -2385,24 +2502,24 @@ void ata_port_disable(struct ata_port *ap)
  *      RETURNS:
  *      0 on success, negative errno on failure
  */
-int sata_down_spd_limit(struct ata_port *ap)
+int sata_down_spd_limit(struct ata_link *link)
 {
         u32 sstatus, spd, mask;
         int rc, highbit;
 
-        if (!sata_scr_valid(ap))
+        if (!sata_scr_valid(link))
                 return -EOPNOTSUPP;
 
         /* If SCR can be read, use it to determine the current SPD.
-         * If not, use cached value in ap->sata_spd.
+         * If not, use cached value in link->sata_spd.
          */
-        rc = sata_scr_read(ap, SCR_STATUS, &sstatus);
+        rc = sata_scr_read(link, SCR_STATUS, &sstatus);
         if (rc == 0)
                 spd = (sstatus >> 4) & 0xf;
         else
-                spd = ap->sata_spd;
+                spd = link->sata_spd;
 
-        mask = ap->sata_spd_limit;
+        mask = link->sata_spd_limit;
         if (mask <= 1)
                 return -EINVAL;
 
@@ -2422,22 +2539,22 @@ int sata_down_spd_limit(struct ata_port *ap)
         if (!mask)
                 return -EINVAL;
 
-        ap->sata_spd_limit = mask;
+        link->sata_spd_limit = mask;
 
-        ata_port_printk(ap, KERN_WARNING, "limiting SATA link speed to %s\n",
+        ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n",
                         sata_spd_string(fls(mask)));
 
         return 0;
 }
 
-static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
+static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
 {
         u32 spd, limit;
 
-        if (ap->sata_spd_limit == UINT_MAX)
+        if (link->sata_spd_limit == UINT_MAX)
                 limit = 0;
         else
-                limit = fls(ap->sata_spd_limit);
+                limit = fls(link->sata_spd_limit);
 
         spd = (*scontrol >> 4) & 0xf;
         *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
@@ -2447,10 +2564,10 @@ static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
 
 /**
  *      sata_set_spd_needed - is SATA spd configuration needed
- *      @ap: Port in question
+ *      @link: Link in question
  *
  *      Test whether the spd limit in SControl matches
- *      @ap->sata_spd_limit.  This function is used to determine
+ *      @link->sata_spd_limit.  This function is used to determine
  *      whether hardreset is necessary to apply SATA spd
  *      configuration.
  *
@@ -2460,21 +2577,21 @@ static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
  *      RETURNS:
  *      1 if SATA spd configuration is needed, 0 otherwise.
  */
-int sata_set_spd_needed(struct ata_port *ap)
+int sata_set_spd_needed(struct ata_link *link)
 {
         u32 scontrol;
 
-        if (sata_scr_read(ap, SCR_CONTROL, &scontrol))
+        if (sata_scr_read(link, SCR_CONTROL, &scontrol))
                 return 0;
 
-        return __sata_set_spd_needed(ap, &scontrol);
+        return __sata_set_spd_needed(link, &scontrol);
 }
 
 /**
  *      sata_set_spd - set SATA spd according to spd limit
- *      @ap: Port to set SATA spd for
+ *      @link: Link to set SATA spd for
  *
- *      Set SATA spd of @ap according to sata_spd_limit.
+ *      Set SATA spd of @link according to sata_spd_limit.
  *
  *      LOCKING:
  *      Inherited from caller.
@@ -2483,18 +2600,18 @@ int sata_set_spd_needed(struct ata_port *ap)
  *      0 if spd doesn't need to be changed, 1 if spd has been
  *      changed.  Negative errno if SCR registers are inaccessible.
  */
-int sata_set_spd(struct ata_port *ap)
+int sata_set_spd(struct ata_link *link)
 {
         u32 scontrol;
         int rc;
 
-        if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+        if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
                 return rc;
 
-        if (!__sata_set_spd_needed(ap, &scontrol))
+        if (!__sata_set_spd_needed(link, &scontrol))
                 return 0;
 
-        if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
+        if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
                 return rc;
 
         return 1;
@@ -2749,7 +2866,7 @@ int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
 
 static int ata_dev_set_mode(struct ata_device *dev)
 {
-        struct ata_eh_context *ehc = &dev->ap->eh_context;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
         unsigned int err_mask;
         int rc;
 
@@ -2761,7 +2878,11 @@ static int ata_dev_set_mode(struct ata_device *dev)
         /* Old CFA may refuse this command, which is just fine */
         if (dev->xfer_shift == ATA_SHIFT_PIO && ata_id_is_cfa(dev->id))
                 err_mask &= ~AC_ERR_DEV;
-
+        /* Some very old devices and some bad newer ones fail any kind of
+           SET_XFERMODE request but support PIO0-2 timings and no IORDY */
+        if (dev->xfer_shift == ATA_SHIFT_PIO && !ata_id_has_iordy(dev->id) &&
+                        dev->pio_mode <= XFER_PIO_2)
+                err_mask &= ~AC_ERR_DEV;
         if (err_mask) {
                 ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
                                "(err_mask=0x%x)\n", err_mask);
@@ -2769,7 +2890,7 @@ static int ata_dev_set_mode(struct ata_device *dev)
         }
 
         ehc->i.flags |= ATA_EHI_POST_SETMODE;
-        rc = ata_dev_revalidate(dev, 0);
+        rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
         ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
         if (rc)
                 return rc;
@@ -2784,7 +2905,7 @@ static int ata_dev_set_mode(struct ata_device *dev)
 
 /**
  *      ata_do_set_mode - Program timings and issue SET FEATURES - XFER
- *      @ap: port on which timings will be programmed
+ *      @link: link on which timings will be programmed
  *      @r_failed_dev: out paramter for failed device
  *
  *      Standard implementation of the function used to tune and set
@@ -2799,25 +2920,36 @@ static int ata_dev_set_mode(struct ata_device *dev)
  *      0 on success, negative errno otherwise
  */
 
-int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
+int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
 {
+        struct ata_port *ap = link->ap;
         struct ata_device *dev;
-        int i, rc = 0, used_dma = 0, found = 0;
-
+        int rc = 0, used_dma = 0, found = 0;
 
         /* step 1: calculate xfer_mask */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+        ata_link_for_each_dev(dev, link) {
                 unsigned int pio_mask, dma_mask;
-
-                dev = &ap->device[i];
+                unsigned int mode_mask;
 
                 if (!ata_dev_enabled(dev))
                         continue;
 
+                mode_mask = ATA_DMA_MASK_ATA;
+                if (dev->class == ATA_DEV_ATAPI)
+                        mode_mask = ATA_DMA_MASK_ATAPI;
+                else if (ata_id_is_cfa(dev->id))
+                        mode_mask = ATA_DMA_MASK_CFA;
+
                 ata_dev_xfermask(dev);
 
                 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
                 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
+
+                if (libata_dma_mask & mode_mask)
+                        dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
+                else
+                        dma_mask = 0;
+
                 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
                 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
 
@@ -2829,8 +2961,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
                 goto out;
 
         /* step 2: always set host PIO timings */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (!ata_dev_enabled(dev))
                         continue;
 
@@ -2847,9 +2978,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
         }
 
         /* step 3: set host DMA timings */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
+        ata_link_for_each_dev(dev, link) {
                 if (!ata_dev_enabled(dev) || !dev->dma_mode)
                         continue;
 
@@ -2860,9 +2989,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
         }
 
         /* step 4: update devices' xfer mode */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
+        ata_link_for_each_dev(dev, link) {
                 /* don't update suspended devices' xfer mode */
                 if (!ata_dev_enabled(dev))
                         continue;
@@ -2886,7 +3013,7 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
 
 /**
  *      ata_set_mode - Program timings and issue SET FEATURES - XFER
- *      @ap: port on which timings will be programmed
+ *      @link: link on which timings will be programmed
  *      @r_failed_dev: out paramter for failed device
  *
  *      Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
@@ -2899,12 +3026,14 @@ int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
  *      RETURNS:
  *      0 on success, negative errno otherwise
  */
-int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
+int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
 {
+        struct ata_port *ap = link->ap;
+
         /* has private set_mode? */
         if (ap->ops->set_mode)
-                return ap->ops->set_mode(ap, r_failed_dev);
-        return ata_do_set_mode(ap, r_failed_dev);
+                return ap->ops->set_mode(link, r_failed_dev);
+        return ata_do_set_mode(link, r_failed_dev);
 }
 
 /**
@@ -3007,7 +3136,7 @@ int ata_wait_ready(struct ata_port *ap, unsigned long deadline)
 
                 if (!(status & ATA_BUSY))
                         return 0;
-                if (!ata_port_online(ap) && status == 0xff)
+                if (!ata_link_online(&ap->link) && status == 0xff)
                         return -ENODEV;
                 if (time_after(now, deadline))
                         return -EBUSY;
@@ -3088,6 +3217,8 @@ static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
                              unsigned long deadline)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
+        struct ata_device *dev;
+        int i = 0;
 
         DPRINTK("ata%u: bus reset via SRST\n", ap->print_id);
 
@@ -3098,6 +3229,25 @@ static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
         udelay(20);     /* FIXME: flush */
         iowrite8(ap->ctl, ioaddr->ctl_addr);
 
+        /* If we issued an SRST then an ATA drive (not ATAPI)
+         * may have changed configuration and be in PIO0 timing. If
+         * we did a hard reset (or are coming from power on) this is
+         * true for ATA or ATAPI. Until we've set a suitable controller
+         * mode we should not touch the bus as we may be talking too fast.
+         */
+
+        ata_link_for_each_dev(dev, &ap->link)
+                dev->pio_mode = XFER_PIO_0;
+
+        /* If the controller has a pio mode setup function then use
+           it to set the chipset to rights. Don't touch the DMA setup
+           as that will be dealt with when revalidating */
+        if (ap->ops->set_piomode) {
+                ata_link_for_each_dev(dev, &ap->link)
+                        if (devmask & (1 << i++))
+                                ap->ops->set_piomode(ap, dev);
+        }
+
         /* spec mandates ">= 2ms" before checking status.
          * We wait 150ms, because that was the magic delay used for
          * ATAPI devices in Hale Landis's ATADRVR, for the period of time
@@ -3142,6 +3292,7 @@ static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
 
 void ata_bus_reset(struct ata_port *ap)
 {
+        struct ata_device *device = ap->link.device;
         struct ata_ioports *ioaddr = &ap->ioaddr;
         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
         u8 err;
@@ -3177,19 +3328,19 @@ void ata_bus_reset(struct ata_port *ap)
         /*
          * determine by signature whether we have ATA or ATAPI devices
          */
-        ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
+        device[0].class = ata_dev_try_classify(&device[0], dev0, &err);
         if ((slave_possible) && (err != 0x81))
-                ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
+                device[1].class = ata_dev_try_classify(&device[1], dev1, &err);
 
         /* is double-select really necessary? */
-        if (ap->device[1].class != ATA_DEV_NONE)
+        if (device[1].class != ATA_DEV_NONE)
                 ap->ops->dev_select(ap, 1);
-        if (ap->device[0].class != ATA_DEV_NONE)
+        if (device[0].class != ATA_DEV_NONE)
                 ap->ops->dev_select(ap, 0);
 
         /* if no devices were detected, disable this port */
-        if ((ap->device[0].class == ATA_DEV_NONE) &&
-            (ap->device[1].class == ATA_DEV_NONE))
+        if ((device[0].class == ATA_DEV_NONE) &&
+            (device[1].class == ATA_DEV_NONE))
                 goto err_out;
 
         if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
@@ -3202,18 +3353,18 @@ void ata_bus_reset(struct ata_port *ap)
 
 err_out:
         ata_port_printk(ap, KERN_ERR, "disabling port\n");
-        ap->ops->port_disable(ap);
+        ata_port_disable(ap);
 
         DPRINTK("EXIT\n");
 }
 
 /**
- *      sata_phy_debounce - debounce SATA phy status
- *      @ap: ATA port to debounce SATA phy status for
+ *      sata_link_debounce - debounce SATA phy status
+ *      @link: ATA link to debounce SATA phy status for
  *      @params: timing parameters { interval, duratinon, timeout } in msec
  *      @deadline: deadline jiffies for the operation
  *
- *      Make sure SStatus of @ap reaches stable state, determined by
+*       Make sure SStatus of @link reaches stable state, determined by
  *      holding the same value where DET is not 1 for @duration polled
  *      every @interval, before @timeout.  Timeout constraints the
  *      beginning of the stable state.  Because DET gets stuck at 1 on
@@ -3229,8 +3380,8 @@ err_out:
  *      RETURNS:
  *      0 on success, -errno on failure.
  */
-int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
-                      unsigned long deadline)
+int sata_link_debounce(struct ata_link *link, const unsigned long *params,
+                       unsigned long deadline)
 {
         unsigned long interval_msec = params[0];
         unsigned long duration = msecs_to_jiffies(params[1]);
@@ -3242,7 +3393,7 @@ int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
         if (time_before(t, deadline))
                 deadline = t;
 
-        if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
+        if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
                 return rc;
         cur &= 0xf;
 
@@ -3251,7 +3402,7 @@ int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
 
         while (1) {
                 msleep(interval_msec);
-                if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
+                if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
                         return rc;
                 cur &= 0xf;
 
@@ -3277,12 +3428,12 @@ int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
 }
 
 /**
- *      sata_phy_resume - resume SATA phy
- *      @ap: ATA port to resume SATA phy for
+ *      sata_link_resume - resume SATA link
+ *      @link: ATA link to resume SATA
  *      @params: timing parameters { interval, duratinon, timeout } in msec
  *      @deadline: deadline jiffies for the operation
  *
- *      Resume SATA phy of @ap and debounce it.
+ *      Resume SATA phy @link and debounce it.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep)
@@ -3290,18 +3441,18 @@ int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
  *      RETURNS:
  *      0 on success, -errno on failure.
  */
-int sata_phy_resume(struct ata_port *ap, const unsigned long *params,
-                    unsigned long deadline)
+int sata_link_resume(struct ata_link *link, const unsigned long *params,
+                     unsigned long deadline)
 {
         u32 scontrol;
         int rc;
 
-        if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+        if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
                 return rc;
 
         scontrol = (scontrol & 0x0f0) | 0x300;
 
-        if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
+        if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
                 return rc;
 
         /* Some PHYs react badly if SStatus is pounded immediately
@@ -3309,15 +3460,15 @@ int sata_phy_resume(struct ata_port *ap, const unsigned long *params,
          */
         msleep(200);
 
-        return sata_phy_debounce(ap, params, deadline);
+        return sata_link_debounce(link, params, deadline);
 }
 
 /**
  *      ata_std_prereset - prepare for reset
- *      @ap: ATA port to be reset
+ *      @link: ATA link to be reset
  *      @deadline: deadline jiffies for the operation
  *
- *      @ap is about to be reset.  Initialize it.  Failure from
+ *      @link is about to be reset.  Initialize it.  Failure from
  *      prereset makes libata abort whole reset sequence and give up
  *      that port, so prereset should be best-effort.  It does its
  *      best to prepare for reset sequence but if things go wrong, it
@@ -3329,37 +3480,44 @@ int sata_phy_resume(struct ata_port *ap, const unsigned long *params,
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
+int ata_std_prereset(struct ata_link *link, unsigned long deadline)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         const unsigned long *timing = sata_ehc_deb_timing(ehc);
         int rc;
 
         /* handle link resume */
         if ((ehc->i.flags & ATA_EHI_RESUME_LINK) &&
-            (ap->flags & ATA_FLAG_HRST_TO_RESUME))
+            (link->flags & ATA_LFLAG_HRST_TO_RESUME))
+                ehc->i.action |= ATA_EH_HARDRESET;
+
+        /* Some PMPs don't work with only SRST, force hardreset if PMP
+         * is supported.
+         */
+        if (ap->flags & ATA_FLAG_PMP)
                 ehc->i.action |= ATA_EH_HARDRESET;
 
         /* if we're about to do hardreset, nothing more to do */
         if (ehc->i.action & ATA_EH_HARDRESET)
                 return 0;
 
-        /* if SATA, resume phy */
+        /* if SATA, resume link */
         if (ap->flags & ATA_FLAG_SATA) {
-                rc = sata_phy_resume(ap, timing, deadline);
+                rc = sata_link_resume(link, timing, deadline);
                 /* whine about phy resume failure but proceed */
                 if (rc && rc != -EOPNOTSUPP)
-                        ata_port_printk(ap, KERN_WARNING, "failed to resume "
+                        ata_link_printk(link, KERN_WARNING, "failed to resume "
                                         "link for reset (errno=%d)\n", rc);
         }
 
         /* Wait for !BSY if the controller can wait for the first D2H
          * Reg FIS and we don't know that no device is attached.
          */
-        if (!(ap->flags & ATA_FLAG_SKIP_D2H_BSY) && !ata_port_offline(ap)) {
+        if (!(link->flags & ATA_LFLAG_SKIP_D2H_BSY) && !ata_link_offline(link)) {
                 rc = ata_wait_ready(ap, deadline);
                 if (rc && rc != -ENODEV) {
-                        ata_port_printk(ap, KERN_WARNING, "device not ready "
+                        ata_link_printk(link, KERN_WARNING, "device not ready "
                                         "(errno=%d), forcing hardreset\n", rc);
                         ehc->i.action |= ATA_EH_HARDRESET;
                 }
@@ -3370,7 +3528,7 @@ int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
 
 /**
  *      ata_std_softreset - reset host port via ATA SRST
- *      @ap: port to reset
+ *      @link: ATA link to reset
  *      @classes: resulting classes of attached devices
  *      @deadline: deadline jiffies for the operation
  *
@@ -3382,9 +3540,10 @@ int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
+int ata_std_softreset(struct ata_link *link, unsigned int *classes,
                       unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
         unsigned int devmask = 0;
         int rc;
@@ -3392,7 +3551,7 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
 
         DPRINTK("ENTER\n");
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 classes[0] = ATA_DEV_NONE;
                 goto out;
         }
@@ -3410,15 +3569,17 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
         DPRINTK("about to softreset, devmask=%x\n", devmask);
         rc = ata_bus_softreset(ap, devmask, deadline);
         /* if link is occupied, -ENODEV too is an error */
-        if (rc && (rc != -ENODEV || sata_scr_valid(ap))) {
-                ata_port_printk(ap, KERN_ERR, "SRST failed (errno=%d)\n", rc);
+        if (rc && (rc != -ENODEV || sata_scr_valid(link))) {
+                ata_link_printk(link, KERN_ERR, "SRST failed (errno=%d)\n", rc);
                 return rc;
         }
 
         /* determine by signature whether we have ATA or ATAPI devices */
-        classes[0] = ata_dev_try_classify(ap, 0, &err);
+        classes[0] = ata_dev_try_classify(&link->device[0],
+                                          devmask & (1 << 0), &err);
         if (slave_possible && err != 0x81)
-                classes[1] = ata_dev_try_classify(ap, 1, &err);
+                classes[1] = ata_dev_try_classify(&link->device[1],
+                                                  devmask & (1 << 1), &err);
 
  out:
         DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
@@ -3426,12 +3587,12 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
 }
 
 /**
- *      sata_port_hardreset - reset port via SATA phy reset
- *      @ap: port to reset
+ *      sata_link_hardreset - reset link via SATA phy reset
+ *      @link: link to reset
  *      @timing: timing parameters { interval, duratinon, timeout } in msec
  *      @deadline: deadline jiffies for the operation
  *
- *      SATA phy-reset host port using DET bits of SControl register.
+ *      SATA phy-reset @link using DET bits of SControl register.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep)
@@ -3439,7 +3600,7 @@ int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
+int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
                         unsigned long deadline)
 {
         u32 scontrol;
@@ -3447,30 +3608,30 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
 
         DPRINTK("ENTER\n");
 
-        if (sata_set_spd_needed(ap)) {
+        if (sata_set_spd_needed(link)) {
                 /* SATA spec says nothing about how to reconfigure
                  * spd.  To be on the safe side, turn off phy during
                  * reconfiguration.  This works for at least ICH7 AHCI
                  * and Sil3124.
                  */
-                if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+                if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
                         goto out;
 
                 scontrol = (scontrol & 0x0f0) | 0x304;
 
-                if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
+                if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
                         goto out;
 
-                sata_set_spd(ap);
+                sata_set_spd(link);
         }
 
         /* issue phy wake/reset */
-        if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+        if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
                 goto out;
 
         scontrol = (scontrol & 0x0f0) | 0x301;
 
-        if ((rc = sata_scr_write_flush(ap, SCR_CONTROL, scontrol)))
+        if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol)))
                 goto out;
 
         /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
@@ -3478,8 +3639,8 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
          */
         msleep(1);
 
-        /* bring phy back */
-        rc = sata_phy_resume(ap, timing, deadline);
+        /* bring link back */
+        rc = sata_link_resume(link, timing, deadline);
  out:
         DPRINTK("EXIT, rc=%d\n", rc);
         return rc;
@@ -3487,7 +3648,7 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
 
 /**
  *      sata_std_hardreset - reset host port via SATA phy reset
- *      @ap: port to reset
+ *      @link: link to reset
  *      @class: resulting class of attached device
  *      @deadline: deadline jiffies for the operation
  *
@@ -3500,24 +3661,25 @@ int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
+int sata_std_hardreset(struct ata_link *link, unsigned int *class,
                        unsigned long deadline)
 {
-        const unsigned long *timing = sata_ehc_deb_timing(&ap->eh_context);
+        struct ata_port *ap = link->ap;
+        const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
         int rc;
 
         DPRINTK("ENTER\n");
 
         /* do hardreset */
-        rc = sata_port_hardreset(ap, timing, deadline);
+        rc = sata_link_hardreset(link, timing, deadline);
         if (rc) {
-                ata_port_printk(ap, KERN_ERR,
+                ata_link_printk(link, KERN_ERR,
                                 "COMRESET failed (errno=%d)\n", rc);
                 return rc;
         }
 
         /* TODO: phy layer with polling, timeouts, etc. */
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 *class = ATA_DEV_NONE;
                 DPRINTK("EXIT, link offline\n");
                 return 0;
@@ -3526,17 +3688,27 @@ int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
         /* wait a while before checking status, see SRST for more info */
         msleep(150);
 
+        /* If PMP is supported, we have to do follow-up SRST.  Note
+         * that some PMPs don't send D2H Reg FIS after hardreset at
+         * all if the first port is empty.  Wait for it just for a
+         * second and request follow-up SRST.
+         */
+        if (ap->flags & ATA_FLAG_PMP) {
+                ata_wait_ready(ap, jiffies + HZ);
+                return -EAGAIN;
+        }
+
         rc = ata_wait_ready(ap, deadline);
         /* link occupied, -ENODEV too is an error */
         if (rc) {
-                ata_port_printk(ap, KERN_ERR,
+                ata_link_printk(link, KERN_ERR,
                                 "COMRESET failed (errno=%d)\n", rc);
                 return rc;
         }
 
         ap->ops->dev_select(ap, 0);     /* probably unnecessary */
 
-        *class = ata_dev_try_classify(ap, 0, NULL);
+        *class = ata_dev_try_classify(link->device, 1, NULL);
 
         DPRINTK("EXIT, class=%u\n", *class);
         return 0;
@@ -3544,7 +3716,7 @@ int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
 
 /**
  *      ata_std_postreset - standard postreset callback
- *      @ap: the target ata_port
+ *      @link: the target ata_link
  *      @classes: classes of attached devices
  *
  *      This function is invoked after a successful reset.  Note that
@@ -3554,18 +3726,19 @@ int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
  *      LOCKING:
  *      Kernel thread context (may sleep)
  */
-void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
+void ata_std_postreset(struct ata_link *link, unsigned int *classes)
 {
+        struct ata_port *ap = link->ap;
         u32 serror;
 
         DPRINTK("ENTER\n");
 
         /* print link status */
-        sata_print_link_status(ap);
+        sata_print_link_status(link);
 
         /* clear SError */
-        if (sata_scr_read(ap, SCR_ERROR, &serror) == 0)
-                sata_scr_write(ap, SCR_ERROR, serror);
+        if (sata_scr_read(link, SCR_ERROR, &serror) == 0)
+                sata_scr_write(link, SCR_ERROR, serror);
 
         /* is double-select really necessary? */
         if (classes[0] != ATA_DEV_NONE)
@@ -3652,7 +3825,7 @@ static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
 int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
 {
         unsigned int class = dev->class;
-        u16 *id = (void *)dev->ap->sector_buf;
+        u16 *id = (void *)dev->link->ap->sector_buf;
         int rc;
 
         /* read ID data */
@@ -3671,6 +3844,7 @@ int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
 /**
  *      ata_dev_revalidate - Revalidate ATA device
  *      @dev: device to revalidate
+ *      @new_class: new class code
  *      @readid_flags: read ID flags
  *
  *      Re-read IDENTIFY page, make sure @dev is still attached to the
@@ -3682,7 +3856,8 @@ int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
  *      RETURNS:
  *      0 on success, negative errno otherwise
  */
-int ata_dev_revalidate(struct ata_device *dev, unsigned int readid_flags)
+int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
+                       unsigned int readid_flags)
 {
         u64 n_sectors = dev->n_sectors;
         int rc;
@@ -3690,6 +3865,15 @@ int ata_dev_revalidate(struct ata_device *dev, unsigned int readid_flags)
         if (!ata_dev_enabled(dev))
                 return -ENODEV;
 
+        /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */
+        if (ata_class_enabled(new_class) &&
+            new_class != ATA_DEV_ATA && new_class != ATA_DEV_ATAPI) {
+                ata_dev_printk(dev, KERN_INFO, "class mismatch %u != %u\n",
+                               dev->class, new_class);
+                rc = -ENODEV;
+                goto fail;
+        }
+
         /* re-read ID */
         rc = ata_dev_reread_id(dev, readid_flags);
         if (rc)
@@ -3763,6 +3947,9 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "IOMEGA  ZIP 250       ATAPI", NULL,  ATA_HORKAGE_NODMA }, /* temporary fix */
         { "IOMEGA  ZIP 250       ATAPI       Floppy",
                                 NULL,           ATA_HORKAGE_NODMA },
+        /* Odd clown on sil3726/4726 PMPs */
+        { "Config  Disk",       NULL,           ATA_HORKAGE_NODMA |
+                                                ATA_HORKAGE_SKIP_PM },
 
         /* Weird ATAPI devices */
         { "TORiSAN DVD-ROM DRD-N216", NULL,     ATA_HORKAGE_MAX_SEC_128 },
@@ -3775,16 +3962,12 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         /* http://thread.gmane.org/gmane.linux.ide/14907 */
         { "FUJITSU MHT2060BH",  NULL,           ATA_HORKAGE_NONCQ },
         /* NCQ is broken */
-        { "Maxtor 6L250S0",     "BANC1G10",     ATA_HORKAGE_NONCQ },
-        { "Maxtor 6B200M0",     "BANC1BM0",     ATA_HORKAGE_NONCQ },
-        { "Maxtor 6B200M0",     "BANC1B10",     ATA_HORKAGE_NONCQ },
-        { "Maxtor 7B250S0",     "BANC1B70",     ATA_HORKAGE_NONCQ, },
-        { "Maxtor 7B300S0",     "BANC1B70",     ATA_HORKAGE_NONCQ },
+        { "Maxtor *",           "BANC*",        ATA_HORKAGE_NONCQ },
         { "Maxtor 7V300F0",     "VA111630",     ATA_HORKAGE_NONCQ },
-        { "HITACHI HDS7250SASUN500G 0621KTAWSD", "K2AOAJ0AHITACHI",
-         ATA_HORKAGE_NONCQ },
-        /* NCQ hard hangs device under heavier load, needs hard power cycle */
-        { "Maxtor 6B250S0",     "BANC1B70",     ATA_HORKAGE_NONCQ },
+        { "HITACHI HDS7250SASUN500G*", NULL,    ATA_HORKAGE_NONCQ },
+        { "HITACHI HDS7225SBSUN250G*", NULL,    ATA_HORKAGE_NONCQ },
+        { "ST380817AS",         "3.42",         ATA_HORKAGE_NONCQ },
+
         /* Blacklist entries taken from Silicon Image 3124/3132
            Windows driver .inf file - also several Linux problem reports */
         { "HTS541060G9SA00",    "MB3OC60D",     ATA_HORKAGE_NONCQ, },
@@ -3793,11 +3976,16 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         /* Drives which do spurious command completion */
         { "HTS541680J9SA00",    "SB2IC7EP",     ATA_HORKAGE_NONCQ, },
         { "HTS541612J9SA00",    "SBDIC7JP",     ATA_HORKAGE_NONCQ, },
+        { "HDT722516DLA380",    "V43OA96A",     ATA_HORKAGE_NONCQ, },
         { "Hitachi HTS541616J9SA00", "SB4OC70P", ATA_HORKAGE_NONCQ, },
         { "WDC WD740ADFD-00NLR1", NULL,         ATA_HORKAGE_NONCQ, },
+        { "WDC WD3200AAJS-00RYA0", "12.01B01",  ATA_HORKAGE_NONCQ, },
         { "FUJITSU MHV2080BH",  "00840028",     ATA_HORKAGE_NONCQ, },
+        { "ST9120822AS",        "3.CLF",        ATA_HORKAGE_NONCQ, },
         { "ST9160821AS",        "3.CLF",        ATA_HORKAGE_NONCQ, },
-        { "ST3160812AS",        "3.AD",         ATA_HORKAGE_NONCQ, },
+        { "ST9160821AS",        "3.ALD",        ATA_HORKAGE_NONCQ, },
+        { "ST3160812AS",        "3.ADJ",        ATA_HORKAGE_NONCQ, },
+        { "ST980813AS",         "3.ADB",        ATA_HORKAGE_NONCQ, },
         { "SAMSUNG HD401LJ",    "ZZ100-15",     ATA_HORKAGE_NONCQ, },
 
         /* devices which puke on READ_NATIVE_MAX */
@@ -3806,10 +3994,31 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
         { "MAXTOR 6L080L4",     "A93.0500",     ATA_HORKAGE_BROKEN_HPA },
 
+        /* Devices which report 1 sector over size HPA */
+        { "ST340823A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
+        { "ST320413A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
+
         /* End Marker */
         { }
 };
 
+int strn_pattern_cmp(const char *patt, const char *name, int wildchar)
+{
+        const char *p;
+        int len;
+
+        /*
+         * check for trailing wildcard: *\0
+         */
+        p = strchr(patt, wildchar);
+        if (p && ((*(p + 1)) == 0))
+                len = p - patt;
+        else
+                len = strlen(name);
+
+        return strncmp(patt, name, len);
+}
+
 static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
 {
         unsigned char model_num[ATA_ID_PROD_LEN + 1];
@@ -3820,10 +4029,10 @@ static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
         ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
 
         while (ad->model_num) {
-                if (!strcmp(ad->model_num, model_num)) {
+                if (!strn_pattern_cmp(ad->model_num, model_num, '*')) {
                         if (ad->model_rev == NULL)
                                 return ad->horkage;
-                        if (!strcmp(ad->model_rev, model_rev))
+                        if (!strn_pattern_cmp(ad->model_rev, model_rev, '*'))
                                 return ad->horkage;
                 }
                 ad++;
@@ -3837,7 +4046,7 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
          * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)
          * if the LLDD handles only interrupts in the HSM_ST_LAST state.
          */
-        if ((dev->ap->flags & ATA_FLAG_PIO_POLLING) &&
+        if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
             (dev->flags & ATA_DFLAG_CDB_INTR))
                 return 1;
         return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
@@ -3857,7 +4066,8 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
  */
 static void ata_dev_xfermask(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
         struct ata_host *host = ap->host;
         unsigned long xfer_mask;
 
@@ -3955,7 +4165,43 @@ static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
         tf.protocol = ATA_PROT_NODATA;
         tf.nsect = dev->xfer_mode;
 
-        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
+
+        DPRINTK("EXIT, err_mask=%x\n", err_mask);
+        return err_mask;
+}
+
+/**
+ *      ata_dev_set_AN - Issue SET FEATURES - SATA FEATURES
+ *      @dev: Device to which command will be sent
+ *      @enable: Whether to enable or disable the feature
+ *
+ *      Issue SET FEATURES - SATA FEATURES command to device @dev
+ *      on port @ap with sector count set to indicate Asynchronous
+ *      Notification feature
+ *
+ *      LOCKING:
+ *      PCI/etc. bus probe sem.
+ *
+ *      RETURNS:
+ *      0 on success, AC_ERR_* mask otherwise.
+ */
+static unsigned int ata_dev_set_AN(struct ata_device *dev, u8 enable)
+{
+        struct ata_taskfile tf;
+        unsigned int err_mask;
+
+        /* set up set-features taskfile */
+        DPRINTK("set features - SATA features\n");
+
+        ata_tf_init(dev, &tf);
+        tf.command = ATA_CMD_SET_FEATURES;
+        tf.feature = enable;
+        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+        tf.protocol = ATA_PROT_NODATA;
+        tf.nsect = SATA_AN;
+
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
 
         DPRINTK("EXIT, err_mask=%x\n", err_mask);
         return err_mask;
@@ -3993,7 +4239,7 @@ static unsigned int ata_dev_init_params(struct ata_device *dev,
         tf.nsect = sectors;
         tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
 
-        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
+        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
         /* A clean abort indicates an original or just out of spec drive
            and we should continue as we issue the setup based on the
            drive reported working geometry */
@@ -4207,6 +4453,36 @@ int ata_check_atapi_dma(struct ata_queued_cmd *qc)
 }
 
 /**
+ *      ata_std_qc_defer - Check whether a qc needs to be deferred
+ *      @qc: ATA command in question
+ *
+ *      Non-NCQ commands cannot run with any other command, NCQ or
+ *      not.  As upper layer only knows the queue depth, we are
+ *      responsible for maintaining exclusion.  This function checks
+ *      whether a new command @qc can be issued.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ *      RETURNS:
+ *      ATA_DEFER_* if deferring is needed, 0 otherwise.
+ */
+int ata_std_qc_defer(struct ata_queued_cmd *qc)
+{
+        struct ata_link *link = qc->dev->link;
+
+        if (qc->tf.protocol == ATA_PROT_NCQ) {
+                if (!ata_tag_valid(link->active_tag))
+                        return 0;
+        } else {
+                if (!ata_tag_valid(link->active_tag) && !link->sactive)
+                        return 0;
+        }
+
+        return ATA_DEFER_LINK;
+}
+
+/**
  *      ata_qc_prep - Prepare taskfile for submission
  *      @qc: Metadata associated with taskfile to be prepared
  *
@@ -4482,7 +4758,7 @@ void swap_buf_le16(u16 *buf, unsigned int buf_words)
 void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
                    unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         unsigned int words = buflen >> 1;
 
         /* Transfer multiple of 2 bytes */
@@ -4611,6 +4887,8 @@ static void ata_pio_sectors(struct ata_queued_cmd *qc)
                         ata_pio_sector(qc);
         } else
                 ata_pio_sector(qc);
+
+        ata_altstatus(qc->ap); /* flush */
 }
 
 /**
@@ -4785,6 +5063,7 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc)
         VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes);
 
         __atapi_pio_bytes(qc, bytes);
+        ata_altstatus(ap); /* flush */
 
         return;
 
@@ -4956,7 +5235,6 @@ fsm_start:
                          */
                         ap->hsm_task_state = HSM_ST;
                         ata_pio_sectors(qc);
-                        ata_altstatus(ap); /* flush */
                 } else
                         /* send CDB */
                         atapi_send_cdb(ap, qc);
@@ -5037,7 +5315,6 @@ fsm_start:
 
                                 if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
                                         ata_pio_sectors(qc);
-                                        ata_altstatus(ap);
                                         status = ata_wait_idle(ap);
                                 }
 
@@ -5057,13 +5334,11 @@ fsm_start:
                         if (ap->hsm_task_state == HSM_ST_LAST &&
                             (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
                                 /* all data read */
-                                ata_altstatus(ap);
                                 status = ata_wait_idle(ap);
                                 goto fsm_start;
                         }
                 }
 
-                ata_altstatus(ap); /* flush */
                 poll_next = 1;
                 break;
 
@@ -5188,7 +5463,7 @@ static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
 
 struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         struct ata_queued_cmd *qc;
 
         qc = ata_qc_new(ap);
@@ -5231,6 +5506,7 @@ void ata_qc_free(struct ata_queued_cmd *qc)
 void __ata_qc_complete(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
+        struct ata_link *link = qc->dev->link;
 
         WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
         WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
@@ -5239,10 +5515,19 @@ void __ata_qc_complete(struct ata_queued_cmd *qc)
                 ata_sg_clean(qc);
 
         /* command should be marked inactive atomically with qc completion */
-        if (qc->tf.protocol == ATA_PROT_NCQ)
-                ap->sactive &= ~(1 << qc->tag);
-        else
-                ap->active_tag = ATA_TAG_POISON;
+        if (qc->tf.protocol == ATA_PROT_NCQ) {
+                link->sactive &= ~(1 << qc->tag);
+                if (!link->sactive)
+                        ap->nr_active_links--;
+        } else {
+                link->active_tag = ATA_TAG_POISON;
+                ap->nr_active_links--;
+        }
+
+        /* clear exclusive status */
+        if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
+                     ap->excl_link == link))
+                ap->excl_link = NULL;
 
         /* atapi: mark qc as inactive to prevent the interrupt handler
          * from completing the command twice later, before the error handler
@@ -5411,19 +5696,25 @@ static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
 void ata_qc_issue(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
+        struct ata_link *link = qc->dev->link;
 
         /* Make sure only one non-NCQ command is outstanding.  The
          * check is skipped for old EH because it reuses active qc to
          * request ATAPI sense.
          */
-        WARN_ON(ap->ops->error_handler && ata_tag_valid(ap->active_tag));
+        WARN_ON(ap->ops->error_handler && ata_tag_valid(link->active_tag));
 
         if (qc->tf.protocol == ATA_PROT_NCQ) {
-                WARN_ON(ap->sactive & (1 << qc->tag));
-                ap->sactive |= 1 << qc->tag;
+                WARN_ON(link->sactive & (1 << qc->tag));
+
+                if (!link->sactive)
+                        ap->nr_active_links++;
+                link->sactive |= 1 << qc->tag;
         } else {
-                WARN_ON(ap->sactive);
-                ap->active_tag = qc->tag;
+                WARN_ON(link->sactive);
+
+                ap->nr_active_links++;
+                link->active_tag = qc->tag;
         }
 
         qc->flags |= ATA_QCFLAG_ACTIVE;
@@ -5606,7 +5897,7 @@ unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
 inline unsigned int ata_host_intr (struct ata_port *ap,
                                    struct ata_queued_cmd *qc)
 {
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
         u8 status, host_stat = 0;
 
         VPRINTK("ata%u: protocol %d task_state %d\n",
@@ -5680,7 +5971,8 @@ idle_irq:
 
 #ifdef ATA_IRQ_TRAP
         if ((ap->stats.idle_irq % 1000) == 0) {
-                ap->ops->irq_ack(ap, 0); /* debug trap */
+                ata_chk_status(ap);
+                ap->ops->irq_clear(ap);
                 ata_port_printk(ap, KERN_WARNING, "irq trap\n");
                 return 1;
         }
@@ -5721,7 +6013,7 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance)
                     !(ap->flags & ATA_FLAG_DISABLED)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
                             (qc->flags & ATA_QCFLAG_ACTIVE))
                                 handled |= ata_host_intr(ap, qc);
@@ -5735,9 +6027,9 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance)
 
 /**
  *      sata_scr_valid - test whether SCRs are accessible
- *      @ap: ATA port to test SCR accessibility for
+ *      @link: ATA link to test SCR accessibility for
  *
- *      Test whether SCRs are accessible for @ap.
+ *      Test whether SCRs are accessible for @link.
  *
  *      LOCKING:
  *      None.
@@ -5745,60 +6037,74 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance)
  *      RETURNS:
  *      1 if SCRs are accessible, 0 otherwise.
  */
-int sata_scr_valid(struct ata_port *ap)
+int sata_scr_valid(struct ata_link *link)
 {
+        struct ata_port *ap = link->ap;
+
         return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read;
 }
 
 /**
  *      sata_scr_read - read SCR register of the specified port
- *      @ap: ATA port to read SCR for
+ *      @link: ATA link to read SCR for
  *      @reg: SCR to read
  *      @val: Place to store read value
  *
- *      Read SCR register @reg of @ap into *@val.  This function is
- *      guaranteed to succeed if the cable type of the port is SATA
- *      and the port implements ->scr_read.
+ *      Read SCR register @reg of @link into *@val.  This function is
+ *      guaranteed to succeed if @link is ap->link, the cable type of
+ *      the port is SATA and the port implements ->scr_read.
  *
  *      LOCKING:
- *      None.
+ *      None if @link is ap->link.  Kernel thread context otherwise.
  *
  *      RETURNS:
  *      0 on success, negative errno on failure.
  */
-int sata_scr_read(struct ata_port *ap, int reg, u32 *val)
+int sata_scr_read(struct ata_link *link, int reg, u32 *val)
 {
-        if (sata_scr_valid(ap))
-                return ap->ops->scr_read(ap, reg, val);
-        return -EOPNOTSUPP;
+        if (ata_is_host_link(link)) {
+                struct ata_port *ap = link->ap;
+
+                if (sata_scr_valid(link))
+                        return ap->ops->scr_read(ap, reg, val);
+                return -EOPNOTSUPP;
+        }
+
+        return sata_pmp_scr_read(link, reg, val);
 }
 
 /**
  *      sata_scr_write - write SCR register of the specified port
- *      @ap: ATA port to write SCR for
+ *      @link: ATA link to write SCR for
  *      @reg: SCR to write
  *      @val: value to write
  *
- *      Write @val to SCR register @reg of @ap.  This function is
- *      guaranteed to succeed if the cable type of the port is SATA
- *      and the port implements ->scr_read.
+ *      Write @val to SCR register @reg of @link.  This function is
+ *      guaranteed to succeed if @link is ap->link, the cable type of
+ *      the port is SATA and the port implements ->scr_read.
  *
  *      LOCKING:
- *      None.
+ *      None if @link is ap->link.  Kernel thread context otherwise.
  *
  *      RETURNS:
  *      0 on success, negative errno on failure.
  */
-int sata_scr_write(struct ata_port *ap, int reg, u32 val)
+int sata_scr_write(struct ata_link *link, int reg, u32 val)
 {
-        if (sata_scr_valid(ap))
-                return ap->ops->scr_write(ap, reg, val);
-        return -EOPNOTSUPP;
+        if (ata_is_host_link(link)) {
+                struct ata_port *ap = link->ap;
+
+                if (sata_scr_valid(link))
+                        return ap->ops->scr_write(ap, reg, val);
+                return -EOPNOTSUPP;
+        }
+
+        return sata_pmp_scr_write(link, reg, val);
 }
 
 /**
  *      sata_scr_write_flush - write SCR register of the specified port and flush
- *      @ap: ATA port to write SCR for
+ *      @link: ATA link to write SCR for
  *      @reg: SCR to write
  *      @val: value to write
  *
@@ -5806,31 +6112,36 @@ int sata_scr_write(struct ata_port *ap, int reg, u32 val)
  *      function performs flush after writing to the register.
  *
  *      LOCKING:
- *      None.
+ *      None if @link is ap->link.  Kernel thread context otherwise.
  *
  *      RETURNS:
  *      0 on success, negative errno on failure.
  */
-int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
+int sata_scr_write_flush(struct ata_link *link, int reg, u32 val)
 {
-        int rc;
+        if (ata_is_host_link(link)) {
+                struct ata_port *ap = link->ap;
+                int rc;
 
-        if (sata_scr_valid(ap)) {
-                rc = ap->ops->scr_write(ap, reg, val);
-                if (rc == 0)
-                        rc = ap->ops->scr_read(ap, reg, &val);
-                return rc;
+                if (sata_scr_valid(link)) {
+                        rc = ap->ops->scr_write(ap, reg, val);
+                        if (rc == 0)
+                                rc = ap->ops->scr_read(ap, reg, &val);
+                        return rc;
+                }
+                return -EOPNOTSUPP;
         }
-        return -EOPNOTSUPP;
+
+        return sata_pmp_scr_write(link, reg, val);
 }
 
 /**
- *      ata_port_online - test whether the given port is online
- *      @ap: ATA port to test
+ *      ata_link_online - test whether the given link is online
+ *      @link: ATA link to test
  *
- *      Test whether @ap is online.  Note that this function returns 0
- *      if online status of @ap cannot be obtained, so
- *      ata_port_online(ap) != !ata_port_offline(ap).
+ *      Test whether @link is online.  Note that this function returns
+ *      0 if online status of @link cannot be obtained, so
+ *      ata_link_online(link) != !ata_link_offline(link).
  *
  *      LOCKING:
  *      None.
@@ -5838,22 +6149,23 @@ int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
  *      RETURNS:
  *      1 if the port online status is available and online.
  */
-int ata_port_online(struct ata_port *ap)
+int ata_link_online(struct ata_link *link)
 {
         u32 sstatus;
 
-        if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) == 0x3)
+        if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
+            (sstatus & 0xf) == 0x3)
                 return 1;
         return 0;
 }
 
 /**
- *      ata_port_offline - test whether the given port is offline
- *      @ap: ATA port to test
+ *      ata_link_offline - test whether the given link is offline
+ *      @link: ATA link to test
  *
- *      Test whether @ap is offline.  Note that this function returns
- *      0 if offline status of @ap cannot be obtained, so
- *      ata_port_online(ap) != !ata_port_offline(ap).
+ *      Test whether @link is offline.  Note that this function
+ *      returns 0 if offline status of @link cannot be obtained, so
+ *      ata_link_online(link) != !ata_link_offline(link).
  *
  *      LOCKING:
  *      None.
@@ -5861,11 +6173,12 @@ int ata_port_online(struct ata_port *ap)
  *      RETURNS:
  *      1 if the port offline status is available and offline.
  */
-int ata_port_offline(struct ata_port *ap)
+int ata_link_offline(struct ata_link *link)
 {
         u32 sstatus;
 
-        if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) != 0x3)
+        if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
+            (sstatus & 0xf) != 0x3)
                 return 1;
         return 0;
 }
@@ -5883,6 +6196,10 @@ int ata_flush_cache(struct ata_device *dev)
         else
                 cmd = ATA_CMD_FLUSH;
 
+        /* This is wrong. On a failed flush we get back the LBA of the lost
+           sector and we should (assuming it wasn't aborted as unknown) issue
+           a further flush command to continue the writeback until it 
+           does not error */
         err_mask = ata_do_simple_cmd(dev, cmd);
         if (err_mask) {
                 ata_dev_printk(dev, KERN_ERR, "failed to flush cache\n");
@@ -5902,6 +6219,7 @@ static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg,
 
         for (i = 0; i < host->n_ports; i++) {
                 struct ata_port *ap = host->ports[i];
+                struct ata_link *link;
 
                 /* Previous resume operation might still be in
                  * progress.  Wait for PM_PENDING to clear.
@@ -5921,8 +6239,10 @@ static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg,
                 }
 
                 ap->pflags |= ATA_PFLAG_PM_PENDING;
-                ap->eh_info.action |= action;
-                ap->eh_info.flags |= ehi_flags;
+                __ata_port_for_each_link(link, ap) {
+                        link->eh_info.action |= action;
+                        link->eh_info.flags |= ehi_flags;
+                }
 
                 ata_port_schedule_eh(ap);
 
@@ -6026,12 +6346,13 @@ int ata_port_start(struct ata_port *ap)
  */
 void ata_dev_init(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
         unsigned long flags;
 
         /* SATA spd limit is bound to the first device */
-        ap->sata_spd_limit = ap->hw_sata_spd_limit;
-        ap->sata_spd = 0;
+        link->sata_spd_limit = link->hw_sata_spd_limit;
+        link->sata_spd = 0;
 
         /* High bits of dev->flags are used to record warm plug
          * requests which occur asynchronously.  Synchronize using
@@ -6050,6 +6371,70 @@ void ata_dev_init(struct ata_device *dev)
 }
 
 /**
+ *      ata_link_init - Initialize an ata_link structure
+ *      @ap: ATA port link is attached to
+ *      @link: Link structure to initialize
+ *      @pmp: Port multiplier port number
+ *
+ *      Initialize @link.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep)
+ */
+void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
+{
+        int i;
+
+        /* clear everything except for devices */
+        memset(link, 0, offsetof(struct ata_link, device[0]));
+
+        link->ap = ap;
+        link->pmp = pmp;
+        link->active_tag = ATA_TAG_POISON;
+        link->hw_sata_spd_limit = UINT_MAX;
+
+        /* can't use iterator, ap isn't initialized yet */
+        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                struct ata_device *dev = &link->device[i];
+
+                dev->link = link;
+                dev->devno = dev - link->device;
+                ata_dev_init(dev);
+        }
+}
+
+/**
+ *      sata_link_init_spd - Initialize link->sata_spd_limit
+ *      @link: Link to configure sata_spd_limit for
+ *
+ *      Initialize @link->[hw_]sata_spd_limit to the currently
+ *      configured value.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+int sata_link_init_spd(struct ata_link *link)
+{
+        u32 scontrol, spd;
+        int rc;
+
+        rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
+        if (rc)
+                return rc;
+
+        spd = (scontrol >> 4) & 0xf;
+        if (spd)
+                link->hw_sata_spd_limit &= (1 << spd) - 1;
+
+        link->sata_spd_limit = link->hw_sata_spd_limit;
+
+        return 0;
+}
+
+/**
  *      ata_port_alloc - allocate and initialize basic ATA port resources
  *      @host: ATA host this allocated port belongs to
  *
@@ -6064,7 +6449,6 @@ void ata_dev_init(struct ata_device *dev)
 struct ata_port *ata_port_alloc(struct ata_host *host)
 {
         struct ata_port *ap;
-        unsigned int i;
 
         DPRINTK("ENTER\n");
 
@@ -6079,9 +6463,6 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
         ap->ctl = ATA_DEVCTL_OBS;
         ap->host = host;
         ap->dev = host->dev;
-
-        ap->hw_sata_spd_limit = UINT_MAX;
-        ap->active_tag = ATA_TAG_POISON;
         ap->last_ctl = 0xFF;
 
 #if defined(ATA_VERBOSE_DEBUG)
@@ -6104,12 +6485,7 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
 
         ap->cbl = ATA_CBL_NONE;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
-                dev->ap = ap;
-                dev->devno = i;
-                ata_dev_init(dev);
-        }
+        ata_link_init(ap, &ap->link, 0);
 
 #ifdef ATA_IRQ_TRAP
         ap->stats.unhandled_irq = 1;
@@ -6145,6 +6521,7 @@ static void ata_host_release(struct device *gendev, void *res)
                 if (ap->scsi_host)
                         scsi_host_put(ap->scsi_host);
 
+                kfree(ap->pmp_link);
                 kfree(ap);
                 host->ports[i] = NULL;
         }
@@ -6255,6 +6632,7 @@ struct ata_host *ata_host_alloc_pinfo(struct device *dev,
                 ap->mwdma_mask = pi->mwdma_mask;
                 ap->udma_mask = pi->udma_mask;
                 ap->flags |= pi->flags;
+                ap->link.flags |= pi->link_flags;
                 ap->ops = pi->port_ops;
 
                 if (!host->ops && (pi->port_ops != &ata_dummy_port_ops))
@@ -6390,8 +6768,6 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
         /* set cable, sata_spd_limit and report */
         for (i = 0; i < host->n_ports; i++) {
                 struct ata_port *ap = host->ports[i];
-                int irq_line;
-                u32 scontrol;
                 unsigned long xfer_mask;
 
                 /* set SATA cable type if still unset */
@@ -6399,32 +6775,20 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
                         ap->cbl = ATA_CBL_SATA;
 
                 /* init sata_spd_limit to the current value */
-                if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
-                        int spd = (scontrol >> 4) & 0xf;
-                        if (spd)
-                                ap->hw_sata_spd_limit &= (1 << spd) - 1;
-                }
-                ap->sata_spd_limit = ap->hw_sata_spd_limit;
-
-                /* report the secondary IRQ for second channel legacy */
-                irq_line = host->irq;
-                if (i == 1 && host->irq2)
-                        irq_line = host->irq2;
+                sata_link_init_spd(&ap->link);
 
+                /* print per-port info to dmesg */
                 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
                                               ap->udma_mask);
 
-                /* print per-port info to dmesg */
-                if (!ata_port_is_dummy(ap))
-                        ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%p "
-                                        "ctl 0x%p bmdma 0x%p irq %d\n",
+                if (!ata_port_is_dummy(ap)) {
+                        ata_port_printk(ap, KERN_INFO,
+                                        "%cATA max %s %s\n",
                                         (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
                                         ata_mode_string(xfer_mask),
-                                        ap->ioaddr.cmd_addr,
-                                        ap->ioaddr.ctl_addr,
-                                        ap->ioaddr.bmdma_addr,
-                                        irq_line);
-                else
+                                        ap->link.eh_info.desc);
+                        ata_ehi_clear_desc(&ap->link.eh_info);
+                } else
                         ata_port_printk(ap, KERN_INFO, "DUMMY\n");
         }
 
@@ -6436,7 +6800,7 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
 
                 /* probe */
                 if (ap->ops->error_handler) {
-                        struct ata_eh_info *ehi = &ap->eh_info;
+                        struct ata_eh_info *ehi = &ap->link.eh_info;
                         unsigned long flags;
 
                         ata_port_probe(ap);
@@ -6444,7 +6808,8 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
                         /* kick EH for boot probing */
                         spin_lock_irqsave(ap->lock, flags);
 
-                        ehi->probe_mask = (1 << ATA_MAX_DEVICES) - 1;
+                        ehi->probe_mask =
+                                (1 << ata_link_max_devices(&ap->link)) - 1;
                         ehi->action |= ATA_EH_SOFTRESET;
                         ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
 
@@ -6506,7 +6871,7 @@ int ata_host_activate(struct ata_host *host, int irq,
                       irq_handler_t irq_handler, unsigned long irq_flags,
                       struct scsi_host_template *sht)
 {
-        int rc;
+        int i, rc;
 
         rc = ata_host_start(host);
         if (rc)
@@ -6517,8 +6882,8 @@ int ata_host_activate(struct ata_host *host, int irq,
         if (rc)
                 return rc;
 
-        /* Used to print device info at probe */
-        host->irq = irq;
+        for (i = 0; i < host->n_ports; i++)
+                ata_port_desc(host->ports[i], "irq %d", irq);
 
         rc = ata_host_register(host, sht);
         /* if failed, just free the IRQ and leave ports alone */
@@ -6542,7 +6907,8 @@ int ata_host_activate(struct ata_host *host, int irq,
 void ata_port_detach(struct ata_port *ap)
 {
         unsigned long flags;
-        int i;
+        struct ata_link *link;
+        struct ata_device *dev;
 
         if (!ap->ops->error_handler)
                 goto skip_eh;
@@ -6559,8 +6925,10 @@ void ata_port_detach(struct ata_port *ap)
          */
         spin_lock_irqsave(ap->lock, flags);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ata_dev_disable(&ap->device[i]);
+        ata_port_for_each_link(link, ap) {
+                ata_link_for_each_dev(dev, link)
+                        ata_dev_disable(dev);
+        }
 
         spin_unlock_irqrestore(ap->lock, flags);
 
@@ -6639,7 +7007,7 @@ void ata_std_ports(struct ata_ioports *ioaddr)
  */
 void ata_pci_remove_one(struct pci_dev *pdev)
 {
-        struct device *dev = pci_dev_to_dev(pdev);
+        struct device *dev = &pdev->dev;
         struct ata_host *host = dev_get_drvdata(dev);
 
         ata_host_detach(host);
@@ -6847,7 +7215,6 @@ static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
 }
 
 const struct ata_port_operations ata_dummy_port_ops = {
-        .port_disable           = ata_port_disable,
         .check_status           = ata_dummy_check_status,
         .check_altstatus        = ata_dummy_check_status,
         .dev_select             = ata_noop_dev_select,
@@ -6909,6 +7276,7 @@ EXPORT_SYMBOL_GPL(ata_interrupt);
 EXPORT_SYMBOL_GPL(ata_do_set_mode);
 EXPORT_SYMBOL_GPL(ata_data_xfer);
 EXPORT_SYMBOL_GPL(ata_data_xfer_noirq);
+EXPORT_SYMBOL_GPL(ata_std_qc_defer);
 EXPORT_SYMBOL_GPL(ata_qc_prep);
 EXPORT_SYMBOL_GPL(ata_dumb_qc_prep);
 EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
@@ -6925,14 +7293,14 @@ EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
 EXPORT_SYMBOL_GPL(ata_port_probe);
 EXPORT_SYMBOL_GPL(ata_dev_disable);
 EXPORT_SYMBOL_GPL(sata_set_spd);
-EXPORT_SYMBOL_GPL(sata_phy_debounce);
-EXPORT_SYMBOL_GPL(sata_phy_resume);
+EXPORT_SYMBOL_GPL(sata_link_debounce);
+EXPORT_SYMBOL_GPL(sata_link_resume);
 EXPORT_SYMBOL_GPL(sata_phy_reset);
 EXPORT_SYMBOL_GPL(__sata_phy_reset);
 EXPORT_SYMBOL_GPL(ata_bus_reset);
 EXPORT_SYMBOL_GPL(ata_std_prereset);
 EXPORT_SYMBOL_GPL(ata_std_softreset);
-EXPORT_SYMBOL_GPL(sata_port_hardreset);
+EXPORT_SYMBOL_GPL(sata_link_hardreset);
 EXPORT_SYMBOL_GPL(sata_std_hardreset);
 EXPORT_SYMBOL_GPL(ata_std_postreset);
 EXPORT_SYMBOL_GPL(ata_dev_classify);
@@ -6953,8 +7321,8 @@ EXPORT_SYMBOL_GPL(sata_scr_valid);
 EXPORT_SYMBOL_GPL(sata_scr_read);
 EXPORT_SYMBOL_GPL(sata_scr_write);
 EXPORT_SYMBOL_GPL(sata_scr_write_flush);
-EXPORT_SYMBOL_GPL(ata_port_online);
-EXPORT_SYMBOL_GPL(ata_port_offline);
+EXPORT_SYMBOL_GPL(ata_link_online);
+EXPORT_SYMBOL_GPL(ata_link_offline);
 #ifdef CONFIG_PM
 EXPORT_SYMBOL_GPL(ata_host_suspend);
 EXPORT_SYMBOL_GPL(ata_host_resume);
@@ -6985,22 +7353,31 @@ EXPORT_SYMBOL_GPL(ata_pci_default_filter);
 EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
 #endif /* CONFIG_PCI */
 
+EXPORT_SYMBOL_GPL(sata_pmp_qc_defer_cmd_switch);
+EXPORT_SYMBOL_GPL(sata_pmp_std_prereset);
+EXPORT_SYMBOL_GPL(sata_pmp_std_hardreset);
+EXPORT_SYMBOL_GPL(sata_pmp_std_postreset);
+EXPORT_SYMBOL_GPL(sata_pmp_do_eh);
+
 EXPORT_SYMBOL_GPL(__ata_ehi_push_desc);
 EXPORT_SYMBOL_GPL(ata_ehi_push_desc);
 EXPORT_SYMBOL_GPL(ata_ehi_clear_desc);
+EXPORT_SYMBOL_GPL(ata_port_desc);
+#ifdef CONFIG_PCI
+EXPORT_SYMBOL_GPL(ata_port_pbar_desc);
+#endif /* CONFIG_PCI */
 EXPORT_SYMBOL_GPL(ata_eng_timeout);
 EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
+EXPORT_SYMBOL_GPL(ata_link_abort);
 EXPORT_SYMBOL_GPL(ata_port_abort);
 EXPORT_SYMBOL_GPL(ata_port_freeze);
+EXPORT_SYMBOL_GPL(sata_async_notification);
 EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
 EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
 EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
 EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
 EXPORT_SYMBOL_GPL(ata_do_eh);
 EXPORT_SYMBOL_GPL(ata_irq_on);
-EXPORT_SYMBOL_GPL(ata_dummy_irq_on);
-EXPORT_SYMBOL_GPL(ata_irq_ack);
-EXPORT_SYMBOL_GPL(ata_dummy_irq_ack);
 EXPORT_SYMBOL_GPL(ata_dev_try_classify);
 
 EXPORT_SYMBOL_GPL(ata_cable_40wire);
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index ac6ceed4bb60..2eaa39fc65d0 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -33,6 +33,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/pci.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_eh.h>
@@ -74,7 +75,6 @@ static const unsigned long ata_eh_reset_timeouts[] = {
 };
 
 static void __ata_port_freeze(struct ata_port *ap);
-static void ata_eh_finish(struct ata_port *ap);
 #ifdef CONFIG_PM
 static void ata_eh_handle_port_suspend(struct ata_port *ap);
 static void ata_eh_handle_port_resume(struct ata_port *ap);
@@ -151,6 +151,73 @@ void ata_ehi_clear_desc(struct ata_eh_info *ehi)
         ehi->desc_len = 0;
 }
 
+/**
+ *      ata_port_desc - append port description
+ *      @ap: target ATA port
+ *      @fmt: printf format string
+ *
+ *      Format string according to @fmt and append it to port
+ *      description.  If port description is not empty, " " is added
+ *      in-between.  This function is to be used while initializing
+ *      ata_host.  The description is printed on host registration.
+ *
+ *      LOCKING:
+ *      None.
+ */
+void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
+{
+        va_list args;
+
+        WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
+
+        if (ap->link.eh_info.desc_len)
+                __ata_ehi_push_desc(&ap->link.eh_info, " ");
+
+        va_start(args, fmt);
+        __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
+        va_end(args);
+}
+
+#ifdef CONFIG_PCI
+
+/**
+ *      ata_port_pbar_desc - append PCI BAR description
+ *      @ap: target ATA port
+ *      @bar: target PCI BAR
+ *      @offset: offset into PCI BAR
+ *      @name: name of the area
+ *
+ *      If @offset is negative, this function formats a string which
+ *      contains the name, address, size and type of the BAR and
+ *      appends it to the port description.  If @offset is zero or
+ *      positive, only name and offsetted address is appended.
+ *
+ *      LOCKING:
+ *      None.
+ */
+void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
+                        const char *name)
+{
+        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
+        char *type = "";
+        unsigned long long start, len;
+
+        if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
+                type = "m";
+        else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
+                type = "i";
+
+        start = (unsigned long long)pci_resource_start(pdev, bar);
+        len = (unsigned long long)pci_resource_len(pdev, bar);
+
+        if (offset < 0)
+                ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
+        else
+                ata_port_desc(ap, "%s 0x%llx", name, start + offset);
+}
+
+#endif /* CONFIG_PCI */
+
 static void ata_ering_record(struct ata_ering *ering, int is_io,
                              unsigned int err_mask)
 {
@@ -195,28 +262,29 @@ static int ata_ering_map(struct ata_ering *ering,
 
 static unsigned int ata_eh_dev_action(struct ata_device *dev)
 {
-        struct ata_eh_context *ehc = &dev->ap->eh_context;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
 
         return ehc->i.action | ehc->i.dev_action[dev->devno];
 }
 
-static void ata_eh_clear_action(struct ata_device *dev,
+static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
                                 struct ata_eh_info *ehi, unsigned int action)
 {
-        int i;
+        struct ata_device *tdev;
 
         if (!dev) {
                 ehi->action &= ~action;
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        ehi->dev_action[i] &= ~action;
+                ata_link_for_each_dev(tdev, link)
+                        ehi->dev_action[tdev->devno] &= ~action;
         } else {
                 /* doesn't make sense for port-wide EH actions */
                 WARN_ON(!(action & ATA_EH_PERDEV_MASK));
 
                 /* break ehi->action into ehi->dev_action */
                 if (ehi->action & action) {
-                        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                                ehi->dev_action[i] |= ehi->action & action;
+                        ata_link_for_each_dev(tdev, link)
+                                ehi->dev_action[tdev->devno] |=
+                                        ehi->action & action;
                         ehi->action &= ~action;
                 }
 
@@ -261,7 +329,7 @@ enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
 
         ret = EH_HANDLED;
         spin_lock_irqsave(ap->lock, flags);
-        qc = ata_qc_from_tag(ap, ap->active_tag);
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
         if (qc) {
                 WARN_ON(qc->scsicmd != cmd);
                 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
@@ -290,7 +358,7 @@ enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
 void ata_scsi_error(struct Scsi_Host *host)
 {
         struct ata_port *ap = ata_shost_to_port(host);
-        int i, repeat_cnt = ATA_EH_MAX_REPEAT;
+        int i;
         unsigned long flags;
 
         DPRINTK("ENTER\n");
@@ -356,12 +424,17 @@ void ata_scsi_error(struct Scsi_Host *host)
                         __ata_port_freeze(ap);
 
                 spin_unlock_irqrestore(ap->lock, flags);
+
+                /* initialize eh_tries */
+                ap->eh_tries = ATA_EH_MAX_TRIES;
         } else
                 spin_unlock_wait(ap->lock);
 
  repeat:
         /* invoke error handler */
         if (ap->ops->error_handler) {
+                struct ata_link *link;
+
                 /* kill fast drain timer */
                 del_timer_sync(&ap->fastdrain_timer);
 
@@ -371,12 +444,15 @@ void ata_scsi_error(struct Scsi_Host *host)
                 /* fetch & clear EH info */
                 spin_lock_irqsave(ap->lock, flags);
 
-                memset(&ap->eh_context, 0, sizeof(ap->eh_context));
-                ap->eh_context.i = ap->eh_info;
-                memset(&ap->eh_info, 0, sizeof(ap->eh_info));
+                __ata_port_for_each_link(link, ap) {
+                        memset(&link->eh_context, 0, sizeof(link->eh_context));
+                        link->eh_context.i = link->eh_info;
+                        memset(&link->eh_info, 0, sizeof(link->eh_info));
+                }
 
                 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
                 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
+                ap->excl_link = NULL;   /* don't maintain exclusion over EH */
 
                 spin_unlock_irqrestore(ap->lock, flags);
 
@@ -396,20 +472,18 @@ void ata_scsi_error(struct Scsi_Host *host)
                 spin_lock_irqsave(ap->lock, flags);
 
                 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
-                        if (--repeat_cnt) {
-                                ata_port_printk(ap, KERN_INFO,
-                                        "EH pending after completion, "
-                                        "repeating EH (cnt=%d)\n", repeat_cnt);
+                        if (--ap->eh_tries) {
                                 spin_unlock_irqrestore(ap->lock, flags);
                                 goto repeat;
                         }
                         ata_port_printk(ap, KERN_ERR, "EH pending after %d "
-                                        "tries, giving up\n", ATA_EH_MAX_REPEAT);
+                                        "tries, giving up\n", ATA_EH_MAX_TRIES);
                         ap->pflags &= ~ATA_PFLAG_EH_PENDING;
                 }
 
                 /* this run is complete, make sure EH info is clear */
-                memset(&ap->eh_info, 0, sizeof(ap->eh_info));
+                __ata_port_for_each_link(link, ap)
+                        memset(&link->eh_info, 0, sizeof(link->eh_info));
 
                 /* Clear host_eh_scheduled while holding ap->lock such
                  * that if exception occurs after this point but
@@ -420,7 +494,7 @@ void ata_scsi_error(struct Scsi_Host *host)
 
                 spin_unlock_irqrestore(ap->lock, flags);
         } else {
-                WARN_ON(ata_qc_from_tag(ap, ap->active_tag) == NULL);
+                WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
                 ap->ops->eng_timeout(ap);
         }
 
@@ -575,7 +649,7 @@ void ata_eng_timeout(struct ata_port *ap)
 {
         DPRINTK("ENTER\n");
 
-        ata_qc_timeout(ata_qc_from_tag(ap, ap->active_tag));
+        ata_qc_timeout(ata_qc_from_tag(ap, ap->link.active_tag));
 
         DPRINTK("EXIT\n");
 }
@@ -718,19 +792,7 @@ void ata_port_schedule_eh(struct ata_port *ap)
         DPRINTK("port EH scheduled\n");
 }
 
-/**
- *      ata_port_abort - abort all qc's on the port
- *      @ap: ATA port to abort qc's for
- *
- *      Abort all active qc's of @ap and schedule EH.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- *
- *      RETURNS:
- *      Number of aborted qc's.
- */
-int ata_port_abort(struct ata_port *ap)
+static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
 {
         int tag, nr_aborted = 0;
 
@@ -742,7 +804,7 @@ int ata_port_abort(struct ata_port *ap)
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
 
-                if (qc) {
+                if (qc && (!link || qc->dev->link == link)) {
                         qc->flags |= ATA_QCFLAG_FAILED;
                         ata_qc_complete(qc);
                         nr_aborted++;
@@ -756,6 +818,40 @@ int ata_port_abort(struct ata_port *ap)
 }
 
 /**
+ *      ata_link_abort - abort all qc's on the link
+ *      @link: ATA link to abort qc's for
+ *
+ *      Abort all active qc's active on @link and schedule EH.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ *      RETURNS:
+ *      Number of aborted qc's.
+ */
+int ata_link_abort(struct ata_link *link)
+{
+        return ata_do_link_abort(link->ap, link);
+}
+
+/**
+ *      ata_port_abort - abort all qc's on the port
+ *      @ap: ATA port to abort qc's for
+ *
+ *      Abort all active qc's of @ap and schedule EH.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ *
+ *      RETURNS:
+ *      Number of aborted qc's.
+ */
+int ata_port_abort(struct ata_port *ap)
+{
+        return ata_do_link_abort(ap, NULL);
+}
+
+/**
  *      __ata_port_freeze - freeze port
  *      @ap: ATA port to freeze
  *
@@ -810,6 +906,79 @@ int ata_port_freeze(struct ata_port *ap)
 }
 
 /**
+ *      sata_async_notification - SATA async notification handler
+ *      @ap: ATA port where async notification is received
+ *
+ *      Handler to be called when async notification via SDB FIS is
+ *      received.  This function schedules EH if necessary.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ *      RETURNS:
+ *      1 if EH is scheduled, 0 otherwise.
+ */
+int sata_async_notification(struct ata_port *ap)
+{
+        u32 sntf;
+        int rc;
+
+        if (!(ap->flags & ATA_FLAG_AN))
+                return 0;
+
+        rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
+        if (rc == 0)
+                sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
+
+        if (!ap->nr_pmp_links || rc) {
+                /* PMP is not attached or SNTF is not available */
+                if (!ap->nr_pmp_links) {
+                        /* PMP is not attached.  Check whether ATAPI
+                         * AN is configured.  If so, notify media
+                         * change.
+                         */
+                        struct ata_device *dev = ap->link.device;
+
+                        if ((dev->class == ATA_DEV_ATAPI) &&
+                            (dev->flags & ATA_DFLAG_AN))
+                                ata_scsi_media_change_notify(dev);
+                        return 0;
+                } else {
+                        /* PMP is attached but SNTF is not available.
+                         * ATAPI async media change notification is
+                         * not used.  The PMP must be reporting PHY
+                         * status change, schedule EH.
+                         */
+                        ata_port_schedule_eh(ap);
+                        return 1;
+                }
+        } else {
+                /* PMP is attached and SNTF is available */
+                struct ata_link *link;
+
+                /* check and notify ATAPI AN */
+                ata_port_for_each_link(link, ap) {
+                        if (!(sntf & (1 << link->pmp)))
+                                continue;
+
+                        if ((link->device->class == ATA_DEV_ATAPI) &&
+                            (link->device->flags & ATA_DFLAG_AN))
+                                ata_scsi_media_change_notify(link->device);
+                }
+
+                /* If PMP is reporting that PHY status of some
+                 * downstream ports has changed, schedule EH.
+                 */
+                if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
+                        ata_port_schedule_eh(ap);
+                        return 1;
+                }
+
+                return 0;
+        }
+}
+
+/**
  *      ata_eh_freeze_port - EH helper to freeze port
  *      @ap: ATA port to freeze
  *
@@ -920,9 +1089,10 @@ void ata_eh_qc_retry(struct ata_queued_cmd *qc)
  *      LOCKING:
  *      None.
  */
-static void ata_eh_detach_dev(struct ata_device *dev)
+void ata_eh_detach_dev(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
         unsigned long flags;
 
         ata_dev_disable(dev);
@@ -937,31 +1107,32 @@ static void ata_eh_detach_dev(struct ata_device *dev)
         }
 
         /* clear per-dev EH actions */
-        ata_eh_clear_action(dev, &ap->eh_info, ATA_EH_PERDEV_MASK);
-        ata_eh_clear_action(dev, &ap->eh_context.i, ATA_EH_PERDEV_MASK);
+        ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
+        ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
 
         spin_unlock_irqrestore(ap->lock, flags);
 }
 
 /**
  *      ata_eh_about_to_do - about to perform eh_action
- *      @ap: target ATA port
+ *      @link: target ATA link
  *      @dev: target ATA dev for per-dev action (can be NULL)
  *      @action: action about to be performed
  *
  *      Called just before performing EH actions to clear related bits
- *      in @ap->eh_info such that eh actions are not unnecessarily
+ *      in @link->eh_info such that eh actions are not unnecessarily
  *      repeated.
  *
  *      LOCKING:
  *      None.
  */
-static void ata_eh_about_to_do(struct ata_port *ap, struct ata_device *dev,
-                               unsigned int action)
+void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
+                        unsigned int action)
 {
+        struct ata_port *ap = link->ap;
+        struct ata_eh_info *ehi = &link->eh_info;
+        struct ata_eh_context *ehc = &link->eh_context;
         unsigned long flags;
-        struct ata_eh_info *ehi = &ap->eh_info;
-        struct ata_eh_context *ehc = &ap->eh_context;
 
         spin_lock_irqsave(ap->lock, flags);
 
@@ -978,7 +1149,7 @@ static void ata_eh_about_to_do(struct ata_port *ap, struct ata_device *dev,
                 ehi->flags &= ~ATA_EHI_RESET_MODIFIER_MASK;
         }
 
-        ata_eh_clear_action(dev, ehi, action);
+        ata_eh_clear_action(link, dev, ehi, action);
 
         if (!(ehc->i.flags & ATA_EHI_QUIET))
                 ap->pflags |= ATA_PFLAG_RECOVERED;
@@ -988,26 +1159,28 @@ static void ata_eh_about_to_do(struct ata_port *ap, struct ata_device *dev,
 
 /**
  *      ata_eh_done - EH action complete
- *      @ap: target ATA port
+*       @ap: target ATA port
  *      @dev: target ATA dev for per-dev action (can be NULL)
  *      @action: action just completed
  *
  *      Called right after performing EH actions to clear related bits
- *      in @ap->eh_context.
+ *      in @link->eh_context.
  *
  *      LOCKING:
  *      None.
  */
-static void ata_eh_done(struct ata_port *ap, struct ata_device *dev,
-                        unsigned int action)
+void ata_eh_done(struct ata_link *link, struct ata_device *dev,
+                 unsigned int action)
 {
+        struct ata_eh_context *ehc = &link->eh_context;
+
         /* if reset is complete, clear all reset actions & reset modifier */
         if (action & ATA_EH_RESET_MASK) {
                 action |= ATA_EH_RESET_MASK;
-                ap->eh_context.i.flags &= ~ATA_EHI_RESET_MODIFIER_MASK;
+                ehc->i.flags &= ~ATA_EHI_RESET_MODIFIER_MASK;
         }
 
-        ata_eh_clear_action(dev, &ap->eh_context.i, action);
+        ata_eh_clear_action(link, dev, &ehc->i, action);
 }
 
 /**
@@ -1077,7 +1250,7 @@ static unsigned int ata_read_log_page(struct ata_device *dev,
         tf.protocol = ATA_PROT_PIO;
 
         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
-                                     buf, sectors * ATA_SECT_SIZE);
+                                     buf, sectors * ATA_SECT_SIZE, 0);
 
         DPRINTK("EXIT, err_mask=%x\n", err_mask);
         return err_mask;
@@ -1101,7 +1274,7 @@ static unsigned int ata_read_log_page(struct ata_device *dev,
 static int ata_eh_read_log_10h(struct ata_device *dev,
                                int *tag, struct ata_taskfile *tf)
 {
-        u8 *buf = dev->ap->sector_buf;
+        u8 *buf = dev->link->ap->sector_buf;
         unsigned int err_mask;
         u8 csum;
         int i;
@@ -1155,7 +1328,7 @@ static unsigned int atapi_eh_request_sense(struct ata_queued_cmd *qc)
 {
         struct ata_device *dev = qc->dev;
         unsigned char *sense_buf = qc->scsicmd->sense_buffer;
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         struct ata_taskfile tf;
         u8 cdb[ATAPI_CDB_LEN];
 
@@ -1191,12 +1364,12 @@ static unsigned int atapi_eh_request_sense(struct ata_queued_cmd *qc)
         }
 
         return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
-                                 sense_buf, SCSI_SENSE_BUFFERSIZE);
+                                 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
 }
 
 /**
  *      ata_eh_analyze_serror - analyze SError for a failed port
- *      @ap: ATA port to analyze SError for
+ *      @link: ATA link to analyze SError for
  *
  *      Analyze SError if available and further determine cause of
  *      failure.
@@ -1204,11 +1377,12 @@ static unsigned int atapi_eh_request_sense(struct ata_queued_cmd *qc)
  *      LOCKING:
  *      None.
  */
-static void ata_eh_analyze_serror(struct ata_port *ap)
+static void ata_eh_analyze_serror(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_eh_context *ehc = &link->eh_context;
         u32 serror = ehc->i.serror;
         unsigned int err_mask = 0, action = 0;
+        u32 hotplug_mask;
 
         if (serror & SERR_PERSISTENT) {
                 err_mask |= AC_ERR_ATA_BUS;
@@ -1227,7 +1401,20 @@ static void ata_eh_analyze_serror(struct ata_port *ap)
                 err_mask |= AC_ERR_SYSTEM;
                 action |= ATA_EH_HARDRESET;
         }
-        if (serror & (SERR_PHYRDY_CHG | SERR_DEV_XCHG))
+
+        /* Determine whether a hotplug event has occurred.  Both
+         * SError.N/X are considered hotplug events for enabled or
+         * host links.  For disabled PMP links, only N bit is
+         * considered as X bit is left at 1 for link plugging.
+         */
+        hotplug_mask = 0;
+
+        if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
+                hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
+        else
+                hotplug_mask = SERR_PHYRDY_CHG;
+
+        if (serror & hotplug_mask)
                 ata_ehi_hotplugged(&ehc->i);
 
         ehc->i.err_mask |= err_mask;
@@ -1236,7 +1423,7 @@ static void ata_eh_analyze_serror(struct ata_port *ap)
 
 /**
  *      ata_eh_analyze_ncq_error - analyze NCQ error
- *      @ap: ATA port to analyze NCQ error for
+ *      @link: ATA link to analyze NCQ error for
  *
  *      Read log page 10h, determine the offending qc and acquire
  *      error status TF.  For NCQ device errors, all LLDDs have to do
@@ -1246,10 +1433,11 @@ static void ata_eh_analyze_serror(struct ata_port *ap)
  *      LOCKING:
  *      Kernel thread context (may sleep).
  */
-static void ata_eh_analyze_ncq_error(struct ata_port *ap)
+static void ata_eh_analyze_ncq_error(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
-        struct ata_device *dev = ap->device;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
+        struct ata_device *dev = link->device;
         struct ata_queued_cmd *qc;
         struct ata_taskfile tf;
         int tag, rc;
@@ -1259,7 +1447,7 @@ static void ata_eh_analyze_ncq_error(struct ata_port *ap)
                 return;
 
         /* is it NCQ device error? */
-        if (!ap->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
+        if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
                 return;
 
         /* has LLDD analyzed already? */
@@ -1276,13 +1464,13 @@ static void ata_eh_analyze_ncq_error(struct ata_port *ap)
         /* okay, this error is ours */
         rc = ata_eh_read_log_10h(dev, &tag, &tf);
         if (rc) {
-                ata_port_printk(ap, KERN_ERR, "failed to read log page 10h "
+                ata_link_printk(link, KERN_ERR, "failed to read log page 10h "
                                 "(errno=%d)\n", rc);
                 return;
         }
 
-        if (!(ap->sactive & (1 << tag))) {
-                ata_port_printk(ap, KERN_ERR, "log page 10h reported "
+        if (!(link->sactive & (1 << tag))) {
+                ata_link_printk(link, KERN_ERR, "log page 10h reported "
                                 "inactive tag %d\n", tag);
                 return;
         }
@@ -1497,7 +1685,7 @@ static unsigned int ata_eh_speed_down(struct ata_device *dev, int is_io,
         /* speed down? */
         if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
                 /* speed down SATA link speed if possible */
-                if (sata_down_spd_limit(dev->ap) == 0) {
+                if (sata_down_spd_limit(dev->link) == 0) {
                         action |= ATA_EH_HARDRESET;
                         goto done;
                 }
@@ -1528,7 +1716,7 @@ static unsigned int ata_eh_speed_down(struct ata_device *dev, int is_io,
          * SATA.  Consider it only for PATA.
          */
         if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
-            (dev->ap->cbl != ATA_CBL_SATA) &&
+            (dev->link->ap->cbl != ATA_CBL_SATA) &&
             (dev->xfer_shift != ATA_SHIFT_PIO)) {
                 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
                         dev->spdn_cnt = 0;
@@ -1545,19 +1733,20 @@ static unsigned int ata_eh_speed_down(struct ata_device *dev, int is_io,
 }
 
 /**
- *      ata_eh_autopsy - analyze error and determine recovery action
- *      @ap: ATA port to perform autopsy on
+ *      ata_eh_link_autopsy - analyze error and determine recovery action
+ *      @link: host link to perform autopsy on
  *
- *      Analyze why @ap failed and determine which recovery action is
- *      needed.  This function also sets more detailed AC_ERR_* values
- *      and fills sense data for ATAPI CHECK SENSE.
+ *      Analyze why @link failed and determine which recovery actions
+ *      are needed.  This function also sets more detailed AC_ERR_*
+ *      values and fills sense data for ATAPI CHECK SENSE.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep).
  */
-static void ata_eh_autopsy(struct ata_port *ap)
+static void ata_eh_link_autopsy(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         unsigned int all_err_mask = 0;
         int tag, is_io = 0;
         u32 serror;
@@ -1569,10 +1758,10 @@ static void ata_eh_autopsy(struct ata_port *ap)
                 return;
 
         /* obtain and analyze SError */
-        rc = sata_scr_read(ap, SCR_ERROR, &serror);
+        rc = sata_scr_read(link, SCR_ERROR, &serror);
         if (rc == 0) {
                 ehc->i.serror |= serror;
-                ata_eh_analyze_serror(ap);
+                ata_eh_analyze_serror(link);
         } else if (rc != -EOPNOTSUPP) {
                 /* SError read failed, force hardreset and probing */
                 ata_ehi_schedule_probe(&ehc->i);
@@ -1581,7 +1770,7 @@ static void ata_eh_autopsy(struct ata_port *ap)
         }
 
         /* analyze NCQ failure */
-        ata_eh_analyze_ncq_error(ap);
+        ata_eh_analyze_ncq_error(link);
 
         /* any real error trumps AC_ERR_OTHER */
         if (ehc->i.err_mask & ~AC_ERR_OTHER)
@@ -1592,7 +1781,7 @@ static void ata_eh_autopsy(struct ata_port *ap)
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
 
-                if (!(qc->flags & ATA_QCFLAG_FAILED))
+                if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link)
                         continue;
 
                 /* inherit upper level err_mask */
@@ -1646,20 +1835,43 @@ static void ata_eh_autopsy(struct ata_port *ap)
 }
 
 /**
- *      ata_eh_report - report error handling to user
- *      @ap: ATA port EH is going on
+ *      ata_eh_autopsy - analyze error and determine recovery action
+ *      @ap: host port to perform autopsy on
+ *
+ *      Analyze all links of @ap and determine why they failed and
+ *      which recovery actions are needed.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ */
+void ata_eh_autopsy(struct ata_port *ap)
+{
+        struct ata_link *link;
+
+        __ata_port_for_each_link(link, ap)
+                ata_eh_link_autopsy(link);
+}
+
+/**
+ *      ata_eh_link_report - report error handling to user
+ *      @link: ATA link EH is going on
  *
  *      Report EH to user.
  *
  *      LOCKING:
  *      None.
  */
-static void ata_eh_report(struct ata_port *ap)
+static void ata_eh_link_report(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         const char *frozen, *desc;
+        char tries_buf[6];
         int tag, nr_failed = 0;
 
+        if (ehc->i.flags & ATA_EHI_QUIET)
+                return;
+
         desc = NULL;
         if (ehc->i.desc[0] != '\0')
                 desc = ehc->i.desc;
@@ -1667,7 +1879,7 @@ static void ata_eh_report(struct ata_port *ap)
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
 
-                if (!(qc->flags & ATA_QCFLAG_FAILED))
+                if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link)
                         continue;
                 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
                         continue;
@@ -1682,22 +1894,48 @@ static void ata_eh_report(struct ata_port *ap)
         if (ap->pflags & ATA_PFLAG_FROZEN)
                 frozen = " frozen";
 
+        memset(tries_buf, 0, sizeof(tries_buf));
+        if (ap->eh_tries < ATA_EH_MAX_TRIES)
+                snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
+                         ap->eh_tries);
+
         if (ehc->i.dev) {
                 ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x "
-                               "SAct 0x%x SErr 0x%x action 0x%x%s\n",
-                               ehc->i.err_mask, ap->sactive, ehc->i.serror,
-                               ehc->i.action, frozen);
+                               "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
+                               ehc->i.err_mask, link->sactive, ehc->i.serror,
+                               ehc->i.action, frozen, tries_buf);
                 if (desc)
                         ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
         } else {
-                ata_port_printk(ap, KERN_ERR, "exception Emask 0x%x "
-                                "SAct 0x%x SErr 0x%x action 0x%x%s\n",
-                                ehc->i.err_mask, ap->sactive, ehc->i.serror,
-                                ehc->i.action, frozen);
+                ata_link_printk(link, KERN_ERR, "exception Emask 0x%x "
+                                "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
+                                ehc->i.err_mask, link->sactive, ehc->i.serror,
+                                ehc->i.action, frozen, tries_buf);
                 if (desc)
-                        ata_port_printk(ap, KERN_ERR, "%s\n", desc);
+                        ata_link_printk(link, KERN_ERR, "%s\n", desc);
         }
 
+        if (ehc->i.serror)
+                ata_port_printk(ap, KERN_ERR,
+                  "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
+                  ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
+                  ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
+                  ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
+                  ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
+                  ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
+                  ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
+                  ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
+                  ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
+                  ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
+                  ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
+                  ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
+                  ehc->i.serror & SERR_CRC ? "BadCRC " : "",
+                  ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
+                  ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
+                  ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
+                  ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
+                  ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "" );
+
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 static const char *dma_str[] = {
                         [DMA_BIDIRECTIONAL]     = "bidi",
@@ -1708,7 +1946,8 @@ static void ata_eh_report(struct ata_port *ap)
                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
                 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
 
-                if (!(qc->flags & ATA_QCFLAG_FAILED) || !qc->err_mask)
+                if (!(qc->flags & ATA_QCFLAG_FAILED) ||
+                    qc->dev->link != link || !qc->err_mask)
                         continue;
 
                 ata_dev_printk(qc->dev, KERN_ERR,
@@ -1728,18 +1967,60 @@ static void ata_eh_report(struct ata_port *ap)
                         res->hob_lbal, res->hob_lbam, res->hob_lbah,
                         res->device, qc->err_mask, ata_err_string(qc->err_mask),
                         qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
+
+                if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
+                                    ATA_ERR) ) {
+                        if (res->command & ATA_BUSY)
+                                ata_dev_printk(qc->dev, KERN_ERR,
+                                  "status: { Busy }\n" );
+                        else
+                                ata_dev_printk(qc->dev, KERN_ERR,
+                                  "status: { %s%s%s%s}\n",
+                                  res->command & ATA_DRDY ? "DRDY " : "",
+                                  res->command & ATA_DF ? "DF " : "",
+                                  res->command & ATA_DRQ ? "DRQ " : "",
+                                  res->command & ATA_ERR ? "ERR " : "" );
+                }
+
+                if (cmd->command != ATA_CMD_PACKET &&
+                    (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
+                                     ATA_ABORTED)))
+                        ata_dev_printk(qc->dev, KERN_ERR,
+                          "error: { %s%s%s%s}\n",
+                          res->feature & ATA_ICRC ? "ICRC " : "",
+                          res->feature & ATA_UNC ? "UNC " : "",
+                          res->feature & ATA_IDNF ? "IDNF " : "",
+                          res->feature & ATA_ABORTED ? "ABRT " : "" );
         }
 }
 
-static int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
+/**
+ *      ata_eh_report - report error handling to user
+ *      @ap: ATA port to report EH about
+ *
+ *      Report EH to user.
+ *
+ *      LOCKING:
+ *      None.
+ */
+void ata_eh_report(struct ata_port *ap)
+{
+        struct ata_link *link;
+
+        __ata_port_for_each_link(link, ap)
+                ata_eh_link_report(link);
+}
+
+static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
                         unsigned int *classes, unsigned long deadline)
 {
-        int i, rc;
+        struct ata_device *dev;
+        int rc;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                classes[i] = ATA_DEV_UNKNOWN;
+        ata_link_for_each_dev(dev, link)
+                classes[dev->devno] = ATA_DEV_UNKNOWN;
 
-        rc = reset(ap, classes, deadline);
+        rc = reset(link, classes, deadline);
         if (rc)
                 return rc;
 
@@ -1747,71 +2028,87 @@ static int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
          * is complete and convert all ATA_DEV_UNKNOWN to
          * ATA_DEV_NONE.
          */
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                if (classes[i] != ATA_DEV_UNKNOWN)
+        ata_link_for_each_dev(dev, link)
+                if (classes[dev->devno] != ATA_DEV_UNKNOWN)
                         break;
 
-        if (i < ATA_MAX_DEVICES)
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        if (classes[i] == ATA_DEV_UNKNOWN)
-                                classes[i] = ATA_DEV_NONE;
+        if (dev) {
+                ata_link_for_each_dev(dev, link) {
+                        if (classes[dev->devno] == ATA_DEV_UNKNOWN)
+                                classes[dev->devno] = ATA_DEV_NONE;
+                }
+        }
 
         return 0;
 }
 
-static int ata_eh_followup_srst_needed(int rc, int classify,
+static int ata_eh_followup_srst_needed(struct ata_link *link,
+                                       int rc, int classify,
                                        const unsigned int *classes)
 {
+        if (link->flags & ATA_LFLAG_NO_SRST)
+                return 0;
         if (rc == -EAGAIN)
                 return 1;
         if (rc != 0)
                 return 0;
-        if (classify && classes[0] == ATA_DEV_UNKNOWN)
+        if ((link->ap->flags & ATA_FLAG_PMP) && ata_is_host_link(link))
+                return 1;
+        if (classify && !(link->flags & ATA_LFLAG_ASSUME_CLASS) &&
+            classes[0] == ATA_DEV_UNKNOWN)
                 return 1;
         return 0;
 }
 
-static int ata_eh_reset(struct ata_port *ap, int classify,
-                        ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
-                        ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
+int ata_eh_reset(struct ata_link *link, int classify,
+                 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
+                 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         unsigned int *classes = ehc->classes;
         int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
         int try = 0;
+        struct ata_device *dev;
         unsigned long deadline;
         unsigned int action;
         ata_reset_fn_t reset;
-        int i, rc;
+        unsigned long flags;
+        int rc;
 
         /* about to reset */
-        ata_eh_about_to_do(ap, NULL, ehc->i.action & ATA_EH_RESET_MASK);
+        spin_lock_irqsave(ap->lock, flags);
+        ap->pflags |= ATA_PFLAG_RESETTING;
+        spin_unlock_irqrestore(ap->lock, flags);
+
+        ata_eh_about_to_do(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
 
         /* Determine which reset to use and record in ehc->i.action.
          * prereset() may examine and modify it.
          */
         action = ehc->i.action;
         ehc->i.action &= ~ATA_EH_RESET_MASK;
-        if (softreset && (!hardreset || (!sata_set_spd_needed(ap) &&
+        if (softreset && (!hardreset || (!(link->flags & ATA_LFLAG_NO_SRST) &&
+                                         !sata_set_spd_needed(link) &&
                                          !(action & ATA_EH_HARDRESET))))
                 ehc->i.action |= ATA_EH_SOFTRESET;
         else
                 ehc->i.action |= ATA_EH_HARDRESET;
 
         if (prereset) {
-                rc = prereset(ap, jiffies + ATA_EH_PRERESET_TIMEOUT);
+                rc = prereset(link, jiffies + ATA_EH_PRERESET_TIMEOUT);
                 if (rc) {
                         if (rc == -ENOENT) {
-                                ata_port_printk(ap, KERN_DEBUG,
+                                ata_link_printk(link, KERN_DEBUG,
                                                 "port disabled. ignoring.\n");
-                                ap->eh_context.i.action &= ~ATA_EH_RESET_MASK;
+                                ehc->i.action &= ~ATA_EH_RESET_MASK;
 
-                                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                                        classes[i] = ATA_DEV_NONE;
+                                ata_link_for_each_dev(dev, link)
+                                        classes[dev->devno] = ATA_DEV_NONE;
 
                                 rc = 0;
                         } else
-                                ata_port_printk(ap, KERN_ERR,
+                                ata_link_printk(link, KERN_ERR,
                                         "prereset failed (errno=%d)\n", rc);
                         goto out;
                 }
@@ -1824,8 +2121,8 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                 reset = softreset;
         else {
                 /* prereset told us not to reset, bang classes and return */
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        classes[i] = ATA_DEV_NONE;
+                ata_link_for_each_dev(dev, link)
+                        classes[dev->devno] = ATA_DEV_NONE;
                 rc = 0;
                 goto out;
         }
@@ -1843,7 +2140,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
 
         /* shut up during boot probing */
         if (verbose)
-                ata_port_printk(ap, KERN_INFO, "%s resetting port\n",
+                ata_link_printk(link, KERN_INFO, "%s resetting link\n",
                                 reset == softreset ? "soft" : "hard");
 
         /* mark that this EH session started with reset */
@@ -1852,49 +2149,54 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
         else
                 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
 
-        rc = ata_do_reset(ap, reset, classes, deadline);
+        rc = ata_do_reset(link, reset, classes, deadline);
 
         if (reset == hardreset &&
-            ata_eh_followup_srst_needed(rc, classify, classes)) {
+            ata_eh_followup_srst_needed(link, rc, classify, classes)) {
                 /* okay, let's do follow-up softreset */
                 reset = softreset;
 
                 if (!reset) {
-                        ata_port_printk(ap, KERN_ERR,
+                        ata_link_printk(link, KERN_ERR,
                                         "follow-up softreset required "
                                         "but no softreset avaliable\n");
                         rc = -EINVAL;
                         goto out;
                 }
 
-                ata_eh_about_to_do(ap, NULL, ATA_EH_RESET_MASK);
-                rc = ata_do_reset(ap, reset, classes, deadline);
+                ata_eh_about_to_do(link, NULL, ATA_EH_RESET_MASK);
+                rc = ata_do_reset(link, reset, classes, deadline);
 
-                if (rc == 0 && classify &&
-                    classes[0] == ATA_DEV_UNKNOWN) {
-                        ata_port_printk(ap, KERN_ERR,
+                if (rc == 0 && classify && classes[0] == ATA_DEV_UNKNOWN &&
+                    !(link->flags & ATA_LFLAG_ASSUME_CLASS)) {
+                        ata_link_printk(link, KERN_ERR,
                                         "classification failed\n");
                         rc = -EINVAL;
                         goto out;
                 }
         }
 
-        if (rc && try < ARRAY_SIZE(ata_eh_reset_timeouts)) {
+        /* if we skipped follow-up srst, clear rc */
+        if (rc == -EAGAIN)
+                rc = 0;
+
+        if (rc && rc != -ERESTART && try < ARRAY_SIZE(ata_eh_reset_timeouts)) {
                 unsigned long now = jiffies;
 
                 if (time_before(now, deadline)) {
                         unsigned long delta = deadline - jiffies;
 
-                        ata_port_printk(ap, KERN_WARNING, "reset failed "
+                        ata_link_printk(link, KERN_WARNING, "reset failed "
                                 "(errno=%d), retrying in %u secs\n",
                                 rc, (jiffies_to_msecs(delta) + 999) / 1000);
 
-                        schedule_timeout_uninterruptible(delta);
+                        while (delta)
+                                delta = schedule_timeout_uninterruptible(delta);
                 }
 
                 if (rc == -EPIPE ||
                     try == ARRAY_SIZE(ata_eh_reset_timeouts) - 1)
-                        sata_down_spd_limit(ap);
+                        sata_down_spd_limit(link);
                 if (hardreset)
                         reset = hardreset;
                 goto retry;
@@ -1903,37 +2205,56 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
         if (rc == 0) {
                 u32 sstatus;
 
-                /* After the reset, the device state is PIO 0 and the
-                 * controller state is undefined.  Record the mode.
-                 */
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        ap->device[i].pio_mode = XFER_PIO_0;
+                ata_link_for_each_dev(dev, link) {
+                        /* After the reset, the device state is PIO 0
+                         * and the controller state is undefined.
+                         * Record the mode.
+                         */
+                        dev->pio_mode = XFER_PIO_0;
+
+                        if (ata_link_offline(link))
+                                continue;
+
+                        /* apply class override and convert UNKNOWN to NONE */
+                        if (link->flags & ATA_LFLAG_ASSUME_ATA)
+                                classes[dev->devno] = ATA_DEV_ATA;
+                        else if (link->flags & ATA_LFLAG_ASSUME_SEMB)
+                                classes[dev->devno] = ATA_DEV_SEMB_UNSUP; /* not yet */
+                        else if (classes[dev->devno] == ATA_DEV_UNKNOWN)
+                                classes[dev->devno] = ATA_DEV_NONE;
+                }
 
                 /* record current link speed */
-                if (sata_scr_read(ap, SCR_STATUS, &sstatus) == 0)
-                        ap->sata_spd = (sstatus >> 4) & 0xf;
+                if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
+                        link->sata_spd = (sstatus >> 4) & 0xf;
 
                 if (postreset)
-                        postreset(ap, classes);
+                        postreset(link, classes);
 
                 /* reset successful, schedule revalidation */
-                ata_eh_done(ap, NULL, ehc->i.action & ATA_EH_RESET_MASK);
+                ata_eh_done(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
                 ehc->i.action |= ATA_EH_REVALIDATE;
         }
  out:
         /* clear hotplug flag */
         ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
+
+        spin_lock_irqsave(ap->lock, flags);
+        ap->pflags &= ~ATA_PFLAG_RESETTING;
+        spin_unlock_irqrestore(ap->lock, flags);
+
         return rc;
 }
 
-static int ata_eh_revalidate_and_attach(struct ata_port *ap,
+static int ata_eh_revalidate_and_attach(struct ata_link *link,
                                         struct ata_device **r_failed_dev)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &link->eh_context;
         struct ata_device *dev;
         unsigned int new_mask = 0;
         unsigned long flags;
-        int i, rc = 0;
+        int rc = 0;
 
         DPRINTK("ENTER\n");
 
@@ -1941,27 +2262,28 @@ static int ata_eh_revalidate_and_attach(struct ata_port *ap,
          * be done backwards such that PDIAG- is released by the slave
          * device before the master device is identified.
          */
-        for (i = ATA_MAX_DEVICES - 1; i >= 0; i--) {
-                unsigned int action, readid_flags = 0;
-
-                dev = &ap->device[i];
-                action = ata_eh_dev_action(dev);
+        ata_link_for_each_dev_reverse(dev, link) {
+                unsigned int action = ata_eh_dev_action(dev);
+                unsigned int readid_flags = 0;
 
                 if (ehc->i.flags & ATA_EHI_DID_RESET)
                         readid_flags |= ATA_READID_POSTRESET;
 
                 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
-                        if (ata_port_offline(ap)) {
+                        WARN_ON(dev->class == ATA_DEV_PMP);
+
+                        if (ata_link_offline(link)) {
                                 rc = -EIO;
                                 goto err;
                         }
 
-                        ata_eh_about_to_do(ap, dev, ATA_EH_REVALIDATE);
-                        rc = ata_dev_revalidate(dev, readid_flags);
+                        ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
+                        rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
+                                                readid_flags);
                         if (rc)
                                 goto err;
 
-                        ata_eh_done(ap, dev, ATA_EH_REVALIDATE);
+                        ata_eh_done(link, dev, ATA_EH_REVALIDATE);
 
                         /* Configuration may have changed, reconfigure
                          * transfer mode.
@@ -1975,11 +2297,14 @@ static int ata_eh_revalidate_and_attach(struct ata_port *ap,
                            ata_class_enabled(ehc->classes[dev->devno])) {
                         dev->class = ehc->classes[dev->devno];
 
-                        rc = ata_dev_read_id(dev, &dev->class, readid_flags,
-                                             dev->id);
+                        if (dev->class == ATA_DEV_PMP)
+                                rc = sata_pmp_attach(dev);
+                        else
+                                rc = ata_dev_read_id(dev, &dev->class,
+                                                     readid_flags, dev->id);
                         switch (rc) {
                         case 0:
-                                new_mask |= 1 << i;
+                                new_mask |= 1 << dev->devno;
                                 break;
                         case -ENOENT:
                                 /* IDENTIFY was issued to non-existent
@@ -1997,16 +2322,16 @@ static int ata_eh_revalidate_and_attach(struct ata_port *ap,
         }
 
         /* PDIAG- should have been released, ask cable type if post-reset */
-        if ((ehc->i.flags & ATA_EHI_DID_RESET) && ap->ops->cable_detect)
+        if (ata_is_host_link(link) && ap->ops->cable_detect &&
+            (ehc->i.flags & ATA_EHI_DID_RESET))
                 ap->cbl = ap->ops->cable_detect(ap);
 
         /* Configure new devices forward such that user doesn't see
          * device detection messages backwards.
          */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
-                if (!(new_mask & (1 << i)))
+        ata_link_for_each_dev(dev, link) {
+                if (!(new_mask & (1 << dev->devno)) ||
+                    dev->class == ATA_DEV_PMP)
                         continue;
 
                 ehc->i.flags |= ATA_EHI_PRINTINFO;
@@ -2031,40 +2356,44 @@ static int ata_eh_revalidate_and_attach(struct ata_port *ap,
         return rc;
 }
 
-static int ata_port_nr_enabled(struct ata_port *ap)
+static int ata_link_nr_enabled(struct ata_link *link)
 {
-        int i, cnt = 0;
+        struct ata_device *dev;
+        int cnt = 0;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                if (ata_dev_enabled(&ap->device[i]))
+        ata_link_for_each_dev(dev, link)
+                if (ata_dev_enabled(dev))
                         cnt++;
         return cnt;
 }
 
-static int ata_port_nr_vacant(struct ata_port *ap)
+static int ata_link_nr_vacant(struct ata_link *link)
 {
-        int i, cnt = 0;
+        struct ata_device *dev;
+        int cnt = 0;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                if (ap->device[i].class == ATA_DEV_UNKNOWN)
+        ata_link_for_each_dev(dev, link)
+                if (dev->class == ATA_DEV_UNKNOWN)
                         cnt++;
         return cnt;
 }
 
-static int ata_eh_skip_recovery(struct ata_port *ap)
+static int ata_eh_skip_recovery(struct ata_link *link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
-        int i;
+        struct ata_eh_context *ehc = &link->eh_context;
+        struct ata_device *dev;
+
+        /* skip disabled links */
+        if (link->flags & ATA_LFLAG_DISABLED)
+                return 1;
 
         /* thaw frozen port, resume link and recover failed devices */
-        if ((ap->pflags & ATA_PFLAG_FROZEN) ||
-            (ehc->i.flags & ATA_EHI_RESUME_LINK) || ata_port_nr_enabled(ap))
+        if ((link->ap->pflags & ATA_PFLAG_FROZEN) ||
+            (ehc->i.flags & ATA_EHI_RESUME_LINK) || ata_link_nr_enabled(link))
                 return 0;
 
         /* skip if class codes for all vacant slots are ATA_DEV_NONE */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
-
+        ata_link_for_each_dev(dev, link) {
                 if (dev->class == ATA_DEV_UNKNOWN &&
                     ehc->classes[dev->devno] != ATA_DEV_NONE)
                         return 0;
@@ -2073,10 +2402,9 @@ static int ata_eh_skip_recovery(struct ata_port *ap)
         return 1;
 }
 
-static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
+static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
 {
-        struct ata_port *ap = dev->ap;
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_eh_context *ehc = &dev->link->eh_context;
 
         ehc->tries[dev->devno]--;
 
@@ -2092,7 +2420,7 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
                         /* This is the last chance, better to slow
                          * down than lose it.
                          */
-                        sata_down_spd_limit(ap);
+                        sata_down_spd_limit(dev->link);
                         ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
                 }
         }
@@ -2102,7 +2430,7 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
                 ata_dev_disable(dev);
 
                 /* detach if offline */
-                if (ata_port_offline(ap))
+                if (ata_link_offline(dev->link))
                         ata_eh_detach_dev(dev);
 
                 /* probe if requested */
@@ -2115,12 +2443,16 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
                         ehc->did_probe_mask |= (1 << dev->devno);
                         ehc->i.action |= ATA_EH_SOFTRESET;
                 }
+
+                return 1;
         } else {
                 /* soft didn't work?  be haaaaard */
                 if (ehc->i.flags & ATA_EHI_DID_RESET)
                         ehc->i.action |= ATA_EH_HARDRESET;
                 else
                         ehc->i.action |= ATA_EH_SOFTRESET;
+
+                return 0;
         }
 }
 
@@ -2131,12 +2463,13 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
  *      @softreset: softreset method (can be NULL)
  *      @hardreset: hardreset method (can be NULL)
  *      @postreset: postreset method (can be NULL)
+ *      @r_failed_link: out parameter for failed link
  *
  *      This is the alpha and omega, eum and yang, heart and soul of
  *      libata exception handling.  On entry, actions required to
- *      recover the port and hotplug requests are recorded in
- *      eh_context.  This function executes all the operations with
- *      appropriate retrials and fallbacks to resurrect failed
+ *      recover each link and hotplug requests are recorded in the
+ *      link's eh_context.  This function executes all the operations
+ *      with appropriate retrials and fallbacks to resurrect failed
  *      devices, detach goners and greet newcomers.
  *
  *      LOCKING:
@@ -2145,104 +2478,171 @@ static void ata_eh_handle_dev_fail(struct ata_device *dev, int err)
  *      RETURNS:
  *      0 on success, -errno on failure.
  */
-static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
-                          ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
-                          ata_postreset_fn_t postreset)
+int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
+                   ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
+                   ata_postreset_fn_t postreset,
+                   struct ata_link **r_failed_link)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_link *link;
         struct ata_device *dev;
-        int i, rc;
+        int nr_failed_devs, nr_disabled_devs;
+        int reset, rc;
+        unsigned long flags;
 
         DPRINTK("ENTER\n");
 
         /* prep for recovery */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-
-                ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
-
-                /* collect port action mask recorded in dev actions */
-                ehc->i.action |= ehc->i.dev_action[i] & ~ATA_EH_PERDEV_MASK;
-                ehc->i.dev_action[i] &= ATA_EH_PERDEV_MASK;
-
-                /* process hotplug request */
-                if (dev->flags & ATA_DFLAG_DETACH)
-                        ata_eh_detach_dev(dev);
+        ata_port_for_each_link(link, ap) {
+                struct ata_eh_context *ehc = &link->eh_context;
+
+                /* re-enable link? */
+                if (ehc->i.action & ATA_EH_ENABLE_LINK) {
+                        ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
+                        spin_lock_irqsave(ap->lock, flags);
+                        link->flags &= ~ATA_LFLAG_DISABLED;
+                        spin_unlock_irqrestore(ap->lock, flags);
+                        ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
+                }
 
-                if (!ata_dev_enabled(dev) &&
-                    ((ehc->i.probe_mask & (1 << dev->devno)) &&
-                     !(ehc->did_probe_mask & (1 << dev->devno)))) {
-                        ata_eh_detach_dev(dev);
-                        ata_dev_init(dev);
-                        ehc->did_probe_mask |= (1 << dev->devno);
-                        ehc->i.action |= ATA_EH_SOFTRESET;
+                ata_link_for_each_dev(dev, link) {
+                        if (link->flags & ATA_LFLAG_NO_RETRY)
+                                ehc->tries[dev->devno] = 1;
+                        else
+                                ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
+
+                        /* collect port action mask recorded in dev actions */
+                        ehc->i.action |= ehc->i.dev_action[dev->devno] &
+                                         ~ATA_EH_PERDEV_MASK;
+                        ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
+
+                        /* process hotplug request */
+                        if (dev->flags & ATA_DFLAG_DETACH)
+                                ata_eh_detach_dev(dev);
+
+                        if (!ata_dev_enabled(dev) &&
+                            ((ehc->i.probe_mask & (1 << dev->devno)) &&
+                             !(ehc->did_probe_mask & (1 << dev->devno)))) {
+                                ata_eh_detach_dev(dev);
+                                ata_dev_init(dev);
+                                ehc->did_probe_mask |= (1 << dev->devno);
+                                ehc->i.action |= ATA_EH_SOFTRESET;
+                        }
                 }
         }
 
  retry:
         rc = 0;
+        nr_failed_devs = 0;
+        nr_disabled_devs = 0;
+        reset = 0;
 
         /* if UNLOADING, finish immediately */
         if (ap->pflags & ATA_PFLAG_UNLOADING)
                 goto out;
 
-        /* skip EH if possible. */
-        if (ata_eh_skip_recovery(ap))
-                ehc->i.action = 0;
+        /* prep for EH */
+        ata_port_for_each_link(link, ap) {
+                struct ata_eh_context *ehc = &link->eh_context;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ehc->classes[i] = ATA_DEV_UNKNOWN;
+                /* skip EH if possible. */
+                if (ata_eh_skip_recovery(link))
+                        ehc->i.action = 0;
 
-        /* reset */
-        if (ehc->i.action & ATA_EH_RESET_MASK) {
-                ata_eh_freeze_port(ap);
+                /* do we need to reset? */
+                if (ehc->i.action & ATA_EH_RESET_MASK)
+                        reset = 1;
 
-                rc = ata_eh_reset(ap, ata_port_nr_vacant(ap), prereset,
-                                  softreset, hardreset, postreset);
-                if (rc) {
-                        ata_port_printk(ap, KERN_ERR,
-                                        "reset failed, giving up\n");
-                        goto out;
+                ata_link_for_each_dev(dev, link)
+                        ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
+        }
+
+        /* reset */
+        if (reset) {
+                /* if PMP is attached, this function only deals with
+                 * downstream links, port should stay thawed.
+                 */
+                if (!ap->nr_pmp_links)
+                        ata_eh_freeze_port(ap);
+
+                ata_port_for_each_link(link, ap) {
+                        struct ata_eh_context *ehc = &link->eh_context;
+
+                        if (!(ehc->i.action & ATA_EH_RESET_MASK))
+                                continue;
+
+                        rc = ata_eh_reset(link, ata_link_nr_vacant(link),
+                                          prereset, softreset, hardreset,
+                                          postreset);
+                        if (rc) {
+                                ata_link_printk(link, KERN_ERR,
+                                                "reset failed, giving up\n");
+                                goto out;
+                        }
                 }
 
-                ata_eh_thaw_port(ap);
+                if (!ap->nr_pmp_links)
+                        ata_eh_thaw_port(ap);
         }
 
-        /* revalidate existing devices and attach new ones */
-        rc = ata_eh_revalidate_and_attach(ap, &dev);
-        if (rc)
-                goto dev_fail;
+        /* the rest */
+        ata_port_for_each_link(link, ap) {
+                struct ata_eh_context *ehc = &link->eh_context;
 
-        /* configure transfer mode if necessary */
-        if (ehc->i.flags & ATA_EHI_SETMODE) {
-                rc = ata_set_mode(ap, &dev);
+                /* revalidate existing devices and attach new ones */
+                rc = ata_eh_revalidate_and_attach(link, &dev);
                 if (rc)
                         goto dev_fail;
-                ehc->i.flags &= ~ATA_EHI_SETMODE;
-        }
 
-        goto out;
+                /* if PMP got attached, return, pmp EH will take care of it */
+                if (link->device->class == ATA_DEV_PMP) {
+                        ehc->i.action = 0;
+                        return 0;
+                }
 
- dev_fail:
-        ata_eh_handle_dev_fail(dev, rc);
+                /* configure transfer mode if necessary */
+                if (ehc->i.flags & ATA_EHI_SETMODE) {
+                        rc = ata_set_mode(link, &dev);
+                        if (rc)
+                                goto dev_fail;
+                        ehc->i.flags &= ~ATA_EHI_SETMODE;
+                }
 
-        if (ata_port_nr_enabled(ap)) {
-                ata_port_printk(ap, KERN_WARNING, "failed to recover some "
-                                "devices, retrying in 5 secs\n");
-                ssleep(5);
-        } else {
-                /* no device left, repeat fast */
-                msleep(500);
+                /* this link is okay now */
+                ehc->i.flags = 0;
+                continue;
+
+        dev_fail:
+                nr_failed_devs++;
+                if (ata_eh_handle_dev_fail(dev, rc))
+                        nr_disabled_devs++;
+
+                if (ap->pflags & ATA_PFLAG_FROZEN) {
+                        /* PMP reset requires working host port.
+                         * Can't retry if it's frozen.
+                         */
+                        if (ap->nr_pmp_links)
+                                goto out;
+                        break;
+                }
         }
 
-        goto retry;
+        if (nr_failed_devs) {
+                if (nr_failed_devs != nr_disabled_devs) {
+                        ata_port_printk(ap, KERN_WARNING, "failed to recover "
+                                        "some devices, retrying in 5 secs\n");
+                        ssleep(5);
+                } else {
+                        /* no device left to recover, repeat fast */
+                        msleep(500);
+                }
 
- out:
-        if (rc) {
-                for (i = 0; i < ATA_MAX_DEVICES; i++)
-                        ata_dev_disable(&ap->device[i]);
+                goto retry;
         }
 
+ out:
+        if (rc && r_failed_link)
+                *r_failed_link = link;
+
         DPRINTK("EXIT, rc=%d\n", rc);
         return rc;
 }
@@ -2257,7 +2657,7 @@ static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
  *      LOCKING:
  *      None.
  */
-static void ata_eh_finish(struct ata_port *ap)
+void ata_eh_finish(struct ata_port *ap)
 {
         int tag;
 
@@ -2287,6 +2687,10 @@ static void ata_eh_finish(struct ata_port *ap)
                         }
                 }
         }
+
+        /* make sure nr_active_links is zero after EH */
+        WARN_ON(ap->nr_active_links);
+        ap->nr_active_links = 0;
 }
 
 /**
@@ -2306,9 +2710,19 @@ void ata_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)
 {
+        struct ata_device *dev;
+        int rc;
+
         ata_eh_autopsy(ap);
         ata_eh_report(ap);
-        ata_eh_recover(ap, prereset, softreset, hardreset, postreset);
+
+        rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
+                            NULL);
+        if (rc) {
+                ata_link_for_each_dev(dev, &ap->link)
+                        ata_dev_disable(dev);
+        }
+
         ata_eh_finish(ap);
 }
 
diff --git a/drivers/ata/libata-pmp.c b/drivers/ata/libata-pmp.c
new file mode 100644
index 000000000000..c0c4dbcde091
--- /dev/null
+++ b/drivers/ata/libata-pmp.c
@@ -0,0 +1,1191 @@
+/*
+ * libata-pmp.c - libata port multiplier support
+ *
+ * Copyright (c) 2007  SUSE Linux Products GmbH
+ * Copyright (c) 2007  Tejun Heo <teheo@suse.de>
+ *
+ * This file is released under the GPLv2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/libata.h>
+#include "libata.h"
+
+/**
+ *      sata_pmp_read - read PMP register
+ *      @link: link to read PMP register for
+ *      @reg: register to read
+ *      @r_val: resulting value
+ *
+ *      Read PMP register.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, AC_ERR_* mask on failure.
+ */
+static unsigned int sata_pmp_read(struct ata_link *link, int reg, u32 *r_val)
+{
+        struct ata_port *ap = link->ap;
+        struct ata_device *pmp_dev = ap->link.device;
+        struct ata_taskfile tf;
+        unsigned int err_mask;
+
+        ata_tf_init(pmp_dev, &tf);
+        tf.command = ATA_CMD_PMP_READ;
+        tf.protocol = ATA_PROT_NODATA;
+        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+        tf.feature = reg;
+        tf.device = link->pmp;
+
+        err_mask = ata_exec_internal(pmp_dev, &tf, NULL, DMA_NONE, NULL, 0,
+                                     SATA_PMP_SCR_TIMEOUT);
+        if (err_mask)
+                return err_mask;
+
+        *r_val = tf.nsect | tf.lbal << 8 | tf.lbam << 16 | tf.lbah << 24;
+        return 0;
+}
+
+/**
+ *      sata_pmp_write - write PMP register
+ *      @link: link to write PMP register for
+ *      @reg: register to write
+ *      @r_val: value to write
+ *
+ *      Write PMP register.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, AC_ERR_* mask on failure.
+ */
+static unsigned int sata_pmp_write(struct ata_link *link, int reg, u32 val)
+{
+        struct ata_port *ap = link->ap;
+        struct ata_device *pmp_dev = ap->link.device;
+        struct ata_taskfile tf;
+
+        ata_tf_init(pmp_dev, &tf);
+        tf.command = ATA_CMD_PMP_WRITE;
+        tf.protocol = ATA_PROT_NODATA;
+        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+        tf.feature = reg;
+        tf.device = link->pmp;
+        tf.nsect = val & 0xff;
+        tf.lbal = (val >> 8) & 0xff;
+        tf.lbam = (val >> 16) & 0xff;
+        tf.lbah = (val >> 24) & 0xff;
+
+        return ata_exec_internal(pmp_dev, &tf, NULL, DMA_NONE, NULL, 0,
+                                 SATA_PMP_SCR_TIMEOUT);
+}
+
+/**
+ *      sata_pmp_qc_defer_cmd_switch - qc_defer for command switching PMP
+ *      @qc: ATA command in question
+ *
+ *      A host which has command switching PMP support cannot issue
+ *      commands to multiple links simultaneously.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ *      RETURNS:
+ *      ATA_DEFER_* if deferring is needed, 0 otherwise.
+ */
+int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc)
+{
+        struct ata_link *link = qc->dev->link;
+        struct ata_port *ap = link->ap;
+
+        if (ap->excl_link == NULL || ap->excl_link == link) {
+                if (ap->nr_active_links == 0 || ata_link_active(link)) {
+                        qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
+                        return ata_std_qc_defer(qc);
+                }
+
+                ap->excl_link = link;
+        }
+
+        return ATA_DEFER_PORT;
+}
+
+/**
+ *      sata_pmp_scr_read - read PSCR
+ *      @link: ATA link to read PSCR for
+ *      @reg: PSCR to read
+ *      @r_val: resulting value
+ *
+ *      Read PSCR @reg into @r_val for @link, to be called from
+ *      ata_scr_read().
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *r_val)
+{
+        unsigned int err_mask;
+
+        if (reg > SATA_PMP_PSCR_CONTROL)
+                return -EINVAL;
+
+        err_mask = sata_pmp_read(link, reg, r_val);
+        if (err_mask) {
+                ata_link_printk(link, KERN_WARNING, "failed to read SCR %d "
+                                "(Emask=0x%x)\n", reg, err_mask);
+                return -EIO;
+        }
+        return 0;
+}
+
+/**
+ *      sata_pmp_scr_write - write PSCR
+ *      @link: ATA link to write PSCR for
+ *      @reg: PSCR to write
+ *      @val: value to be written
+ *
+ *      Write @val to PSCR @reg for @link, to be called from
+ *      ata_scr_write() and ata_scr_write_flush().
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
+{
+        unsigned int err_mask;
+
+        if (reg > SATA_PMP_PSCR_CONTROL)
+                return -EINVAL;
+
+        err_mask = sata_pmp_write(link, reg, val);
+        if (err_mask) {
+                ata_link_printk(link, KERN_WARNING, "failed to write SCR %d "
+                                "(Emask=0x%x)\n", reg, err_mask);
+                return -EIO;
+        }
+        return 0;
+}
+
+/**
+ *      sata_pmp_std_prereset - prepare PMP link for reset
+ *      @link: link to be reset
+ *      @deadline: deadline jiffies for the operation
+ *
+ *      @link is about to be reset.  Initialize it.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep)
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
+ */
+int sata_pmp_std_prereset(struct ata_link *link, unsigned long deadline)
+{
+        struct ata_eh_context *ehc = &link->eh_context;
+        const unsigned long *timing = sata_ehc_deb_timing(ehc);
+        int rc;
+
+        /* force HRST? */
+        if (link->flags & ATA_LFLAG_NO_SRST)
+                ehc->i.action |= ATA_EH_HARDRESET;
+
+        /* handle link resume */
+        if ((ehc->i.flags & ATA_EHI_RESUME_LINK) &&
+            (link->flags & ATA_LFLAG_HRST_TO_RESUME))
+                ehc->i.action |= ATA_EH_HARDRESET;
+
+        /* if we're about to do hardreset, nothing more to do */
+        if (ehc->i.action & ATA_EH_HARDRESET)
+                return 0;
+
+        /* resume link */
+        rc = sata_link_resume(link, timing, deadline);
+        if (rc) {
+                /* phy resume failed */
+                ata_link_printk(link, KERN_WARNING, "failed to resume link "
+                                "for reset (errno=%d)\n", rc);
+                return rc;
+        }
+
+        /* clear SError bits including .X which blocks the port when set */
+        rc = sata_scr_write(link, SCR_ERROR, 0xffffffff);
+        if (rc) {
+                ata_link_printk(link, KERN_ERR,
+                                "failed to clear SError (errno=%d)\n", rc);
+                return rc;
+        }
+
+        return 0;
+}
+
+/**
+ *      sata_pmp_std_hardreset - standard hardreset method for PMP link
+ *      @link: link to be reset
+ *      @class: resulting class of attached device
+ *      @deadline: deadline jiffies for the operation
+ *
+ *      Hardreset PMP port @link.  Note that this function doesn't
+ *      wait for BSY clearance.  There simply isn't a generic way to
+ *      wait the event.  Instead, this function return -EAGAIN thus
+ *      telling libata-EH to followup with softreset.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep)
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
+ */
+int sata_pmp_std_hardreset(struct ata_link *link, unsigned int *class,
+                           unsigned long deadline)
+{
+        const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
+        u32 tmp;
+        int rc;
+
+        DPRINTK("ENTER\n");
+
+        /* do hardreset */
+        rc = sata_link_hardreset(link, timing, deadline);
+        if (rc) {
+                ata_link_printk(link, KERN_ERR,
+                                "COMRESET failed (errno=%d)\n", rc);
+                goto out;
+        }
+
+        /* clear SError bits including .X which blocks the port when set */
+        rc = sata_scr_write(link, SCR_ERROR, 0xffffffff);
+        if (rc) {
+                ata_link_printk(link, KERN_ERR, "failed to clear SError "
+                                "during hardreset (errno=%d)\n", rc);
+                goto out;
+        }
+
+        /* if device is present, follow up with srst to wait for !BSY */
+        if (ata_link_online(link))
+                rc = -EAGAIN;
+ out:
+        /* if SCR isn't accessible, we need to reset the PMP */
+        if (rc && rc != -EAGAIN && sata_scr_read(link, SCR_STATUS, &tmp))
+                rc = -ERESTART;
+
+        DPRINTK("EXIT, rc=%d\n", rc);
+        return rc;
+}
+
+/**
+ *      ata_std_postreset - standard postreset method for PMP link
+ *      @link: the target ata_link
+ *      @classes: classes of attached devices
+ *
+ *      This function is invoked after a successful reset.  Note that
+ *      the device might have been reset more than once using
+ *      different reset methods before postreset is invoked.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep)
+ */
+void sata_pmp_std_postreset(struct ata_link *link, unsigned int *class)
+{
+        u32 serror;
+
+        DPRINTK("ENTER\n");
+
+        /* clear SError */
+        if (sata_scr_read(link, SCR_ERROR, &serror) == 0)
+                sata_scr_write(link, SCR_ERROR, serror);
+
+        /* print link status */
+        sata_print_link_status(link);
+
+        DPRINTK("EXIT\n");
+}
+
+/**
+ *      sata_pmp_read_gscr - read GSCR block of SATA PMP
+ *      @dev: PMP device
+ *      @gscr: buffer to read GSCR block into
+ *
+ *      Read selected PMP GSCRs from the PMP at @dev.  This will serve
+ *      as configuration and identification info for the PMP.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+static int sata_pmp_read_gscr(struct ata_device *dev, u32 *gscr)
+{
+        static const int gscr_to_read[] = { 0, 1, 2, 32, 33, 64, 96 };
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(gscr_to_read); i++) {
+                int reg = gscr_to_read[i];
+                unsigned int err_mask;
+
+                err_mask = sata_pmp_read(dev->link, reg, &gscr[reg]);
+                if (err_mask) {
+                        ata_dev_printk(dev, KERN_ERR, "failed to read PMP "
+                                "GSCR[%d] (Emask=0x%x)\n", reg, err_mask);
+                        return -EIO;
+                }
+        }
+
+        return 0;
+}
+
+static const char *sata_pmp_spec_rev_str(const u32 *gscr)
+{
+        u32 rev = gscr[SATA_PMP_GSCR_REV];
+
+        if (rev & (1 << 2))
+                return "1.1";
+        if (rev & (1 << 1))
+                return "1.0";
+        return "<unknown>";
+}
+
+static int sata_pmp_configure(struct ata_device *dev, int print_info)
+{
+        struct ata_port *ap = dev->link->ap;
+        u32 *gscr = dev->gscr;
+        unsigned int err_mask = 0;
+        const char *reason;
+        int nr_ports, rc;
+
+        nr_ports = sata_pmp_gscr_ports(gscr);
+
+        if (nr_ports <= 0 || nr_ports > SATA_PMP_MAX_PORTS) {
+                rc = -EINVAL;
+                reason = "invalid nr_ports";
+                goto fail;
+        }
+
+        if ((ap->flags & ATA_FLAG_AN) &&
+            (gscr[SATA_PMP_GSCR_FEAT] & SATA_PMP_FEAT_NOTIFY))
+                dev->flags |= ATA_DFLAG_AN;
+
+        /* monitor SERR_PHYRDY_CHG on fan-out ports */
+        err_mask = sata_pmp_write(dev->link, SATA_PMP_GSCR_ERROR_EN,
+                                  SERR_PHYRDY_CHG);
+        if (err_mask) {
+                rc = -EIO;
+                reason = "failed to write GSCR_ERROR_EN";
+                goto fail;
+        }
+
+        /* turn off notification till fan-out ports are reset and configured */
+        if (gscr[SATA_PMP_GSCR_FEAT_EN] & SATA_PMP_FEAT_NOTIFY) {
+                gscr[SATA_PMP_GSCR_FEAT_EN] &= ~SATA_PMP_FEAT_NOTIFY;
+
+                err_mask = sata_pmp_write(dev->link, SATA_PMP_GSCR_FEAT_EN,
+                                          gscr[SATA_PMP_GSCR_FEAT_EN]);
+                if (err_mask) {
+                        rc = -EIO;
+                        reason = "failed to write GSCR_FEAT_EN";
+                        goto fail;
+                }
+        }
+
+        if (print_info) {
+                ata_dev_printk(dev, KERN_INFO, "Port Multiplier %s, "
+                               "0x%04x:0x%04x r%d, %d ports, feat 0x%x/0x%x\n",
+                               sata_pmp_spec_rev_str(gscr),
+                               sata_pmp_gscr_vendor(gscr),
+                               sata_pmp_gscr_devid(gscr),
+                               sata_pmp_gscr_rev(gscr),
+                               nr_ports, gscr[SATA_PMP_GSCR_FEAT_EN],
+                               gscr[SATA_PMP_GSCR_FEAT]);
+
+                if (!(dev->flags & ATA_DFLAG_AN))
+                        ata_dev_printk(dev, KERN_INFO,
+                                "Asynchronous notification not supported, "
+                                "hotplug won't\n         work on fan-out "
+                                "ports. Use warm-plug instead.\n");
+        }
+
+        return 0;
+
+ fail:
+        ata_dev_printk(dev, KERN_ERR,
+                       "failed to configure Port Multiplier (%s, Emask=0x%x)\n",
+                       reason, err_mask);
+        return rc;
+}
+
+static int sata_pmp_init_links(struct ata_port *ap, int nr_ports)
+{
+        struct ata_link *pmp_link = ap->pmp_link;
+        int i;
+
+        if (!pmp_link) {
+                pmp_link = kzalloc(sizeof(pmp_link[0]) * SATA_PMP_MAX_PORTS,
+                                   GFP_NOIO);
+                if (!pmp_link)
+                        return -ENOMEM;
+
+                for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
+                        ata_link_init(ap, &pmp_link[i], i);
+
+                ap->pmp_link = pmp_link;
+        }
+
+        for (i = 0; i < nr_ports; i++) {
+                struct ata_link *link = &pmp_link[i];
+                struct ata_eh_context *ehc = &link->eh_context;
+
+                link->flags = 0;
+                ehc->i.probe_mask |= 1;
+                ehc->i.action |= ATA_EH_SOFTRESET;
+                ehc->i.flags |= ATA_EHI_RESUME_LINK;
+        }
+
+        return 0;
+}
+
+static void sata_pmp_quirks(struct ata_port *ap)
+{
+        u32 *gscr = ap->link.device->gscr;
+        u16 vendor = sata_pmp_gscr_vendor(gscr);
+        u16 devid = sata_pmp_gscr_devid(gscr);
+        struct ata_link *link;
+
+        if (vendor == 0x1095 && devid == 0x3726) {
+                /* sil3726 quirks */
+                ata_port_for_each_link(link, ap) {
+                        /* SError.N need a kick in the ass to get working */
+                        link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+
+                        /* class code report is unreliable */
+                        if (link->pmp < 5)
+                                link->flags |= ATA_LFLAG_ASSUME_ATA;
+
+                        /* port 5 is for SEMB device and it doesn't like SRST */
+                        if (link->pmp == 5)
+                                link->flags |= ATA_LFLAG_NO_SRST |
+                                               ATA_LFLAG_ASSUME_SEMB;
+                }
+        } else if (vendor == 0x1095 && devid == 0x4723) {
+                /* sil4723 quirks */
+                ata_port_for_each_link(link, ap) {
+                        /* SError.N need a kick in the ass to get working */
+                        link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+
+                        /* class code report is unreliable */
+                        if (link->pmp < 2)
+                                link->flags |= ATA_LFLAG_ASSUME_ATA;
+
+                        /* the config device at port 2 locks up on SRST */
+                        if (link->pmp == 2)
+                                link->flags |= ATA_LFLAG_NO_SRST |
+                                               ATA_LFLAG_ASSUME_ATA;
+                }
+        } else if (vendor == 0x1095 && devid == 0x4726) {
+                /* sil4726 quirks */
+                ata_port_for_each_link(link, ap) {
+                        /* SError.N need a kick in the ass to get working */
+                        link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+
+                        /* class code report is unreliable */
+                        if (link->pmp < 5)
+                                link->flags |= ATA_LFLAG_ASSUME_ATA;
+
+                        /* The config device, which can be either at
+                         * port 0 or 5, locks up on SRST.
+                         */
+                        if (link->pmp == 0 || link->pmp == 5)
+                                link->flags |= ATA_LFLAG_NO_SRST |
+                                               ATA_LFLAG_ASSUME_ATA;
+
+                        /* Port 6 is for SEMB device which doesn't
+                         * like SRST either.
+                         */
+                        if (link->pmp == 6)
+                                link->flags |= ATA_LFLAG_NO_SRST |
+                                               ATA_LFLAG_ASSUME_SEMB;
+                }
+        } else if (vendor == 0x1095 && (devid == 0x5723 || devid == 0x5733 ||
+                                        devid == 0x5734 || devid == 0x5744)) {
+                /* sil5723/5744 quirks */
+
+                /* sil5723/5744 has either two or three downstream
+                 * ports depending on operation mode.  The last port
+                 * is empty if any actual IO device is available or
+                 * occupied by a pseudo configuration device
+                 * otherwise.  Don't try hard to recover it.
+                 */
+                ap->pmp_link[ap->nr_pmp_links - 1].flags |= ATA_LFLAG_NO_RETRY;
+        } else if (vendor == 0x11ab && devid == 0x4140) {
+                /* Marvell 88SM4140 quirks.  Fan-out ports require PHY
+                 * reset to work; other than that, it behaves very
+                 * nicely.
+                 */
+                ata_port_for_each_link(link, ap)
+                        link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+        }
+}
+
+/**
+ *      sata_pmp_attach - attach a SATA PMP device
+ *      @dev: SATA PMP device to attach
+ *
+ *      Configure and attach SATA PMP device @dev.  This function is
+ *      also responsible for allocating and initializing PMP links.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+int sata_pmp_attach(struct ata_device *dev)
+{
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
+        unsigned long flags;
+        struct ata_link *tlink;
+        int rc;
+
+        /* is it hanging off the right place? */
+        if (!(ap->flags & ATA_FLAG_PMP)) {
+                ata_dev_printk(dev, KERN_ERR,
+                               "host does not support Port Multiplier\n");
+                return -EINVAL;
+        }
+
+        if (!ata_is_host_link(link)) {
+                ata_dev_printk(dev, KERN_ERR,
+                               "Port Multipliers cannot be nested\n");
+                return -EINVAL;
+        }
+
+        if (dev->devno) {
+                ata_dev_printk(dev, KERN_ERR,
+                               "Port Multiplier must be the first device\n");
+                return -EINVAL;
+        }
+
+        WARN_ON(link->pmp != 0);
+        link->pmp = SATA_PMP_CTRL_PORT;
+
+        /* read GSCR block */
+        rc = sata_pmp_read_gscr(dev, dev->gscr);
+        if (rc)
+                goto fail;
+
+        /* config PMP */
+        rc = sata_pmp_configure(dev, 1);
+        if (rc)
+                goto fail;
+
+        rc = sata_pmp_init_links(ap, sata_pmp_gscr_ports(dev->gscr));
+        if (rc) {
+                ata_dev_printk(dev, KERN_INFO,
+                               "failed to initialize PMP links\n");
+                goto fail;
+        }
+
+        /* attach it */
+        spin_lock_irqsave(ap->lock, flags);
+        WARN_ON(ap->nr_pmp_links);
+        ap->nr_pmp_links = sata_pmp_gscr_ports(dev->gscr);
+        spin_unlock_irqrestore(ap->lock, flags);
+
+        sata_pmp_quirks(ap);
+
+        if (ap->ops->pmp_attach)
+                ap->ops->pmp_attach(ap);
+
+        ata_port_for_each_link(tlink, ap)
+                sata_link_init_spd(tlink);
+
+        ata_acpi_associate_sata_port(ap);
+
+        return 0;
+
+ fail:
+        link->pmp = 0;
+        return rc;
+}
+
+/**
+ *      sata_pmp_detach - detach a SATA PMP device
+ *      @dev: SATA PMP device to detach
+ *
+ *      Detach SATA PMP device @dev.  This function is also
+ *      responsible for deconfiguring PMP links.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ */
+static void sata_pmp_detach(struct ata_device *dev)
+{
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
+        struct ata_link *tlink;
+        unsigned long flags;
+
+        ata_dev_printk(dev, KERN_INFO, "Port Multiplier detaching\n");
+
+        WARN_ON(!ata_is_host_link(link) || dev->devno ||
+                link->pmp != SATA_PMP_CTRL_PORT);
+
+        if (ap->ops->pmp_detach)
+                ap->ops->pmp_detach(ap);
+
+        ata_port_for_each_link(tlink, ap)
+                ata_eh_detach_dev(tlink->device);
+
+        spin_lock_irqsave(ap->lock, flags);
+        ap->nr_pmp_links = 0;
+        link->pmp = 0;
+        spin_unlock_irqrestore(ap->lock, flags);
+
+        ata_acpi_associate_sata_port(ap);
+}
+
+/**
+ *      sata_pmp_same_pmp - does new GSCR matches the configured PMP?
+ *      @dev: PMP device to compare against
+ *      @new_gscr: GSCR block of the new device
+ *
+ *      Compare @new_gscr against @dev and determine whether @dev is
+ *      the PMP described by @new_gscr.
+ *
+ *      LOCKING:
+ *      None.
+ *
+ *      RETURNS:
+ *      1 if @dev matches @new_gscr, 0 otherwise.
+ */
+static int sata_pmp_same_pmp(struct ata_device *dev, const u32 *new_gscr)
+{
+        const u32 *old_gscr = dev->gscr;
+        u16 old_vendor, new_vendor, old_devid, new_devid;
+        int old_nr_ports, new_nr_ports;
+
+        old_vendor = sata_pmp_gscr_vendor(old_gscr);
+        new_vendor = sata_pmp_gscr_vendor(new_gscr);
+        old_devid = sata_pmp_gscr_devid(old_gscr);
+        new_devid = sata_pmp_gscr_devid(new_gscr);
+        old_nr_ports = sata_pmp_gscr_ports(old_gscr);
+        new_nr_ports = sata_pmp_gscr_ports(new_gscr);
+
+        if (old_vendor != new_vendor) {
+                ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
+                               "vendor mismatch '0x%x' != '0x%x'\n",
+                               old_vendor, new_vendor);
+                return 0;
+        }
+
+        if (old_devid != new_devid) {
+                ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
+                               "device ID mismatch '0x%x' != '0x%x'\n",
+                               old_devid, new_devid);
+                return 0;
+        }
+
+        if (old_nr_ports != new_nr_ports) {
+                ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
+                               "nr_ports mismatch '0x%x' != '0x%x'\n",
+                               old_nr_ports, new_nr_ports);
+                return 0;
+        }
+
+        return 1;
+}
+
+/**
+ *      sata_pmp_revalidate - revalidate SATA PMP
+ *      @dev: PMP device to revalidate
+ *      @new_class: new class code
+ *
+ *      Re-read GSCR block and make sure @dev is still attached to the
+ *      port and properly configured.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
+ */
+static int sata_pmp_revalidate(struct ata_device *dev, unsigned int new_class)
+{
+        struct ata_link *link = dev->link;
+        struct ata_port *ap = link->ap;
+        u32 *gscr = (void *)ap->sector_buf;
+        int rc;
+
+        DPRINTK("ENTER\n");
+
+        ata_eh_about_to_do(link, NULL, ATA_EH_REVALIDATE);
+
+        if (!ata_dev_enabled(dev)) {
+                rc = -ENODEV;
+                goto fail;
+        }
+
+        /* wrong class? */
+        if (ata_class_enabled(new_class) && new_class != ATA_DEV_PMP) {
+                rc = -ENODEV;
+                goto fail;
+        }
+
+        /* read GSCR */
+        rc = sata_pmp_read_gscr(dev, gscr);
+        if (rc)
+                goto fail;
+
+        /* is the pmp still there? */
+        if (!sata_pmp_same_pmp(dev, gscr)) {
+                rc = -ENODEV;
+                goto fail;
+        }
+
+        memcpy(dev->gscr, gscr, sizeof(gscr[0]) * SATA_PMP_GSCR_DWORDS);
+
+        rc = sata_pmp_configure(dev, 0);
+        if (rc)
+                goto fail;
+
+        ata_eh_done(link, NULL, ATA_EH_REVALIDATE);
+
+        DPRINTK("EXIT, rc=0\n");
+        return 0;
+
+ fail:
+        ata_dev_printk(dev, KERN_ERR,
+                       "PMP revalidation failed (errno=%d)\n", rc);
+        DPRINTK("EXIT, rc=%d\n", rc);
+        return rc;
+}
+
+/**
+ *      sata_pmp_revalidate_quick - revalidate SATA PMP quickly
+ *      @dev: PMP device to revalidate
+ *
+ *      Make sure the attached PMP is accessible.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
+ */
+static int sata_pmp_revalidate_quick(struct ata_device *dev)
+{
+        unsigned int err_mask;
+        u32 prod_id;
+
+        err_mask = sata_pmp_read(dev->link, SATA_PMP_GSCR_PROD_ID, &prod_id);
+        if (err_mask) {
+                ata_dev_printk(dev, KERN_ERR, "failed to read PMP product ID "
+                               "(Emask=0x%x)\n", err_mask);
+                return -EIO;
+        }
+
+        if (prod_id != dev->gscr[SATA_PMP_GSCR_PROD_ID]) {
+                ata_dev_printk(dev, KERN_ERR, "PMP product ID mismatch\n");
+                /* something weird is going on, request full PMP recovery */
+                return -EIO;
+        }
+
+        return 0;
+}
+
+/**
+ *      sata_pmp_eh_recover_pmp - recover PMP
+ *      @ap: ATA port PMP is attached to
+ *      @prereset: prereset method (can be NULL)
+ *      @softreset: softreset method
+ *      @hardreset: hardreset method
+ *      @postreset: postreset method (can be NULL)
+ *
+ *      Recover PMP attached to @ap.  Recovery procedure is somewhat
+ *      similar to that of ata_eh_recover() except that reset should
+ *      always be performed in hard->soft sequence and recovery
+ *      failure results in PMP detachment.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+static int sata_pmp_eh_recover_pmp(struct ata_port *ap,
+                ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
+                ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
+{
+        struct ata_link *link = &ap->link;
+        struct ata_eh_context *ehc = &link->eh_context;
+        struct ata_device *dev = link->device;
+        int tries = ATA_EH_PMP_TRIES;
+        int detach = 0, rc = 0;
+        int reval_failed = 0;
+
+        DPRINTK("ENTER\n");
+
+        if (dev->flags & ATA_DFLAG_DETACH) {
+                detach = 1;
+                goto fail;
+        }
+
+ retry:
+        ehc->classes[0] = ATA_DEV_UNKNOWN;
+
+        if (ehc->i.action & ATA_EH_RESET_MASK) {
+                struct ata_link *tlink;
+
+                ata_eh_freeze_port(ap);
+
+                /* reset */
+                ehc->i.action = ATA_EH_HARDRESET;
+                rc = ata_eh_reset(link, 0, prereset, softreset, hardreset,
+                                  postreset);
+                if (rc) {
+                        ata_link_printk(link, KERN_ERR,
+                                        "failed to reset PMP, giving up\n");
+                        goto fail;
+                }
+
+                ata_eh_thaw_port(ap);
+
+                /* PMP is reset, SErrors cannot be trusted, scan all */
+                ata_port_for_each_link(tlink, ap)
+                        ata_ehi_schedule_probe(&tlink->eh_context.i);
+        }
+
+        /* If revalidation is requested, revalidate and reconfigure;
+         * otherwise, do quick revalidation.
+         */
+        if (ehc->i.action & ATA_EH_REVALIDATE)
+                rc = sata_pmp_revalidate(dev, ehc->classes[0]);
+        else
+                rc = sata_pmp_revalidate_quick(dev);
+
+        if (rc) {
+                tries--;
+
+                if (rc == -ENODEV) {
+                        ehc->i.probe_mask |= 1;
+                        detach = 1;
+                        /* give it just two more chances */
+                        tries = min(tries, 2);
+                }
+
+                if (tries) {
+                        int sleep = ehc->i.flags & ATA_EHI_DID_RESET;
+
+                        /* consecutive revalidation failures? speed down */
+                        if (reval_failed)
+                                sata_down_spd_limit(link);
+                        else
+                                reval_failed = 1;
+
+                        ata_dev_printk(dev, KERN_WARNING,
+                                       "retrying hardreset%s\n",
+                                       sleep ? " in 5 secs" : "");
+                        if (sleep)
+                                ssleep(5);
+                        ehc->i.action |= ATA_EH_HARDRESET;
+                        goto retry;
+                } else {
+                        ata_dev_printk(dev, KERN_ERR, "failed to recover PMP "
+                                       "after %d tries, giving up\n",
+                                       ATA_EH_PMP_TRIES);
+                        goto fail;
+                }
+        }
+
+        /* okay, PMP resurrected */
+        ehc->i.flags = 0;
+
+        DPRINTK("EXIT, rc=0\n");
+        return 0;
+
+ fail:
+        sata_pmp_detach(dev);
+        if (detach)
+                ata_eh_detach_dev(dev);
+        else
+                ata_dev_disable(dev);
+
+        DPRINTK("EXIT, rc=%d\n", rc);
+        return rc;
+}
+
+static int sata_pmp_eh_handle_disabled_links(struct ata_port *ap)
+{
+        struct ata_link *link;
+        unsigned long flags;
+        int rc;
+
+        spin_lock_irqsave(ap->lock, flags);
+
+        ata_port_for_each_link(link, ap) {
+                if (!(link->flags & ATA_LFLAG_DISABLED))
+                        continue;
+
+                spin_unlock_irqrestore(ap->lock, flags);
+
+                /* Some PMPs require hardreset sequence to get
+                 * SError.N working.
+                 */
+                if ((link->flags & ATA_LFLAG_HRST_TO_RESUME) &&
+                    (link->eh_context.i.flags & ATA_EHI_RESUME_LINK))
+                        sata_link_hardreset(link, sata_deb_timing_normal,
+                                            jiffies + ATA_TMOUT_INTERNAL_QUICK);
+
+                /* unconditionally clear SError.N */
+                rc = sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
+                if (rc) {
+                        ata_link_printk(link, KERN_ERR, "failed to clear "
+                                        "SError.N (errno=%d)\n", rc);
+                        return rc;
+                }
+
+                spin_lock_irqsave(ap->lock, flags);
+        }
+
+        spin_unlock_irqrestore(ap->lock, flags);
+
+        return 0;
+}
+
+static int sata_pmp_handle_link_fail(struct ata_link *link, int *link_tries)
+{
+        struct ata_port *ap = link->ap;
+        unsigned long flags;
+
+        if (link_tries[link->pmp] && --link_tries[link->pmp])
+                return 1;
+
+        /* disable this link */
+        if (!(link->flags & ATA_LFLAG_DISABLED)) {
+                ata_link_printk(link, KERN_WARNING,
+                        "failed to recover link after %d tries, disabling\n",
+                        ATA_EH_PMP_LINK_TRIES);
+
+                spin_lock_irqsave(ap->lock, flags);
+                link->flags |= ATA_LFLAG_DISABLED;
+                spin_unlock_irqrestore(ap->lock, flags);
+        }
+
+        ata_dev_disable(link->device);
+        link->eh_context.i.action = 0;
+
+        return 0;
+}
+
+/**
+ *      sata_pmp_eh_recover - recover PMP-enabled port
+ *      @ap: ATA port to recover
+ *      @prereset: prereset method (can be NULL)
+ *      @softreset: softreset method
+ *      @hardreset: hardreset method
+ *      @postreset: postreset method (can be NULL)
+ *      @pmp_prereset: PMP prereset method (can be NULL)
+ *      @pmp_softreset: PMP softreset method (can be NULL)
+ *      @pmp_hardreset: PMP hardreset method (can be NULL)
+ *      @pmp_postreset: PMP postreset method (can be NULL)
+ *
+ *      Drive EH recovery operation for PMP enabled port @ap.  This
+ *      function recovers host and PMP ports with proper retrials and
+ *      fallbacks.  Actual recovery operations are performed using
+ *      ata_eh_recover() and sata_pmp_eh_recover_pmp().
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+static int sata_pmp_eh_recover(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)
+{
+        int pmp_tries, link_tries[SATA_PMP_MAX_PORTS];
+        struct ata_link *pmp_link = &ap->link;
+        struct ata_device *pmp_dev = pmp_link->device;
+        struct ata_eh_context *pmp_ehc = &pmp_link->eh_context;
+        struct ata_link *link;
+        struct ata_device *dev;
+        unsigned int err_mask;
+        u32 gscr_error, sntf;
+        int cnt, rc;
+
+        pmp_tries = ATA_EH_PMP_TRIES;
+        ata_port_for_each_link(link, ap)
+                link_tries[link->pmp] = ATA_EH_PMP_LINK_TRIES;
+
+ retry:
+        /* PMP attached? */
+        if (!ap->nr_pmp_links) {
+                rc = ata_eh_recover(ap, prereset, softreset, hardreset,
+                                    postreset, NULL);
+                if (rc) {
+                        ata_link_for_each_dev(dev, &ap->link)
+                                ata_dev_disable(dev);
+                        return rc;
+                }
+
+                if (pmp_dev->class != ATA_DEV_PMP)
+                        return 0;
+
+                /* new PMP online */
+                ata_port_for_each_link(link, ap)
+                        link_tries[link->pmp] = ATA_EH_PMP_LINK_TRIES;
+
+                /* fall through */
+        }
+
+        /* recover pmp */
+        rc = sata_pmp_eh_recover_pmp(ap, prereset, softreset, hardreset,
+                                     postreset);
+        if (rc)
+                goto pmp_fail;
+
+        /* handle disabled links */
+        rc = sata_pmp_eh_handle_disabled_links(ap);
+        if (rc)
+                goto pmp_fail;
+
+        /* recover links */
+        rc = ata_eh_recover(ap, pmp_prereset, pmp_softreset, pmp_hardreset,
+                            pmp_postreset, &link);
+        if (rc)
+                goto link_fail;
+
+        /* Connection status might have changed while resetting other
+         * links, check SATA_PMP_GSCR_ERROR before returning.
+         */
+
+        /* clear SNotification */
+        rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
+        if (rc == 0)
+                sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
+
+        /* enable notification */
+        if (pmp_dev->flags & ATA_DFLAG_AN) {
+                pmp_dev->gscr[SATA_PMP_GSCR_FEAT_EN] |= SATA_PMP_FEAT_NOTIFY;
+
+                err_mask = sata_pmp_write(pmp_dev->link, SATA_PMP_GSCR_FEAT_EN,
+                                          pmp_dev->gscr[SATA_PMP_GSCR_FEAT_EN]);
+                if (err_mask) {
+                        ata_dev_printk(pmp_dev, KERN_ERR, "failed to write "
+                                       "PMP_FEAT_EN (Emask=0x%x)\n", err_mask);
+                        rc = -EIO;
+                        goto pmp_fail;
+                }
+        }
+
+        /* check GSCR_ERROR */
+        err_mask = sata_pmp_read(pmp_link, SATA_PMP_GSCR_ERROR, &gscr_error);
+        if (err_mask) {
+                ata_dev_printk(pmp_dev, KERN_ERR, "failed to read "
+                               "PMP_GSCR_ERROR (Emask=0x%x)\n", err_mask);
+                rc = -EIO;
+                goto pmp_fail;
+        }
+
+        cnt = 0;
+        ata_port_for_each_link(link, ap) {
+                if (!(gscr_error & (1 << link->pmp)))
+                        continue;
+
+                if (sata_pmp_handle_link_fail(link, link_tries)) {
+                        ata_ehi_hotplugged(&link->eh_context.i);
+                        cnt++;
+                } else {
+                        ata_link_printk(link, KERN_WARNING,
+                                "PHY status changed but maxed out on retries, "
+                                "giving up\n");
+                        ata_link_printk(link, KERN_WARNING,
+                                "Manully issue scan to resume this link\n");
+                }
+        }
+
+        if (cnt) {
+                ata_port_printk(ap, KERN_INFO, "PMP SError.N set for some "
+                                "ports, repeating recovery\n");
+                goto retry;
+        }
+
+        return 0;
+
+ link_fail:
+        if (sata_pmp_handle_link_fail(link, link_tries)) {
+                pmp_ehc->i.action |= ATA_EH_HARDRESET;
+                goto retry;
+        }
+
+        /* fall through */
+ pmp_fail:
+        /* Control always ends up here after detaching PMP.  Shut up
+         * and return if we're unloading.
+         */
+        if (ap->pflags & ATA_PFLAG_UNLOADING)
+                return rc;
+
+        if (!ap->nr_pmp_links)
+                goto retry;
+
+        if (--pmp_tries) {
+                ata_port_printk(ap, KERN_WARNING,
+                                "failed to recover PMP, retrying in 5 secs\n");
+                pmp_ehc->i.action |= ATA_EH_HARDRESET;
+                ssleep(5);
+                goto retry;
+        }
+
+        ata_port_printk(ap, KERN_ERR,
+                        "failed to recover PMP after %d tries, giving up\n",
+                        ATA_EH_PMP_TRIES);
+        sata_pmp_detach(pmp_dev);
+        ata_dev_disable(pmp_dev);
+
+        return rc;
+}
+
+/**
+ *      sata_pmp_do_eh - do standard error handling for PMP-enabled host
+ *      @ap: host port to handle error for
+ *      @prereset: prereset method (can be NULL)
+ *      @softreset: softreset method
+ *      @hardreset: hardreset method
+ *      @postreset: postreset method (can be NULL)
+ *      @pmp_prereset: PMP prereset method (can be NULL)
+ *      @pmp_softreset: PMP softreset method (can be NULL)
+ *      @pmp_hardreset: PMP hardreset method (can be NULL)
+ *      @pmp_postreset: PMP postreset method (can be NULL)
+ *
+ *      Perform standard error handling sequence for PMP-enabled host
+ *      @ap.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ */
+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)
+{
+        ata_eh_autopsy(ap);
+        ata_eh_report(ap);
+        sata_pmp_eh_recover(ap, prereset, softreset, hardreset, postreset,
+                            pmp_prereset, pmp_softreset, pmp_hardreset,
+                            pmp_postreset);
+        ata_eh_finish(ap);
+}
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index e83647651b31..ea53e6a570b4 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -71,11 +71,10 @@ static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
 #define ALL_SUB_MPAGES 0xff
 
 
-static const u8 def_rw_recovery_mpage[] = {
+static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = {
         RW_RECOVERY_MPAGE,
         RW_RECOVERY_MPAGE_LEN - 2,
-        (1 << 7) |      /* AWRE, sat-r06 say it shall be 0 */
-            (1 << 6),   /* ARRE (auto read reallocation) */
+        (1 << 7),       /* AWRE */
         0,              /* read retry count */
         0, 0, 0, 0,
         0,              /* write retry count */
@@ -450,13 +449,8 @@ static struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
                 qc->scsicmd = cmd;
                 qc->scsidone = done;
 
-                if (cmd->use_sg) {
-                        qc->__sg = (struct scatterlist *) cmd->request_buffer;
-                        qc->n_elem = cmd->use_sg;
-                } else if (cmd->request_bufflen) {
-                        qc->__sg = &qc->sgent;
-                        qc->n_elem = 1;
-                }
+                qc->__sg = scsi_sglist(cmd);
+                qc->n_elem = scsi_sg_count(cmd);
         } else {
                 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
                 done(cmd);
@@ -755,6 +749,13 @@ static void ata_scsi_sdev_config(struct scsi_device *sdev)
 {
         sdev->use_10_for_rw = 1;
         sdev->use_10_for_ms = 1;
+
+        /* Schedule policy is determined by ->qc_defer() callback and
+         * it needs to see every deferred qc.  Set dev_blocked to 1 to
+         * prevent SCSI midlayer from automatically deferring
+         * requests.
+         */
+        sdev->max_device_blocked = 1;
 }
 
 static void ata_scsi_dev_config(struct scsi_device *sdev,
@@ -943,6 +944,13 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
                 goto invalid_fld;       /* LOEJ bit set not supported */
         if (((cdb[4] >> 4) & 0xf) != 0)
                 goto invalid_fld;       /* power conditions not supported */
+
+        if (qc->dev->horkage & ATA_HORKAGE_SKIP_PM) {
+                /* the device lacks PM support, finish without doing anything */
+                scmd->result = SAM_STAT_GOOD;
+                return 1;
+        }
+
         if (cdb[4] & 0x1) {
                 tf->nsect = 1;  /* 1 sector, lba=0 */
 
@@ -1368,14 +1376,14 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
                 case ATA_CMD_SET_FEATURES:
                         if ((qc->tf.feature == SETFEATURES_WC_ON) ||
                             (qc->tf.feature == SETFEATURES_WC_OFF)) {
-                                ap->eh_info.action |= ATA_EH_REVALIDATE;
+                                ap->link.eh_info.action |= ATA_EH_REVALIDATE;
                                 ata_port_schedule_eh(ap);
                         }
                         break;
 
                 case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */
                 case ATA_CMD_SET_MULTI: /* multi_count changed */
-                        ap->eh_info.action |= ATA_EH_REVALIDATE;
+                        ap->link.eh_info.action |= ATA_EH_REVALIDATE;
                         ata_port_schedule_eh(ap);
                         break;
                 }
@@ -1422,37 +1430,6 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
 }
 
 /**
- *      ata_scmd_need_defer - Check whether we need to defer scmd
- *      @dev: ATA device to which the command is addressed
- *      @is_io: Is the command IO (and thus possibly NCQ)?
- *
- *      NCQ and non-NCQ commands cannot run together.  As upper layer
- *      only knows the queue depth, we are responsible for maintaining
- *      exclusion.  This function checks whether a new command can be
- *      issued to @dev.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- *
- *      RETURNS:
- *      1 if deferring is needed, 0 otherwise.
- */
-static int ata_scmd_need_defer(struct ata_device *dev, int is_io)
-{
-        struct ata_port *ap = dev->ap;
-        int is_ncq = is_io && ata_ncq_enabled(dev);
-
-        if (is_ncq) {
-                if (!ata_tag_valid(ap->active_tag))
-                        return 0;
-        } else {
-                if (!ata_tag_valid(ap->active_tag) && !ap->sactive)
-                        return 0;
-        }
-        return 1;
-}
-
-/**
  *      ata_scsi_translate - Translate then issue SCSI command to ATA device
  *      @dev: ATA device to which the command is addressed
  *      @cmd: SCSI command to execute
@@ -1483,14 +1460,12 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
                               void (*done)(struct scsi_cmnd *),
                               ata_xlat_func_t xlat_func)
 {
+        struct ata_port *ap = dev->link->ap;
         struct ata_queued_cmd *qc;
-        int is_io = xlat_func == ata_scsi_rw_xlat;
+        int rc;
 
         VPRINTK("ENTER\n");
 
-        if (unlikely(ata_scmd_need_defer(dev, is_io)))
-                goto defer;
-
         qc = ata_scsi_qc_new(dev, cmd, done);
         if (!qc)
                 goto err_mem;
@@ -1498,17 +1473,13 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
         /* data is present; dma-map it */
         if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
             cmd->sc_data_direction == DMA_TO_DEVICE) {
-                if (unlikely(cmd->request_bufflen < 1)) {
+                if (unlikely(scsi_bufflen(cmd) < 1)) {
                         ata_dev_printk(dev, KERN_WARNING,
                                        "WARNING: zero len r/w req\n");
                         goto err_did;
                 }
 
-                if (cmd->use_sg)
-                        ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
-                else
-                        ata_sg_init_one(qc, cmd->request_buffer,
-                                        cmd->request_bufflen);
+                ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));
 
                 qc->dma_dir = cmd->sc_data_direction;
         }
@@ -1518,6 +1489,11 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
         if (xlat_func(qc))
                 goto early_finish;
 
+        if (ap->ops->qc_defer) {
+                if ((rc = ap->ops->qc_defer(qc)))
+                        goto defer;
+        }
+
         /* select device, send command to hardware */
         ata_qc_issue(qc);
 
@@ -1539,8 +1515,12 @@ err_mem:
         return 0;
 
 defer:
+        ata_qc_free(qc);
         DPRINTK("EXIT - defer\n");
-        return SCSI_MLQUEUE_DEVICE_BUSY;
+        if (rc == ATA_DEFER_LINK)
+                return SCSI_MLQUEUE_DEVICE_BUSY;
+        else
+                return SCSI_MLQUEUE_HOST_BUSY;
 }
 
 /**
@@ -1562,15 +1542,14 @@ static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
         u8 *buf;
         unsigned int buflen;
 
-        if (cmd->use_sg) {
-                struct scatterlist *sg;
+        struct scatterlist *sg = scsi_sglist(cmd);
 
-                sg = (struct scatterlist *) cmd->request_buffer;
+        if (sg) {
                 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
                 buflen = sg->length;
         } else {
-                buf = cmd->request_buffer;
-                buflen = cmd->request_bufflen;
+                buf = NULL;
+                buflen = 0;
         }
 
         *buf_out = buf;
@@ -1590,12 +1569,9 @@ static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
 
 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
 {
-        if (cmd->use_sg) {
-                struct scatterlist *sg;
-
-                sg = (struct scatterlist *) cmd->request_buffer;
+        struct scatterlist *sg = scsi_sglist(cmd);
+        if (sg)
                 kunmap_atomic(buf - sg->offset, KM_IRQ0);
-        }
 }
 
 /**
@@ -1817,6 +1793,62 @@ unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
 }
 
 /**
+ *      ata_scsiop_inq_89 - Simulate INQUIRY VPD page 89, ATA info
+ *      @args: device IDENTIFY data / SCSI command of interest.
+ *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
+ *      @buflen: Response buffer length.
+ *
+ *      Yields SAT-specified ATA VPD page.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+
+unsigned int ata_scsiop_inq_89(struct ata_scsi_args *args, u8 *rbuf,
+                              unsigned int buflen)
+{
+        u8 pbuf[60];
+        struct ata_taskfile tf;
+        unsigned int i;
+
+        if (!buflen)
+                return 0;
+
+        memset(&pbuf, 0, sizeof(pbuf));
+        memset(&tf, 0, sizeof(tf));
+
+        pbuf[1] = 0x89;                 /* our page code */
+        pbuf[2] = (0x238 >> 8);         /* page size fixed at 238h */
+        pbuf[3] = (0x238 & 0xff);
+
+        memcpy(&pbuf[8], "linux   ", 8);
+        memcpy(&pbuf[16], "libata          ", 16);
+        memcpy(&pbuf[32], DRV_VERSION, 4);
+        ata_id_string(args->id, &pbuf[32], ATA_ID_FW_REV, 4);
+
+        /* we don't store the ATA device signature, so we fake it */
+
+        tf.command = ATA_DRDY;          /* really, this is Status reg */
+        tf.lbal = 0x1;
+        tf.nsect = 0x1;
+
+        ata_tf_to_fis(&tf, 0, 1, &pbuf[36]);    /* TODO: PMP? */
+        pbuf[36] = 0x34;                /* force D2H Reg FIS (34h) */
+
+        pbuf[56] = ATA_CMD_ID_ATA;
+
+        i = min(buflen, 60U);
+        memcpy(rbuf, &pbuf[0], i);
+        buflen -= i;
+
+        if (!buflen)
+                return 0;
+
+        memcpy(&rbuf[60], &args->id[0], min(buflen, 512U));
+        return 0;
+}
+
+/**
  *      ata_scsiop_noop - Command handler that simply returns success.
  *      @args: device IDENTIFY data / SCSI command of interest.
  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
@@ -2273,8 +2305,8 @@ static void atapi_request_sense(struct ata_queued_cmd *qc)
                 qc->tf.feature |= ATAPI_PKT_DMA;
         } else {
                 qc->tf.protocol = ATA_PROT_ATAPI;
-                qc->tf.lbam = (8 * 1024) & 0xff;
-                qc->tf.lbah = (8 * 1024) >> 8;
+                qc->tf.lbam = SCSI_SENSE_BUFFERSIZE;
+                qc->tf.lbah = 0;
         }
         qc->nbytes = SCSI_SENSE_BUFFERSIZE;
 
@@ -2383,6 +2415,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
         struct ata_device *dev = qc->dev;
         int using_pio = (dev->flags & ATA_DFLAG_PIO);
         int nodata = (scmd->sc_data_direction == DMA_NONE);
+        unsigned int nbytes;
 
         memset(qc->cdb, 0, dev->cdb_len);
         memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
@@ -2396,20 +2429,26 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
         }
 
         qc->tf.command = ATA_CMD_PACKET;
-        qc->nbytes = scmd->request_bufflen;
+        qc->nbytes = scsi_bufflen(scmd);
 
         /* check whether ATAPI DMA is safe */
         if (!using_pio && ata_check_atapi_dma(qc))
                 using_pio = 1;
 
+        /* Some controller variants snoop this value for Packet transfers
+           to do state machine and FIFO management. Thus we want to set it
+           properly, and for DMA where it is effectively meaningless */
+        nbytes = min(qc->nbytes, (unsigned int)63 * 1024);
+
+        qc->tf.lbam = (nbytes & 0xFF);
+        qc->tf.lbah = (nbytes >> 8);
+
         if (using_pio || nodata) {
                 /* no data, or PIO data xfer */
                 if (nodata)
                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
                 else
                         qc->tf.protocol = ATA_PROT_ATAPI;
-                qc->tf.lbam = (8 * 1024) & 0xff;
-                qc->tf.lbah = (8 * 1024) >> 8;
         } else {
                 /* DMA data xfer */
                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
@@ -2420,24 +2459,42 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
                         qc->tf.feature |= ATAPI_DMADIR;
         }
 
+
+        /* FIXME: We need to translate 0x05 READ_BLOCK_LIMITS to a MODE_SENSE
+           as ATAPI tape drives don't get this right otherwise */
         return 0;
 }
 
-static struct ata_device * ata_find_dev(struct ata_port *ap, int id)
+static struct ata_device * ata_find_dev(struct ata_port *ap, int devno)
 {
-        if (likely(id < ATA_MAX_DEVICES))
-                return &ap->device[id];
+        if (ap->nr_pmp_links == 0) {
+                if (likely(devno < ata_link_max_devices(&ap->link)))
+                        return &ap->link.device[devno];
+        } else {
+                if (likely(devno < ap->nr_pmp_links))
+                        return &ap->pmp_link[devno].device[0];
+        }
+
         return NULL;
 }
 
 static struct ata_device * __ata_scsi_find_dev(struct ata_port *ap,
                                         const struct scsi_device *scsidev)
 {
+        int devno;
+
         /* skip commands not addressed to targets we simulate */
-        if (unlikely(scsidev->channel || scsidev->lun))
-                return NULL;
+        if (ap->nr_pmp_links == 0) {
+                if (unlikely(scsidev->channel || scsidev->lun))
+                        return NULL;
+                devno = scsidev->id;
+        } else {
+                if (unlikely(scsidev->id || scsidev->lun))
+                        return NULL;
+                devno = scsidev->channel;
+        }
 
-        return ata_find_dev(ap, scsidev->id);
+        return ata_find_dev(ap, devno);
 }
 
 /**
@@ -2458,7 +2515,7 @@ static int ata_scsi_dev_enabled(struct ata_device *dev)
         if (unlikely(!ata_dev_enabled(dev)))
                 return 0;
 
-        if (!atapi_enabled || (dev->ap->flags & ATA_FLAG_NO_ATAPI)) {
+        if (!atapi_enabled || (dev->link->ap->flags & ATA_FLAG_NO_ATAPI)) {
                 if (unlikely(dev->class == ATA_DEV_ATAPI)) {
                         ata_dev_printk(dev, KERN_WARNING,
                                        "WARNING: ATAPI is %s, device ignored.\n",
@@ -2631,7 +2688,7 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
         case ATA_CMD_WRITE_LONG_ONCE:
                 if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
                         goto invalid_fld;
-                qc->sect_size = scmd->request_bufflen;
+                qc->sect_size = scsi_bufflen(scmd);
         }
 
         /*
@@ -2661,7 +2718,7 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
          * TODO: find out if we need to do more here to
          *       cover scatter/gather case.
          */
-        qc->nbytes = scmd->request_bufflen;
+        qc->nbytes = scsi_bufflen(scmd);
 
         /* request result TF */
         qc->flags |= ATA_QCFLAG_RESULT_TF;
@@ -2746,28 +2803,48 @@ static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
                                       void (*done)(struct scsi_cmnd *),
                                       struct ata_device *dev)
 {
+        u8 scsi_op = scmd->cmnd[0];
+        ata_xlat_func_t xlat_func;
         int rc = 0;
 
-        if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len)) {
-                DPRINTK("bad CDB len=%u, max=%u\n",
-                        scmd->cmd_len, dev->cdb_len);
-                scmd->result = DID_ERROR << 16;
-                done(scmd);
-                return 0;
-        }
-
         if (dev->class == ATA_DEV_ATA) {
-                ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
-                                                              scmd->cmnd[0]);
+                if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len))
+                        goto bad_cdb_len;
 
-                if (xlat_func)
-                        rc = ata_scsi_translate(dev, scmd, done, xlat_func);
-                else
-                        ata_scsi_simulate(dev, scmd, done);
-        } else
-                rc = ata_scsi_translate(dev, scmd, done, atapi_xlat);
+                xlat_func = ata_get_xlat_func(dev, scsi_op);
+        } else {
+                if (unlikely(!scmd->cmd_len))
+                        goto bad_cdb_len;
+
+                xlat_func = NULL;
+                if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {
+                        /* relay SCSI command to ATAPI device */
+                        if (unlikely(scmd->cmd_len > dev->cdb_len))
+                                goto bad_cdb_len;
+
+                        xlat_func = atapi_xlat;
+                } else {
+                        /* ATA_16 passthru, treat as an ATA command */
+                        if (unlikely(scmd->cmd_len > 16))
+                                goto bad_cdb_len;
+
+                        xlat_func = ata_get_xlat_func(dev, scsi_op);
+                }
+        }
+
+        if (xlat_func)
+                rc = ata_scsi_translate(dev, scmd, done, xlat_func);
+        else
+                ata_scsi_simulate(dev, scmd, done);
 
         return rc;
+
+ bad_cdb_len:
+        DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",
+                scmd->cmd_len, scsi_op, dev->cdb_len);
+        scmd->result = DID_ERROR << 16;
+        done(scmd);
+        return 0;
 }
 
 /**
@@ -2835,6 +2912,7 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
 {
         struct ata_scsi_args args;
         const u8 *scsicmd = cmd->cmnd;
+        u8 tmp8;
 
         args.dev = dev;
         args.id = dev->id;
@@ -2842,15 +2920,9 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
         args.done = done;
 
         switch(scsicmd[0]) {
-                /* no-op's, complete with success */
-                case SYNCHRONIZE_CACHE:
-                case REZERO_UNIT:
-                case SEEK_6:
-                case SEEK_10:
-                case TEST_UNIT_READY:
-                case FORMAT_UNIT:               /* FIXME: correct? */
-                case SEND_DIAGNOSTIC:           /* FIXME: correct? */
-                        ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
+                /* TODO: worth improving? */
+                case FORMAT_UNIT:
+                        ata_scsi_invalid_field(cmd, done);
                         break;
 
                 case INQUIRY:
@@ -2858,14 +2930,23 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
                                 ata_scsi_invalid_field(cmd, done);
                         else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
-                        else if (scsicmd[2] == 0x00)
+                        else switch (scsicmd[2]) {
+                        case 0x00:
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
-                        else if (scsicmd[2] == 0x80)
+                                break;
+                        case 0x80:
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
-                        else if (scsicmd[2] == 0x83)
+                                break;
+                        case 0x83:
                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
-                        else
+                                break;
+                        case 0x89:
+                                ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
+                                break;
+                        default:
                                 ata_scsi_invalid_field(cmd, done);
+                                break;
+                        }
                         break;
 
                 case MODE_SENSE:
@@ -2893,8 +2974,33 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
                         ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
                         break;
 
-                /* mandatory commands we haven't implemented yet */
                 case REQUEST_SENSE:
+                        ata_scsi_set_sense(cmd, 0, 0, 0);
+                        cmd->result = (DRIVER_SENSE << 24);
+                        done(cmd);
+                        break;
+
+                /* if we reach this, then writeback caching is disabled,
+                 * turning this into a no-op.
+                 */
+                case SYNCHRONIZE_CACHE:
+                        /* fall through */
+
+                /* no-op's, complete with success */
+                case REZERO_UNIT:
+                case SEEK_6:
+                case SEEK_10:
+                case TEST_UNIT_READY:
+                        ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
+                        break;
+
+                case SEND_DIAGNOSTIC:
+                        tmp8 = scsicmd[1] & ~(1 << 3);
+                        if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
+                                ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
+                        else
+                                ata_scsi_invalid_field(cmd, done);
+                        break;
 
                 /* all other commands */
                 default:
@@ -2928,6 +3034,13 @@ int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
                 shost->max_channel = 1;
                 shost->max_cmd_len = 16;
 
+                /* Schedule policy is determined by ->qc_defer()
+                 * callback and it needs to see every deferred qc.
+                 * Set host_blocked to 1 to prevent SCSI midlayer from
+                 * automatically deferring requests.
+                 */
+                shost->max_host_blocked = 1;
+
                 rc = scsi_add_host(ap->scsi_host, ap->host->dev);
                 if (rc)
                         goto err_add;
@@ -2951,25 +3064,32 @@ void ata_scsi_scan_host(struct ata_port *ap, int sync)
 {
         int tries = 5;
         struct ata_device *last_failed_dev = NULL;
+        struct ata_link *link;
         struct ata_device *dev;
-        unsigned int i;
 
         if (ap->flags & ATA_FLAG_DISABLED)
                 return;
 
  repeat:
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct scsi_device *sdev;
+        ata_port_for_each_link(link, ap) {
+                ata_link_for_each_dev(dev, link) {
+                        struct scsi_device *sdev;
+                        int channel = 0, id = 0;
 
-                dev = &ap->device[i];
+                        if (!ata_dev_enabled(dev) || dev->sdev)
+                                continue;
 
-                if (!ata_dev_enabled(dev) || dev->sdev)
-                        continue;
+                        if (ata_is_host_link(link))
+                                id = dev->devno;
+                        else
+                                channel = link->pmp;
 
-                sdev = __scsi_add_device(ap->scsi_host, 0, i, 0, NULL);
-                if (!IS_ERR(sdev)) {
-                        dev->sdev = sdev;
-                        scsi_device_put(sdev);
+                        sdev = __scsi_add_device(ap->scsi_host, channel, id, 0,
+                                                 NULL);
+                        if (!IS_ERR(sdev)) {
+                                dev->sdev = sdev;
+                                scsi_device_put(sdev);
+                        }
                 }
         }
 
@@ -2977,12 +3097,14 @@ void ata_scsi_scan_host(struct ata_port *ap, int sync)
          * failure occurred, scan would have failed silently.  Check
          * whether all devices are attached.
          */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                dev = &ap->device[i];
-                if (ata_dev_enabled(dev) && !dev->sdev)
-                        break;
+        ata_port_for_each_link(link, ap) {
+                ata_link_for_each_dev(dev, link) {
+                        if (ata_dev_enabled(dev) && !dev->sdev)
+                                goto exit_loop;
+                }
         }
-        if (i == ATA_MAX_DEVICES)
+ exit_loop:
+        if (!link)
                 return;
 
         /* we're missing some SCSI devices */
@@ -3049,7 +3171,7 @@ int ata_scsi_offline_dev(struct ata_device *dev)
  */
 static void ata_scsi_remove_dev(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
+        struct ata_port *ap = dev->link->ap;
         struct scsi_device *sdev;
         unsigned long flags;
 
@@ -3096,6 +3218,43 @@ static void ata_scsi_remove_dev(struct ata_device *dev)
         }
 }
 
+static void ata_scsi_handle_link_detach(struct ata_link *link)
+{
+        struct ata_port *ap = link->ap;
+        struct ata_device *dev;
+
+        ata_link_for_each_dev(dev, link) {
+                unsigned long flags;
+
+                if (!(dev->flags & ATA_DFLAG_DETACHED))
+                        continue;
+
+                spin_lock_irqsave(ap->lock, flags);
+                dev->flags &= ~ATA_DFLAG_DETACHED;
+                spin_unlock_irqrestore(ap->lock, flags);
+
+                ata_scsi_remove_dev(dev);
+        }
+}
+
+/**
+ *      ata_scsi_media_change_notify - send media change event
+ *      @atadev: Pointer to the disk device with media change event
+ *
+ *      Tell the block layer to send a media change notification
+ *      event.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+void ata_scsi_media_change_notify(struct ata_device *dev)
+{
+#ifdef OTHER_AN_PATCHES_HAVE_BEEN_APPLIED
+        if (dev->sdev)
+                scsi_device_event_notify(dev->sdev, SDEV_MEDIA_CHANGE);
+#endif
+}
+
 /**
  *      ata_scsi_hotplug - SCSI part of hotplug
  *      @work: Pointer to ATA port to perform SCSI hotplug on
@@ -3121,20 +3280,14 @@ void ata_scsi_hotplug(struct work_struct *work)
 
         DPRINTK("ENTER\n");
 
-        /* unplug detached devices */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
-                unsigned long flags;
-
-                if (!(dev->flags & ATA_DFLAG_DETACHED))
-                        continue;
-
-                spin_lock_irqsave(ap->lock, flags);
-                dev->flags &= ~ATA_DFLAG_DETACHED;
-                spin_unlock_irqrestore(ap->lock, flags);
-
-                ata_scsi_remove_dev(dev);
-        }
+        /* Unplug detached devices.  We cannot use link iterator here
+         * because PMP links have to be scanned even if PMP is
+         * currently not attached.  Iterate manually.
+         */
+        ata_scsi_handle_link_detach(&ap->link);
+        if (ap->pmp_link)
+                for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
+                        ata_scsi_handle_link_detach(&ap->pmp_link[i]);
 
         /* scan for new ones */
         ata_scsi_scan_host(ap, 0);
@@ -3163,27 +3316,42 @@ static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
 {
         struct ata_port *ap = ata_shost_to_port(shost);
         unsigned long flags;
-        int rc = 0;
+        int devno, rc = 0;
 
         if (!ap->ops->error_handler)
                 return -EOPNOTSUPP;
 
-        if ((channel != SCAN_WILD_CARD && channel != 0) ||
-            (lun != SCAN_WILD_CARD && lun != 0))
+        if (lun != SCAN_WILD_CARD && lun)
                 return -EINVAL;
 
+        if (ap->nr_pmp_links == 0) {
+                if (channel != SCAN_WILD_CARD && channel)
+                        return -EINVAL;
+                devno = id;
+        } else {
+                if (id != SCAN_WILD_CARD && id)
+                        return -EINVAL;
+                devno = channel;
+        }
+
         spin_lock_irqsave(ap->lock, flags);
 
-        if (id == SCAN_WILD_CARD) {
-                ap->eh_info.probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
-                ap->eh_info.action |= ATA_EH_SOFTRESET;
+        if (devno == SCAN_WILD_CARD) {
+                struct ata_link *link;
+
+                ata_port_for_each_link(link, ap) {
+                        struct ata_eh_info *ehi = &link->eh_info;
+                        ehi->probe_mask |= (1 << ata_link_max_devices(link)) - 1;
+                        ehi->action |= ATA_EH_SOFTRESET;
+                }
         } else {
-                struct ata_device *dev = ata_find_dev(ap, id);
+                struct ata_device *dev = ata_find_dev(ap, devno);
 
                 if (dev) {
-                        ap->eh_info.probe_mask |= 1 << dev->devno;
-                        ap->eh_info.action |= ATA_EH_SOFTRESET;
-                        ap->eh_info.flags |= ATA_EHI_RESUME_LINK;
+                        struct ata_eh_info *ehi = &dev->link->eh_info;
+                        ehi->probe_mask |= 1 << dev->devno;
+                        ehi->action |= ATA_EH_SOFTRESET;
+                        ehi->flags |= ATA_EHI_RESUME_LINK;
                 } else
                         rc = -EINVAL;
         }
@@ -3214,24 +3382,26 @@ void ata_scsi_dev_rescan(struct work_struct *work)
 {
         struct ata_port *ap =
                 container_of(work, struct ata_port, scsi_rescan_task);
+        struct ata_link *link;
+        struct ata_device *dev;
         unsigned long flags;
-        unsigned int i;
 
         spin_lock_irqsave(ap->lock, flags);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
-                struct scsi_device *sdev = dev->sdev;
+        ata_port_for_each_link(link, ap) {
+                ata_link_for_each_dev(dev, link) {
+                        struct scsi_device *sdev = dev->sdev;
 
-                if (!ata_dev_enabled(dev) || !sdev)
-                        continue;
-                if (scsi_device_get(sdev))
-                        continue;
+                        if (!ata_dev_enabled(dev) || !sdev)
+                                continue;
+                        if (scsi_device_get(sdev))
+                                continue;
 
-                spin_unlock_irqrestore(ap->lock, flags);
-                scsi_rescan_device(&(sdev->sdev_gendev));
-                scsi_device_put(sdev);
-                spin_lock_irqsave(ap->lock, flags);
+                        spin_unlock_irqrestore(ap->lock, flags);
+                        scsi_rescan_device(&(sdev->sdev_gendev));
+                        scsi_device_put(sdev);
+                        spin_lock_irqsave(ap->lock, flags);
+                }
         }
 
         spin_unlock_irqrestore(ap->lock, flags);
@@ -3359,7 +3529,7 @@ EXPORT_SYMBOL_GPL(ata_sas_port_destroy);
 int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
 {
         ata_scsi_sdev_config(sdev);
-        ata_scsi_dev_config(sdev, ap->device);
+        ata_scsi_dev_config(sdev, ap->link.device);
         return 0;
 }
 EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
@@ -3382,8 +3552,8 @@ int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
 
         ata_scsi_dump_cdb(ap, cmd);
 
-        if (likely(ata_scsi_dev_enabled(ap->device)))
-                rc = __ata_scsi_queuecmd(cmd, done, ap->device);
+        if (likely(ata_scsi_dev_enabled(ap->link.device)))
+                rc = __ata_scsi_queuecmd(cmd, done, ap->link.device);
         else {
                 cmd->result = (DID_BAD_TARGET << 16);
                 done(cmd);
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 8023167bbbeb..026439e05afe 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -64,46 +64,6 @@ u8 ata_irq_on(struct ata_port *ap)
         return tmp;
 }
 
-u8 ata_dummy_irq_on (struct ata_port *ap)       { return 0; }
-
-/**
- *      ata_irq_ack - Acknowledge a device interrupt.
- *      @ap: Port on which interrupts are enabled.
- *
- *      Wait up to 10 ms for legacy IDE device to become idle (BUSY
- *      or BUSY+DRQ clear).  Obtain dma status and port status from
- *      device.  Clear the interrupt.  Return port status.
- *
- *      LOCKING:
- */
-
-u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
-{
-        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
-        u8 host_stat = 0, post_stat = 0, status;
-
-        status = ata_busy_wait(ap, bits, 1000);
-        if (status & bits)
-                if (ata_msg_err(ap))
-                        printk(KERN_ERR "abnormal status 0x%X\n", status);
-
-        if (ap->ioaddr.bmdma_addr) {
-                /* get controller status; clear intr, err bits */
-                host_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
-                iowrite8(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
-                         ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
-
-                post_stat = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
-        }
-        if (ata_msg_intr(ap))
-                printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
-                        __FUNCTION__,
-                        host_stat, post_stat, status);
-        return status;
-}
-
-u8 ata_dummy_irq_ack(struct ata_port *ap, unsigned int chk_drq) { return 0; }
-
 /**
  *      ata_tf_load - send taskfile registers to host controller
  *      @ap: Port to which output is sent
@@ -445,7 +405,7 @@ void ata_bmdma_drive_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
         unsigned long flags;
         int thaw = 0;
 
-        qc = __ata_qc_from_tag(ap, ap->active_tag);
+        qc = __ata_qc_from_tag(ap, ap->link.active_tag);
         if (qc && !(qc->flags & ATA_QCFLAG_FAILED))
                 qc = NULL;
 
@@ -500,7 +460,7 @@ void ata_bmdma_error_handler(struct ata_port *ap)
         ata_reset_fn_t hardreset;
 
         hardreset = NULL;
-        if (sata_scr_valid(ap))
+        if (sata_scr_valid(&ap->link))
                 hardreset = sata_std_hardreset;
 
         ata_bmdma_drive_eh(ap, ata_std_prereset, ata_std_softreset, hardreset,
@@ -607,6 +567,9 @@ int ata_pci_init_bmdma(struct ata_host *host)
                 if ((!(ap->flags & ATA_FLAG_IGN_SIMPLEX)) &&
                     (ioread8(bmdma + 2) & 0x80))
                         host->flags |= ATA_HOST_SIMPLEX;
+
+                ata_port_desc(ap, "bmdma 0x%llx",
+                        (unsigned long long)pci_resource_start(pdev, 4) + 8 * i);
         }
 
         return 0;
@@ -674,6 +637,10 @@ int ata_pci_init_sff_host(struct ata_host *host)
                         ((unsigned long)iomap[base + 1] | ATA_PCI_CTL_OFS);
                 ata_std_ports(&ap->ioaddr);
 
+                ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
+                        (unsigned long long)pci_resource_start(pdev, base),
+                        (unsigned long long)pci_resource_start(pdev, base + 1));
+
                 mask |= 1 << i;
         }
 
@@ -844,24 +811,30 @@ int ata_pci_init_one(struct pci_dev *pdev,
                                       IRQF_SHARED, DRV_NAME, host);
                 if (rc)
                         goto err_out;
-                host->irq = pdev->irq;
+
+                ata_port_desc(host->ports[0], "irq %d", pdev->irq);
+                ata_port_desc(host->ports[1], "irq %d", pdev->irq);
         } else {
                 if (!ata_port_is_dummy(host->ports[0])) {
-                        host->irq = ATA_PRIMARY_IRQ(pdev);
-                        rc = devm_request_irq(dev, host->irq,
+                        rc = devm_request_irq(dev, ATA_PRIMARY_IRQ(pdev),
                                               pi->port_ops->irq_handler,
                                               IRQF_SHARED, DRV_NAME, host);
                         if (rc)
                                 goto err_out;
+
+                        ata_port_desc(host->ports[0], "irq %d",
+                                      ATA_PRIMARY_IRQ(pdev));
                 }
 
                 if (!ata_port_is_dummy(host->ports[1])) {
-                        host->irq2 = ATA_SECONDARY_IRQ(pdev);
-                        rc = devm_request_irq(dev, host->irq2,
+                        rc = devm_request_irq(dev, ATA_SECONDARY_IRQ(pdev),
                                               pi->port_ops->irq_handler,
                                               IRQF_SHARED, DRV_NAME, host);
                         if (rc)
                                 goto err_out;
+
+                        ata_port_desc(host->ports[1], "irq %d",
+                                      ATA_SECONDARY_IRQ(pdev));
                 }
         }
 
@@ -909,7 +882,7 @@ unsigned long ata_pci_default_filter(struct ata_device *adev, unsigned long xfer
         /* Filter out DMA modes if the device has been configured by
            the BIOS as PIO only */
 
-        if (adev->ap->ioaddr.bmdma_addr == 0)
+        if (adev->link->ap->ioaddr.bmdma_addr == 0)
                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
         return xfer_mask;
 }
diff --git a/drivers/ata/libata.h b/drivers/ata/libata.h
index 564cd234c805..90df58a3edc9 100644
--- a/drivers/ata/libata.h
+++ b/drivers/ata/libata.h
@@ -29,6 +29,7 @@
 #define __LIBATA_H__
 
 #define DRV_NAME        "libata"
+#define DRV_VERSION     "3.00"  /* must be exactly four chars */
 
 struct ata_scsi_args {
         struct ata_device       *dev;
@@ -56,6 +57,7 @@ extern unsigned int ata_print_id;
 extern struct workqueue_struct *ata_aux_wq;
 extern int atapi_enabled;
 extern int atapi_dmadir;
+extern int atapi_passthru16;
 extern int libata_fua;
 extern int libata_noacpi;
 extern struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev);
@@ -67,21 +69,23 @@ extern void ata_dev_disable(struct ata_device *dev);
 extern void ata_port_flush_task(struct ata_port *ap);
 extern unsigned ata_exec_internal(struct ata_device *dev,
                                   struct ata_taskfile *tf, const u8 *cdb,
-                                  int dma_dir, void *buf, unsigned int buflen);
+                                  int dma_dir, void *buf, unsigned int buflen,
+                                  unsigned long timeout);
 extern unsigned ata_exec_internal_sg(struct ata_device *dev,
                                      struct ata_taskfile *tf, const u8 *cdb,
                                      int dma_dir, struct scatterlist *sg,
-                                     unsigned int n_elem);
+                                     unsigned int n_elem, unsigned long timeout);
 extern unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd);
 extern int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
                            unsigned int flags, u16 *id);
 extern int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags);
-extern int ata_dev_revalidate(struct ata_device *dev, unsigned int readid_flags);
+extern int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
+                              unsigned int readid_flags);
 extern int ata_dev_configure(struct ata_device *dev);
-extern int sata_down_spd_limit(struct ata_port *ap);
-extern int sata_set_spd_needed(struct ata_port *ap);
+extern int sata_down_spd_limit(struct ata_link *link);
+extern int sata_set_spd_needed(struct ata_link *link);
 extern int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel);
-extern int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev);
+extern int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
 extern void ata_sg_clean(struct ata_queued_cmd *qc);
 extern void ata_qc_free(struct ata_queued_cmd *qc);
 extern void ata_qc_issue(struct ata_queued_cmd *qc);
@@ -92,17 +96,21 @@ extern void ata_dev_select(struct ata_port *ap, unsigned int device,
 extern void swap_buf_le16(u16 *buf, unsigned int buf_words);
 extern int ata_flush_cache(struct ata_device *dev);
 extern void ata_dev_init(struct ata_device *dev);
+extern void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp);
+extern int sata_link_init_spd(struct ata_link *link);
 extern int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg);
 extern int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg);
 extern struct ata_port *ata_port_alloc(struct ata_host *host);
 
 /* libata-acpi.c */
 #ifdef CONFIG_ATA_ACPI
+extern void ata_acpi_associate_sata_port(struct ata_port *ap);
 extern void ata_acpi_associate(struct ata_host *host);
 extern int ata_acpi_on_suspend(struct ata_port *ap);
 extern void ata_acpi_on_resume(struct ata_port *ap);
 extern int ata_acpi_on_devcfg(struct ata_device *adev);
 #else
+static inline void ata_acpi_associate_sata_port(struct ata_port *ap) { }
 static inline void ata_acpi_associate(struct ata_host *host) { }
 static inline int ata_acpi_on_suspend(struct ata_port *ap) { return 0; }
 static inline void ata_acpi_on_resume(struct ata_port *ap) { }
@@ -114,6 +122,7 @@ extern int ata_scsi_add_hosts(struct ata_host *host,
                               struct scsi_host_template *sht);
 extern void ata_scsi_scan_host(struct ata_port *ap, int sync);
 extern int ata_scsi_offline_dev(struct ata_device *dev);
+extern void ata_scsi_media_change_notify(struct ata_device *dev);
 extern void ata_scsi_hotplug(struct work_struct *work);
 extern unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
                                unsigned int buflen);
@@ -147,12 +156,32 @@ extern void ata_schedule_scsi_eh(struct Scsi_Host *shost);
 extern void ata_scsi_dev_rescan(struct work_struct *work);
 extern int ata_bus_probe(struct ata_port *ap);
 
+/* libata-pmp.c */
+extern int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *val);
+extern int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val);
+extern int sata_pmp_attach(struct ata_device *dev);
+
 /* libata-eh.c */
 extern enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd);
 extern void ata_scsi_error(struct Scsi_Host *host);
 extern void ata_port_wait_eh(struct ata_port *ap);
 extern void ata_eh_fastdrain_timerfn(unsigned long arg);
 extern void ata_qc_schedule_eh(struct ata_queued_cmd *qc);
+extern void ata_eh_detach_dev(struct ata_device *dev);
+extern void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
+                               unsigned int action);
+extern void ata_eh_done(struct ata_link *link, struct ata_device *dev,
+                        unsigned int action);
+extern void ata_eh_autopsy(struct ata_port *ap);
+extern void ata_eh_report(struct ata_port *ap);
+extern int ata_eh_reset(struct ata_link *link, int classify,
+                        ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
+                        ata_reset_fn_t hardreset, ata_postreset_fn_t postreset);
+extern int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
+                          ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
+                          ata_postreset_fn_t postreset,
+                          struct ata_link **r_failed_disk);
+extern void ata_eh_finish(struct ata_port *ap);
 
 /* libata-sff.c */
 extern u8 ata_irq_on(struct ata_port *ap);
diff --git a/drivers/ata/pata_acpi.c b/drivers/ata/pata_acpi.c
new file mode 100644
index 000000000000..5d3920f6fd69
--- /dev/null
+++ b/drivers/ata/pata_acpi.c
@@ -0,0 +1,395 @@
+/*
+ *      ACPI PATA driver
+ *
+ *      (c) 2007 Red Hat  <alan@redhat.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <scsi/scsi_host.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acnames.h>
+#include <acpi/acnamesp.h>
+#include <acpi/acparser.h>
+#include <acpi/acexcep.h>
+#include <acpi/acmacros.h>
+#include <acpi/actypes.h>
+
+#include <linux/libata.h>
+#include <linux/ata.h>
+
+#define DRV_NAME        "pata_acpi"
+#define DRV_VERSION     "0.2.3"
+
+struct pata_acpi {
+        struct ata_acpi_gtm gtm;
+        void *last;
+        unsigned long mask[2];
+};
+
+/**
+ *      pacpi_pre_reset -       check for 40/80 pin
+ *      @ap: Port
+ *      @deadline: deadline jiffies for the operation
+ *
+ *      Perform the PATA port setup we need.
+ */
+
+static int pacpi_pre_reset(struct ata_link *link, unsigned long deadline)
+{
+        struct ata_port *ap = link->ap;
+        struct pata_acpi *acpi = ap->private_data;
+        if (ap->acpi_handle == NULL || ata_acpi_gtm(ap, &acpi->gtm) < 0)
+                return -ENODEV;
+
+        return ata_std_prereset(link, deadline);
+}
+
+/**
+ *      pacpi_cable_detect      -       cable type detection
+ *      @ap: port to detect
+ *
+ *      Perform device specific cable detection
+ */
+
+static int pacpi_cable_detect(struct ata_port *ap)
+{
+        struct pata_acpi *acpi = ap->private_data;
+
+        if ((acpi->mask[0] | acpi->mask[1]) & (0xF8 << ATA_SHIFT_UDMA))
+                return ATA_CBL_PATA80;
+        else
+                return ATA_CBL_PATA40;
+}
+
+/**
+ *      pacpi_error_handler - Setup and error handler
+ *      @ap: Port to handle
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void pacpi_error_handler(struct ata_port *ap)
+{
+        return ata_bmdma_drive_eh(ap, pacpi_pre_reset, ata_std_softreset,
+                                  NULL, ata_std_postreset);
+}
+
+/* Welcome to ACPI, bring a bucket */
+static const unsigned int pio_cycle[7] = {
+        600, 383, 240, 180, 120, 100, 80
+};
+static const unsigned int mwdma_cycle[5] = {
+        480, 150, 120, 100, 80
+};
+static const unsigned int udma_cycle[7] = {
+        120, 80, 60, 45, 30, 20, 15
+};
+
+/**
+ *      pacpi_discover_modes    -       filter non ACPI modes
+ *      @adev: ATA device
+ *      @mask: proposed modes
+ *
+ *      Try the modes available and see which ones the ACPI method will
+ *      set up sensibly. From this we get a mask of ACPI modes we can use
+ */
+
+static unsigned long pacpi_discover_modes(struct ata_port *ap, struct ata_device *adev)
+{
+        int unit = adev->devno;
+        struct pata_acpi *acpi = ap->private_data;
+        int i;
+        u32 t;
+        unsigned long mask = (0x7f << ATA_SHIFT_UDMA) | (0x7 << ATA_SHIFT_MWDMA) | (0x1F << ATA_SHIFT_PIO);
+
+        struct ata_acpi_gtm probe;
+
+        probe = acpi->gtm;
+
+        /* We always use the 0 slot for crap hardware */
+        if (!(probe.flags & 0x10))
+                unit = 0;
+
+        ata_acpi_gtm(ap, &probe);
+
+        /* Start by scanning for PIO modes */
+        for (i = 0; i < 7; i++) {
+                t = probe.drive[unit].pio;
+                if (t <= pio_cycle[i]) {
+                        mask |= (2 << (ATA_SHIFT_PIO + i)) - 1;
+                        break;
+                }
+        }
+
+        /* See if we have MWDMA or UDMA data. We don't bother with MWDMA
+           if UDMA is availabe as this means the BIOS set UDMA and our
+           error changedown if it works is UDMA to PIO anyway */
+        if (probe.flags & (1 << (2 * unit))) {
+                /* MWDMA */
+                for (i = 0; i < 5; i++) {
+                        t = probe.drive[unit].dma;
+                        if (t <= mwdma_cycle[i]) {
+                                mask |= (2 << (ATA_SHIFT_MWDMA + i)) - 1;
+                                break;
+                        }
+                }
+        } else {
+                /* UDMA */
+                for (i = 0; i < 7; i++) {
+                        t = probe.drive[unit].dma;
+                        if (t <= udma_cycle[i]) {
+                                mask |= (2 << (ATA_SHIFT_UDMA + i)) - 1;
+                                break;
+                        }
+                }
+        }
+        if (mask & (0xF8 << ATA_SHIFT_UDMA))
+                ap->cbl = ATA_CBL_PATA80;
+        return mask;
+}
+
+/**
+ *      pacpi_mode_filter       -       mode filter for ACPI
+ *      @adev: device
+ *      @mask: mask of valid modes
+ *
+ *      Filter the valid mode list according to our own specific rules, in
+ *      this case the list of discovered valid modes obtained by ACPI probing
+ */
+
+static unsigned long pacpi_mode_filter(struct ata_device *adev, unsigned long mask)
+{
+        struct pata_acpi *acpi = adev->link->ap->private_data;
+        return ata_pci_default_filter(adev, mask & acpi->mask[adev->devno]);
+}
+
+/**
+ *      pacpi_set_piomode       -       set initial PIO mode data
+ *      @ap: ATA interface
+ *      @adev: ATA device
+ */
+
+static void pacpi_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        int unit = adev->devno;
+        struct pata_acpi *acpi = ap->private_data;
+
+        if(!(acpi->gtm.flags & 0x10))
+                unit = 0;
+
+        /* Now stuff the nS values into the structure */
+        acpi->gtm.drive[unit].pio = pio_cycle[adev->pio_mode - XFER_PIO_0];
+        ata_acpi_stm(ap, &acpi->gtm);
+        /* See what mode we actually got */
+        ata_acpi_gtm(ap, &acpi->gtm);
+}
+
+/**
+ *      pacpi_set_dmamode       -       set initial DMA mode data
+ *      @ap: ATA interface
+ *      @adev: ATA device
+ */
+
+static void pacpi_set_dmamode(struct ata_port *ap, struct ata_device *adev)
+{
+        int unit = adev->devno;
+        struct pata_acpi *acpi = ap->private_data;
+
+        if(!(acpi->gtm.flags & 0x10))
+                unit = 0;
+
+        /* Now stuff the nS values into the structure */
+        if (adev->dma_mode >= XFER_UDMA_0) {
+                acpi->gtm.drive[unit].dma = udma_cycle[adev->dma_mode - XFER_UDMA_0];
+                acpi->gtm.flags |= (1 << (2 * unit));
+        } else {
+                acpi->gtm.drive[unit].dma = mwdma_cycle[adev->dma_mode - XFER_MW_DMA_0];
+                acpi->gtm.flags &= ~(1 << (2 * unit));
+        }
+        ata_acpi_stm(ap, &acpi->gtm);
+        /* See what mode we actually got */
+        ata_acpi_gtm(ap, &acpi->gtm);
+}
+
+/**
+ *      pacpi_qc_issue_prot     -       command issue
+ *      @qc: command pending
+ *
+ *      Called when the libata layer is about to issue a command. We wrap
+ *      this interface so that we can load the correct ATA timings if
+ *      neccessary.
+ */
+
+static unsigned int pacpi_qc_issue_prot(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct ata_device *adev = qc->dev;
+        struct pata_acpi *acpi = ap->private_data;
+
+        if (acpi->gtm.flags & 0x10)
+                return ata_qc_issue_prot(qc);
+
+        if (adev != acpi->last) {
+                pacpi_set_piomode(ap, adev);
+                if (adev->dma_mode)
+                        pacpi_set_dmamode(ap, adev);
+                acpi->last = adev;
+        }
+        return ata_qc_issue_prot(qc);
+}
+
+/**
+ *      pacpi_port_start        -       port setup
+ *      @ap: ATA port being set up
+ *
+ *      Use the port_start hook to maintain private control structures
+ */
+
+static int pacpi_port_start(struct ata_port *ap)
+{
+        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
+        struct pata_acpi *acpi;
+
+        int ret;
+
+        if (ap->acpi_handle == NULL)
+                return -ENODEV;
+
+        acpi = ap->private_data = devm_kzalloc(&pdev->dev, sizeof(struct pata_acpi), GFP_KERNEL);
+        if (ap->private_data == NULL)
+                return -ENOMEM;
+        acpi->mask[0] = pacpi_discover_modes(ap, &ap->link.device[0]);
+        acpi->mask[1] = pacpi_discover_modes(ap, &ap->link.device[1]);
+        ret = ata_sff_port_start(ap);
+        if (ret < 0)
+                return ret;
+
+        return ret;
+}
+
+static struct scsi_host_template pacpi_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = LIBATA_MAX_PRD,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = ATA_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .slave_destroy          = ata_scsi_slave_destroy,
+        /* Use standard CHS mapping rules */
+        .bios_param             = ata_std_bios_param,
+};
+
+static const struct ata_port_operations pacpi_ops = {
+        .set_piomode            = pacpi_set_piomode,
+        .set_dmamode            = pacpi_set_dmamode,
+        .mode_filter            = pacpi_mode_filter,
+
+        /* Task file is PCI ATA format, use helpers */
+        .tf_load                = ata_tf_load,
+        .tf_read                = ata_tf_read,
+        .check_status           = ata_check_status,
+        .exec_command           = ata_exec_command,
+        .dev_select             = ata_std_dev_select,
+
+        .freeze                 = ata_bmdma_freeze,
+        .thaw                   = ata_bmdma_thaw,
+        .error_handler          = pacpi_error_handler,
+        .post_internal_cmd      = ata_bmdma_post_internal_cmd,
+        .cable_detect           = pacpi_cable_detect,
+
+        /* BMDMA handling is PCI ATA format, use helpers */
+        .bmdma_setup            = ata_bmdma_setup,
+        .bmdma_start            = ata_bmdma_start,
+        .bmdma_stop             = ata_bmdma_stop,
+        .bmdma_status           = ata_bmdma_status,
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = pacpi_qc_issue_prot,
+        .data_xfer              = ata_data_xfer,
+
+        /* Timeout handling */
+        .irq_handler            = ata_interrupt,
+        .irq_clear              = ata_bmdma_irq_clear,
+        .irq_on                 = ata_irq_on,
+
+        /* Generic PATA PCI ATA helpers */
+        .port_start             = pacpi_port_start,
+};
+
+
+/**
+ *      pacpi_init_one - Register ACPI ATA PCI device with kernel services
+ *      @pdev: PCI device to register
+ *      @ent: Entry in pacpi_pci_tbl matching with @pdev
+ *
+ *      Called from kernel PCI layer.
+ *
+ *      LOCKING:
+ *      Inherited from PCI layer (may sleep).
+ *
+ *      RETURNS:
+ *      Zero on success, or -ERRNO value.
+ */
+
+static int pacpi_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        static const struct ata_port_info info = {
+                .sht            = &pacpi_sht,
+                .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
+
+                .pio_mask       = 0x1f,
+                .mwdma_mask     = 0x07,
+                .udma_mask      = 0x7f,
+
+                .port_ops       = &pacpi_ops,
+        };
+        const struct ata_port_info *ppi[] = { &info, NULL };
+        return ata_pci_init_one(pdev, ppi);
+}
+
+static const struct pci_device_id pacpi_pci_tbl[] = {
+        { PCI_ANY_ID,           PCI_ANY_ID,                        PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xFFFFFF00UL, 1},
+        { }     /* terminate list */
+};
+
+static struct pci_driver pacpi_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = pacpi_pci_tbl,
+        .probe                  = pacpi_init_one,
+        .remove                 = ata_pci_remove_one,
+        .suspend                = ata_pci_device_suspend,
+        .resume                 = ata_pci_device_resume,
+};
+
+static int __init pacpi_init(void)
+{
+        return pci_register_driver(&pacpi_pci_driver);
+}
+
+static void __exit pacpi_exit(void)
+{
+        pci_unregister_driver(&pacpi_pci_driver);
+}
+
+module_init(pacpi_init);
+module_exit(pacpi_exit);
+
+MODULE_AUTHOR("Alan Cox");
+MODULE_DESCRIPTION("SCSI low-level driver for ATA in ACPI mode");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, pacpi_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
+
diff --git a/drivers/ata/pata_ali.c b/drivers/ata/pata_ali.c
index 32a10c99c06f..364534e7aff4 100644
--- a/drivers/ata/pata_ali.c
+++ b/drivers/ata/pata_ali.c
@@ -305,7 +305,6 @@ static struct scsi_host_template ali_sht = {
  */
 
 static struct ata_port_operations ali_early_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = ali_set_piomode,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
@@ -327,9 +326,8 @@ static struct ata_port_operations ali_early_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
@@ -337,8 +335,6 @@ static struct ata_port_operations ali_early_port_ops = {
  *      detect
  */
 static struct ata_port_operations ali_20_port_ops = {
-        .port_disable   = ata_port_disable,
-
         .set_piomode    = ali_set_piomode,
         .set_dmamode    = ali_set_dmamode,
         .mode_filter    = ali_20_filter,
@@ -369,16 +365,14 @@ static struct ata_port_operations ali_20_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
  *      Port operations for DMA capable ALi with cable detect
  */
 static struct ata_port_operations ali_c2_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = ali_set_piomode,
         .set_dmamode    = ali_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -408,16 +402,14 @@ static struct ata_port_operations ali_c2_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
  *      Port operations for DMA capable ALi with cable detect and LBA48
  */
 static struct ata_port_operations ali_c5_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = ali_set_piomode,
         .set_dmamode    = ali_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -446,9 +438,8 @@ static struct ata_port_operations ali_c5_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_amd.c b/drivers/ata/pata_amd.c
index 04048fcf6305..c5779ad4abca 100644
--- a/drivers/ata/pata_amd.c
+++ b/drivers/ata/pata_amd.c
@@ -119,27 +119,28 @@ static void timing_setup(struct ata_port *ap, struct ata_device *adev, int offse
 }
 
 /**
- *      amd_probe_init          -       perform reset handling
- *      @ap: ATA port
+ *      amd_pre_reset           -       perform reset handling
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Reset sequence checking enable bits to see which ports are
  *      active.
  */
 
-static int amd_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int amd_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits amd_enable_bits[] = {
                 { 0x40, 1, 0x02, 0x02 },
                 { 0x40, 1, 0x01, 0x01 }
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &amd_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static void amd_error_handler(struct ata_port *ap)
@@ -221,25 +222,26 @@ static void amd133_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 
 /**
  *      nv_probe_init   -       cable detection
- *      @ap: ATA port
+ *      @lin: ATA link
  *
  *      Perform cable detection. The BIOS stores this in PCI config
  *      space for us.
  */
 
-static int nv_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int nv_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits nv_enable_bits[] = {
                 { 0x50, 1, 0x02, 0x02 },
                 { 0x50, 1, 0x01, 0x01 }
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &nv_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static void nv_error_handler(struct ata_port *ap)
@@ -268,6 +270,9 @@ static int nv_cable_detect(struct ata_port *ap)
         pci_read_config_word(pdev, 0x62 - 2 * ap->port_no, &udma);
         if ((udma & 0xC4) == 0xC4 || (udma & 0xC400) == 0xC400)
                 cbl = ATA_CBL_PATA80;
+        /* And a triple check across suspend/resume with ACPI around */
+        if (ata_acpi_cbl_80wire(ap))
+                cbl = ATA_CBL_PATA80;
         return cbl;
 }
 
@@ -327,7 +332,6 @@ static struct scsi_host_template amd_sht = {
 };
 
 static struct ata_port_operations amd33_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = amd33_set_piomode,
         .set_dmamode    = amd33_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -356,13 +360,11 @@ static struct ata_port_operations amd33_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations amd66_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = amd66_set_piomode,
         .set_dmamode    = amd66_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -391,13 +393,11 @@ static struct ata_port_operations amd66_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations amd100_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = amd100_set_piomode,
         .set_dmamode    = amd100_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -426,13 +426,11 @@ static struct ata_port_operations amd100_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations amd133_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = amd133_set_piomode,
         .set_dmamode    = amd133_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -461,13 +459,11 @@ static struct ata_port_operations amd133_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations nv100_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = nv100_set_piomode,
         .set_dmamode    = nv100_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -496,13 +492,11 @@ static struct ata_port_operations nv100_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations nv133_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = nv133_set_piomode,
         .set_dmamode    = nv133_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -531,9 +525,8 @@ static struct ata_port_operations nv133_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int amd_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_artop.c b/drivers/ata/pata_artop.c
index b5352ebecef9..d4218310327b 100644
--- a/drivers/ata/pata_artop.c
+++ b/drivers/ata/pata_artop.c
@@ -40,8 +40,9 @@
 
 static int clock = 0;
 
-static int artop6210_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int artop6210_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         const struct pci_bits artop_enable_bits[] = {
                 { 0x4AU, 1U, 0x02UL, 0x02UL },  /* port 0 */
@@ -51,7 +52,7 @@ static int artop6210_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &artop_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -71,27 +72,28 @@ static void artop6210_error_handler(struct ata_port *ap)
 
 /**
  *      artop6260_pre_reset     -       check for 40/80 pin
- *      @ap: Port
+ *      @link: link
  *      @deadline: deadline jiffies for the operation
  *
  *      The ARTOP hardware reports the cable detect bits in register 0x49.
  *      Nothing complicated needed here.
  */
 
-static int artop6260_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int artop6260_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits artop_enable_bits[] = {
                 { 0x4AU, 1U, 0x02UL, 0x02UL },  /* port 0 */
                 { 0x4AU, 1U, 0x04UL, 0x04UL },  /* port 1 */
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         /* Odd numbered device ids are the units with enable bits (the -R cards) */
         if (pdev->device % 1 && !pci_test_config_bits(pdev, &artop_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -330,7 +332,6 @@ static struct scsi_host_template artop_sht = {
 };
 
 static const struct ata_port_operations artop6210_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = artop6210_set_piomode,
         .set_dmamode            = artop6210_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -359,13 +360,11 @@ static const struct ata_port_operations artop6210_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations artop6260_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = artop6260_set_piomode,
         .set_dmamode            = artop6260_set_dmamode,
 
@@ -392,9 +391,8 @@ static const struct ata_port_operations artop6260_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_at32.c b/drivers/ata/pata_at32.c
new file mode 100644
index 000000000000..bb250a48e27c
--- /dev/null
+++ b/drivers/ata/pata_at32.c
@@ -0,0 +1,441 @@
+/*
+ * AVR32 SMC/CFC PATA Driver
+ *
+ * Copyright (C) 2007 Atmel Norway
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ */
+
+#define DEBUG
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <scsi/scsi_host.h>
+#include <linux/ata.h>
+#include <linux/libata.h>
+#include <linux/err.h>
+#include <linux/io.h>
+
+#include <asm/arch/board.h>
+#include <asm/arch/smc.h>
+
+#define DRV_NAME "pata_at32"
+#define DRV_VERSION "0.0.2"
+
+/*
+ * CompactFlash controller memory layout relative to the base address:
+ *
+ *      Attribute memory:  0000 0000 -> 003f ffff
+ *      Common memory:     0040 0000 -> 007f ffff
+ *      I/O memory:        0080 0000 -> 00bf ffff
+ *      True IDE Mode:     00c0 0000 -> 00df ffff
+ *      Alt IDE Mode:      00e0 0000 -> 00ff ffff
+ *
+ * Only True IDE and Alt True IDE mode are needed for this driver.
+ *
+ *      True IDE mode     => CS0 = 0, CS1 = 1 (cmd, error, stat, etc)
+ *      Alt True IDE mode => CS0 = 1, CS1 = 0 (ctl, alt_stat)
+ */
+#define CF_IDE_OFFSET     0x00c00000
+#define CF_ALT_IDE_OFFSET 0x00e00000
+#define CF_RES_SIZE       2048
+
+/*
+ * Define DEBUG_BUS if you are doing debugging of your own EBI -> PATA
+ * adaptor with a logic analyzer or similar.
+ */
+#undef DEBUG_BUS
+
+/*
+ * ATA PIO modes
+ *
+ *      Name    | Mb/s  | Min cycle time | Mask
+ *      --------+-------+----------------+--------
+ *      Mode 0  | 3.3   | 600 ns         | 0x01
+ *      Mode 1  | 5.2   | 383 ns         | 0x03
+ *      Mode 2  | 8.3   | 240 ns         | 0x07
+ *      Mode 3  | 11.1  | 180 ns         | 0x0f
+ *      Mode 4  | 16.7  | 120 ns         | 0x1f
+ */
+#define PIO_MASK (0x1f)
+
+/*
+ * Struct containing private information about device.
+ */
+struct at32_ide_info {
+        unsigned int            irq;
+        struct resource         res_ide;
+        struct resource         res_alt;
+        void __iomem            *ide_addr;
+        void __iomem            *alt_addr;
+        unsigned int            cs;
+        struct smc_config       smc;
+};
+
+/*
+ * Setup SMC for the given ATA timing.
+ */
+static int pata_at32_setup_timing(struct device *dev,
+                                  struct at32_ide_info *info,
+                                  const struct ata_timing *timing)
+{
+        /* These two values are found through testing */
+        const int min_recover = 25;
+        const int ncs_hold    = 15;
+
+        struct smc_config *smc = &info->smc;
+
+        int active;
+        int recover;
+
+        /* Total cycle time */
+        smc->read_cycle = timing->cyc8b;
+
+        /* DIOR <= CFIOR timings */
+        smc->nrd_setup = timing->setup;
+        smc->nrd_pulse = timing->act8b;
+
+        /* Compute recover, extend total cycle if needed */
+        active  = smc->nrd_setup + smc->nrd_pulse;
+        recover = smc->read_cycle - active;
+
+        if (recover < min_recover) {
+                smc->read_cycle = active + min_recover;
+                recover = min_recover;
+        }
+
+        /* (CS0, CS1, DIR, OE) <= (CFCE1, CFCE2, CFRNW, NCSX) timings */
+        smc->ncs_read_setup  = 0;
+        smc->ncs_read_pulse  = active + ncs_hold;
+
+        /* Write timings same as read timings */
+        smc->write_cycle = smc->read_cycle;
+        smc->nwe_setup = smc->nrd_setup;
+        smc->nwe_pulse = smc->nrd_pulse;
+        smc->ncs_write_setup = smc->ncs_read_setup;
+        smc->ncs_write_pulse = smc->ncs_read_pulse;
+
+        /* Do some debugging output */
+        dev_dbg(dev, "SMC: C=%d S=%d P=%d R=%d NCSS=%d NCSP=%d NCSR=%d\n",
+                smc->read_cycle, smc->nrd_setup, smc->nrd_pulse,
+                recover, smc->ncs_read_setup, smc->ncs_read_pulse,
+                smc->read_cycle - smc->ncs_read_pulse);
+
+        /* Finally, configure the SMC */
+        return smc_set_configuration(info->cs, smc);
+}
+
+/*
+ * Procedures for libATA.
+ */
+static void pata_at32_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        struct ata_timing timing;
+        struct at32_ide_info *info = ap->host->private_data;
+
+        int ret;
+
+        /* Compute ATA timing */
+        ret = ata_timing_compute(adev, adev->pio_mode, &timing, 1000, 0);
+        if (ret) {
+                dev_warn(ap->dev, "Failed to compute ATA timing %d\n", ret);
+                return;
+        }
+
+        /* Setup SMC to ATA timing */
+        ret = pata_at32_setup_timing(ap->dev, info, &timing);
+        if (ret) {
+                dev_warn(ap->dev, "Failed to setup ATA timing %d\n", ret);
+                return;
+        }
+}
+
+static void pata_at32_irq_clear(struct ata_port *ap)
+{
+        /* No DMA controller yet */
+}
+
+static struct scsi_host_template at32_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = LIBATA_MAX_PRD,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = ATA_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .slave_destroy          = ata_scsi_slave_destroy,
+        .bios_param             = ata_std_bios_param,
+};
+
+static struct ata_port_operations at32_port_ops = {
+        .port_disable           = ata_port_disable,
+        .set_piomode            = pata_at32_set_piomode,
+        .tf_load                = ata_tf_load,
+        .tf_read                = ata_tf_read,
+        .exec_command           = ata_exec_command,
+        .check_status           = ata_check_status,
+        .dev_select             = ata_std_dev_select,
+
+        .freeze                 = ata_bmdma_freeze,
+        .thaw                   = ata_bmdma_thaw,
+        .error_handler          = ata_bmdma_error_handler,
+        .post_internal_cmd      = ata_bmdma_post_internal_cmd,
+        .cable_detect           = ata_cable_40wire,
+
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+
+        .data_xfer              = ata_data_xfer,
+
+        .irq_clear              = pata_at32_irq_clear,
+        .irq_on                 = ata_irq_on,
+        .irq_ack                = ata_irq_ack,
+
+        .port_start             = ata_sff_port_start,
+};
+
+static int __init pata_at32_init_one(struct device *dev,
+                                     struct at32_ide_info *info)
+{
+        struct ata_host *host;
+        struct ata_port *ap;
+
+        host = ata_host_alloc(dev, 1);
+        if (!host)
+                return -ENOMEM;
+
+        ap = host->ports[0];
+
+        /* Setup ATA bindings */
+        ap->ops      = &at32_port_ops;
+        ap->pio_mask = PIO_MASK;
+        ap->flags    = ATA_FLAG_MMIO | ATA_FLAG_SLAVE_POSS
+                | ATA_FLAG_PIO_POLLING;
+
+        /*
+         * Since all 8-bit taskfile transfers has to go on the lower
+         * byte of the data bus and there is a bug in the SMC that
+         * makes it impossible to alter the bus width during runtime,
+         * we need to hardwire the address signals as follows:
+         *
+         *      A_IDE(2:0) <= A_EBI(3:1)
+         *
+         * This makes all addresses on the EBI even, thus all data
+         * will be on the lower byte of the data bus.  All addresses
+         * used by libATA need to be altered according to this.
+         */
+        ap->ioaddr.altstatus_addr = info->alt_addr + (0x06 << 1);
+        ap->ioaddr.ctl_addr       = info->alt_addr + (0x06 << 1);
+
+        ap->ioaddr.data_addr      = info->ide_addr + (ATA_REG_DATA << 1);
+        ap->ioaddr.error_addr     = info->ide_addr + (ATA_REG_ERR << 1);
+        ap->ioaddr.feature_addr   = info->ide_addr + (ATA_REG_FEATURE << 1);
+        ap->ioaddr.nsect_addr     = info->ide_addr + (ATA_REG_NSECT << 1);
+        ap->ioaddr.lbal_addr      = info->ide_addr + (ATA_REG_LBAL << 1);
+        ap->ioaddr.lbam_addr      = info->ide_addr + (ATA_REG_LBAM << 1);
+        ap->ioaddr.lbah_addr      = info->ide_addr + (ATA_REG_LBAH << 1);
+        ap->ioaddr.device_addr    = info->ide_addr + (ATA_REG_DEVICE << 1);
+        ap->ioaddr.status_addr    = info->ide_addr + (ATA_REG_STATUS << 1);
+        ap->ioaddr.command_addr   = info->ide_addr + (ATA_REG_CMD << 1);
+
+        /* Set info as private data of ATA host */
+        host->private_data = info;
+
+        /* Register ATA device and return */
+        return ata_host_activate(host, info->irq, ata_interrupt,
+                                 IRQF_SHARED | IRQF_TRIGGER_RISING,
+                                 &at32_sht);
+}
+
+/*
+ * This function may come in handy for people analyzing their own
+ * EBI -> PATA adaptors.
+ */
+#ifdef DEBUG_BUS
+
+static void __init pata_at32_debug_bus(struct device *dev,
+                                       struct at32_ide_info *info)
+{
+        const int d1 = 0xff;
+        const int d2 = 0x00;
+
+        int i;
+
+        /* Write 8-bit values (registers) */
+        iowrite8(d1, info->alt_addr + (0x06 << 1));
+        iowrite8(d2, info->alt_addr + (0x06 << 1));
+
+        for (i = 0; i < 8; i++) {
+                iowrite8(d1, info->ide_addr + (i << 1));
+                iowrite8(d2, info->ide_addr + (i << 1));
+        }
+
+        /* Write 16 bit values (data) */
+        iowrite16(d1,      info->ide_addr);
+        iowrite16(d1 << 8, info->ide_addr);
+
+        iowrite16(d1,      info->ide_addr);
+        iowrite16(d1 << 8, info->ide_addr);
+}
+
+#endif
+
+static int __init pata_at32_probe(struct platform_device *pdev)
+{
+        const struct ata_timing initial_timing =
+                {XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0};
+
+        struct device            *dev = &pdev->dev;
+        struct at32_ide_info     *info;
+        struct ide_platform_data *board = pdev->dev.platform_data;
+        struct resource          *res;
+
+        int irq;
+        int ret;
+
+        if (!board)
+                return -ENXIO;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENXIO;
+
+        /* Retrive IRQ */
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return irq;
+
+        /* Setup struct containing private infomation */
+        info = kzalloc(sizeof(struct at32_ide_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        memset(info, 0, sizeof(struct at32_ide_info));
+
+        info->irq = irq;
+        info->cs  = board->cs;
+
+        /* Request memory resources */
+        info->res_ide.start = res->start + CF_IDE_OFFSET;
+        info->res_ide.end   = info->res_ide.start + CF_RES_SIZE - 1;
+        info->res_ide.name  = "ide";
+        info->res_ide.flags = IORESOURCE_MEM;
+
+        ret = request_resource(res, &info->res_ide);
+        if (ret)
+                goto err_req_res_ide;
+
+        info->res_alt.start = res->start + CF_ALT_IDE_OFFSET;
+        info->res_alt.end   = info->res_alt.start + CF_RES_SIZE - 1;
+        info->res_alt.name  = "alt";
+        info->res_alt.flags = IORESOURCE_MEM;
+
+        ret = request_resource(res, &info->res_alt);
+        if (ret)
+                goto err_req_res_alt;
+
+        /* Setup non-timing elements of SMC */
+        info->smc.bus_width      = 2; /* 16 bit data bus */
+        info->smc.nrd_controlled = 1; /* Sample data on rising edge of NRD */
+        info->smc.nwe_controlled = 0; /* Drive data on falling edge of NCS */
+        info->smc.nwait_mode     = 3; /* NWAIT is in READY mode */
+        info->smc.byte_write     = 0; /* Byte select access type */
+        info->smc.tdf_mode       = 0; /* TDF optimization disabled */
+        info->smc.tdf_cycles     = 0; /* No TDF wait cycles */
+
+        /* Setup ATA timing */
+        ret = pata_at32_setup_timing(dev, info, &initial_timing);
+        if (ret)
+                goto err_setup_timing;
+
+        /* Setup ATA addresses */
+        ret = -ENOMEM;
+        info->ide_addr = devm_ioremap(dev, info->res_ide.start, 16);
+        info->alt_addr = devm_ioremap(dev, info->res_alt.start, 16);
+        if (!info->ide_addr || !info->alt_addr)
+                goto err_ioremap;
+
+#ifdef DEBUG_BUS
+        pata_at32_debug_bus(dev, info);
+#endif
+
+        /* Register ATA device */
+        ret = pata_at32_init_one(dev, info);
+        if (ret)
+                goto err_ata_device;
+
+        return 0;
+
+ err_ata_device:
+ err_ioremap:
+ err_setup_timing:
+        release_resource(&info->res_alt);
+ err_req_res_alt:
+        release_resource(&info->res_ide);
+ err_req_res_ide:
+        kfree(info);
+
+        return ret;
+}
+
+static int __exit pata_at32_remove(struct platform_device *pdev)
+{
+        struct ata_host *host = platform_get_drvdata(pdev);
+        struct at32_ide_info *info;
+
+        if (!host)
+                return 0;
+
+        info = host->private_data;
+        ata_host_detach(host);
+
+        if (!info)
+                return 0;
+
+        release_resource(&info->res_ide);
+        release_resource(&info->res_alt);
+
+        kfree(info);
+
+        return 0;
+}
+
+static struct platform_driver pata_at32_driver = {
+        .remove        = __exit_p(pata_at32_remove),
+        .driver        = {
+                .name  = "at32_ide",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init pata_at32_init(void)
+{
+        return platform_driver_probe(&pata_at32_driver, pata_at32_probe);
+}
+
+static void __exit pata_at32_exit(void)
+{
+        platform_driver_unregister(&pata_at32_driver);
+}
+
+module_init(pata_at32_init);
+module_exit(pata_at32_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("AVR32 SMC/CFC PATA Driver");
+MODULE_AUTHOR("Kristoffer Nyborg Gregertsen <kngregertsen@norway.atmel.com>");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
index 86f85a2cab7e..9623f5295530 100644
--- a/drivers/ata/pata_atiixp.c
+++ b/drivers/ata/pata_atiixp.c
@@ -33,8 +33,9 @@ enum {
         ATIIXP_IDE_UDMA_MODE    = 0x56
 };
 
-static int atiixp_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int atiixp_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         static const struct pci_bits atiixp_enable_bits[] = {
                 { 0x48, 1, 0x01, 0x00 },
                 { 0x48, 1, 0x08, 0x00 }
@@ -44,7 +45,7 @@ static int atiixp_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &atiixp_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static void atiixp_error_handler(struct ata_port *ap)
@@ -172,6 +173,9 @@ static void atiixp_set_dmamode(struct ata_port *ap, struct ata_device *adev)
  *
  *      When DMA begins we need to ensure that the UDMA control
  *      register for the channel is correctly set.
+ *
+ *      Note: The host lock held by the libata layer protects
+ *      us from two channels both trying to set DMA bits at once
  */
 
 static void atiixp_bmdma_start(struct ata_queued_cmd *qc)
@@ -198,6 +202,9 @@ static void atiixp_bmdma_start(struct ata_queued_cmd *qc)
  *
  *      DMA has completed. Clear the UDMA flag as the next operations will
  *      be PIO ones not UDMA data transfer.
+ *
+ *      Note: The host lock held by the libata layer protects
+ *      us from two channels both trying to set DMA bits at once
  */
 
 static void atiixp_bmdma_stop(struct ata_queued_cmd *qc)
@@ -232,7 +239,6 @@ static struct scsi_host_template atiixp_sht = {
 };
 
 static struct ata_port_operations atiixp_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = atiixp_set_piomode,
         .set_dmamode    = atiixp_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -261,9 +267,8 @@ static struct ata_port_operations atiixp_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int atiixp_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_bf54x.c b/drivers/ata/pata_bf54x.c
new file mode 100644
index 000000000000..747549e4563a
--- /dev/null
+++ b/drivers/ata/pata_bf54x.c
@@ -0,0 +1,1627 @@
+/*
+ * File:         drivers/ata/pata_bf54x.c
+ * Author:       Sonic Zhang <sonic.zhang@analog.com>
+ *
+ * Created:
+ * Description:  PATA Driver for blackfin 54x
+ *
+ * Modified:
+ *               Copyright 2007 Analog Devices Inc.
+ *
+ * Bugs:         Enter bugs at http://blackfin.uclinux.org/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see the file COPYING, or write
+ * to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <scsi/scsi_host.h>
+#include <linux/libata.h>
+#include <linux/platform_device.h>
+#include <asm/dma.h>
+#include <asm/gpio.h>
+#include <asm/portmux.h>
+
+#define DRV_NAME                "pata-bf54x"
+#define DRV_VERSION             "0.9"
+
+#define ATA_REG_CTRL            0x0E
+#define ATA_REG_ALTSTATUS       ATA_REG_CTRL
+
+/* These are the offset of the controller's registers */
+#define ATAPI_OFFSET_CONTROL            0x00
+#define ATAPI_OFFSET_STATUS             0x04
+#define ATAPI_OFFSET_DEV_ADDR           0x08
+#define ATAPI_OFFSET_DEV_TXBUF          0x0c
+#define ATAPI_OFFSET_DEV_RXBUF          0x10
+#define ATAPI_OFFSET_INT_MASK           0x14
+#define ATAPI_OFFSET_INT_STATUS         0x18
+#define ATAPI_OFFSET_XFER_LEN           0x1c
+#define ATAPI_OFFSET_LINE_STATUS        0x20
+#define ATAPI_OFFSET_SM_STATE           0x24
+#define ATAPI_OFFSET_TERMINATE          0x28
+#define ATAPI_OFFSET_PIO_TFRCNT         0x2c
+#define ATAPI_OFFSET_DMA_TFRCNT         0x30
+#define ATAPI_OFFSET_UMAIN_TFRCNT       0x34
+#define ATAPI_OFFSET_UDMAOUT_TFRCNT     0x38
+#define ATAPI_OFFSET_REG_TIM_0          0x40
+#define ATAPI_OFFSET_PIO_TIM_0          0x44
+#define ATAPI_OFFSET_PIO_TIM_1          0x48
+#define ATAPI_OFFSET_MULTI_TIM_0        0x50
+#define ATAPI_OFFSET_MULTI_TIM_1        0x54
+#define ATAPI_OFFSET_MULTI_TIM_2        0x58
+#define ATAPI_OFFSET_ULTRA_TIM_0        0x60
+#define ATAPI_OFFSET_ULTRA_TIM_1        0x64
+#define ATAPI_OFFSET_ULTRA_TIM_2        0x68
+#define ATAPI_OFFSET_ULTRA_TIM_3        0x6c
+
+
+#define ATAPI_GET_CONTROL(base)\
+        bfin_read16(base + ATAPI_OFFSET_CONTROL)
+#define ATAPI_SET_CONTROL(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_CONTROL, val)
+#define ATAPI_GET_STATUS(base)\
+        bfin_read16(base + ATAPI_OFFSET_STATUS)
+#define ATAPI_GET_DEV_ADDR(base)\
+        bfin_read16(base + ATAPI_OFFSET_DEV_ADDR)
+#define ATAPI_SET_DEV_ADDR(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_DEV_ADDR, val)
+#define ATAPI_GET_DEV_TXBUF(base)\
+        bfin_read16(base + ATAPI_OFFSET_DEV_TXBUF)
+#define ATAPI_SET_DEV_TXBUF(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_DEV_TXBUF, val)
+#define ATAPI_GET_DEV_RXBUF(base)\
+        bfin_read16(base + ATAPI_OFFSET_DEV_RXBUF)
+#define ATAPI_SET_DEV_RXBUF(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_DEV_RXBUF, val)
+#define ATAPI_GET_INT_MASK(base)\
+        bfin_read16(base + ATAPI_OFFSET_INT_MASK)
+#define ATAPI_SET_INT_MASK(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_INT_MASK, val)
+#define ATAPI_GET_INT_STATUS(base)\
+        bfin_read16(base + ATAPI_OFFSET_INT_STATUS)
+#define ATAPI_SET_INT_STATUS(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_INT_STATUS, val)
+#define ATAPI_GET_XFER_LEN(base)\
+        bfin_read16(base + ATAPI_OFFSET_XFER_LEN)
+#define ATAPI_SET_XFER_LEN(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_XFER_LEN, val)
+#define ATAPI_GET_LINE_STATUS(base)\
+        bfin_read16(base + ATAPI_OFFSET_LINE_STATUS)
+#define ATAPI_GET_SM_STATE(base)\
+        bfin_read16(base + ATAPI_OFFSET_SM_STATE)
+#define ATAPI_GET_TERMINATE(base)\
+        bfin_read16(base + ATAPI_OFFSET_TERMINATE)
+#define ATAPI_SET_TERMINATE(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_TERMINATE, val)
+#define ATAPI_GET_PIO_TFRCNT(base)\
+        bfin_read16(base + ATAPI_OFFSET_PIO_TFRCNT)
+#define ATAPI_GET_DMA_TFRCNT(base)\
+        bfin_read16(base + ATAPI_OFFSET_DMA_TFRCNT)
+#define ATAPI_GET_UMAIN_TFRCNT(base)\
+        bfin_read16(base + ATAPI_OFFSET_UMAIN_TFRCNT)
+#define ATAPI_GET_UDMAOUT_TFRCNT(base)\
+        bfin_read16(base + ATAPI_OFFSET_UDMAOUT_TFRCNT)
+#define ATAPI_GET_REG_TIM_0(base)\
+        bfin_read16(base + ATAPI_OFFSET_REG_TIM_0)
+#define ATAPI_SET_REG_TIM_0(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_REG_TIM_0, val)
+#define ATAPI_GET_PIO_TIM_0(base)\
+        bfin_read16(base + ATAPI_OFFSET_PIO_TIM_0)
+#define ATAPI_SET_PIO_TIM_0(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_PIO_TIM_0, val)
+#define ATAPI_GET_PIO_TIM_1(base)\
+        bfin_read16(base + ATAPI_OFFSET_PIO_TIM_1)
+#define ATAPI_SET_PIO_TIM_1(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_PIO_TIM_1, val)
+#define ATAPI_GET_MULTI_TIM_0(base)\
+        bfin_read16(base + ATAPI_OFFSET_MULTI_TIM_0)
+#define ATAPI_SET_MULTI_TIM_0(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_MULTI_TIM_0, val)
+#define ATAPI_GET_MULTI_TIM_1(base)\
+        bfin_read16(base + ATAPI_OFFSET_MULTI_TIM_1)
+#define ATAPI_SET_MULTI_TIM_1(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_MULTI_TIM_1, val)
+#define ATAPI_GET_MULTI_TIM_2(base)\
+        bfin_read16(base + ATAPI_OFFSET_MULTI_TIM_2)
+#define ATAPI_SET_MULTI_TIM_2(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_MULTI_TIM_2, val)
+#define ATAPI_GET_ULTRA_TIM_0(base)\
+        bfin_read16(base + ATAPI_OFFSET_ULTRA_TIM_0)
+#define ATAPI_SET_ULTRA_TIM_0(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_ULTRA_TIM_0, val)
+#define ATAPI_GET_ULTRA_TIM_1(base)\
+        bfin_read16(base + ATAPI_OFFSET_ULTRA_TIM_1)
+#define ATAPI_SET_ULTRA_TIM_1(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_ULTRA_TIM_1, val)
+#define ATAPI_GET_ULTRA_TIM_2(base)\
+        bfin_read16(base + ATAPI_OFFSET_ULTRA_TIM_2)
+#define ATAPI_SET_ULTRA_TIM_2(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_ULTRA_TIM_2, val)
+#define ATAPI_GET_ULTRA_TIM_3(base)\
+        bfin_read16(base + ATAPI_OFFSET_ULTRA_TIM_3)
+#define ATAPI_SET_ULTRA_TIM_3(base, val)\
+        bfin_write16(base + ATAPI_OFFSET_ULTRA_TIM_3, val)
+
+/**
+ * PIO Mode - Frequency compatibility
+ */
+/* mode: 0         1         2         3         4 */
+static const u32 pio_fsclk[] =
+{ 33333333, 33333333, 33333333, 33333333, 33333333 };
+
+/**
+ * MDMA Mode - Frequency compatibility
+ */
+/*               mode:      0         1         2        */
+static const u32 mdma_fsclk[] = { 33333333, 33333333, 33333333 };
+
+/**
+ * UDMA Mode - Frequency compatibility
+ *
+ * UDMA5 - 100 MB/s   - SCLK  = 133 MHz
+ * UDMA4 - 66 MB/s    - SCLK >=  80 MHz
+ * UDMA3 - 44.4 MB/s  - SCLK >=  50 MHz
+ * UDMA2 - 33 MB/s    - SCLK >=  40 MHz
+ */
+/* mode: 0         1         2         3         4          5 */
+static const u32 udma_fsclk[] =
+{ 33333333, 33333333, 40000000, 50000000, 80000000, 133333333 };
+
+/**
+ * Register transfer timing table
+ */
+/*               mode:       0    1    2    3    4    */
+/* Cycle Time                     */
+static const u32 reg_t0min[]   = { 600, 383, 330, 180, 120 };
+/* DIOR/DIOW to end cycle         */
+static const u32 reg_t2min[]   = { 290, 290, 290, 70,  25  };
+/* DIOR/DIOW asserted pulse width */
+static const u32 reg_teocmin[] = { 290, 290, 290, 80,  70  };
+
+/**
+ * PIO timing table
+ */
+/*               mode:       0    1    2    3    4    */
+/* Cycle Time                     */
+static const u32 pio_t0min[]   = { 600, 383, 240, 180, 120 };
+/* Address valid to DIOR/DIORW    */
+static const u32 pio_t1min[]   = { 70,  50,  30,  30,  25  };
+/* DIOR/DIOW to end cycle         */
+static const u32 pio_t2min[]   = { 165, 125, 100, 80,  70  };
+/* DIOR/DIOW asserted pulse width */
+static const u32 pio_teocmin[] = { 165, 125, 100, 70,  25  };
+/* DIOW data hold                 */
+static const u32 pio_t4min[]   = { 30,  20,  15,  10,  10  };
+
+/* ******************************************************************
+ * Multiword DMA timing table
+ * ******************************************************************
+ */
+/*               mode:       0   1    2        */
+/* Cycle Time                     */
+static const u32 mdma_t0min[]  = { 480, 150, 120 };
+/* DIOR/DIOW asserted pulse width */
+static const u32 mdma_tdmin[]  = { 215, 80,  70  };
+/* DMACK to read data released    */
+static const u32 mdma_thmin[]  = { 20,  15,  10  };
+/* DIOR/DIOW to DMACK hold        */
+static const u32 mdma_tjmin[]  = { 20,  5,   5   };
+/* DIOR negated pulse width       */
+static const u32 mdma_tkrmin[] = { 50,  50,  25  };
+/* DIOR negated pulse width       */
+static const u32 mdma_tkwmin[] = { 215, 50,  25  };
+/* CS[1:0] valid to DIOR/DIOW     */
+static const u32 mdma_tmmin[]  = { 50,  30,  25  };
+/* DMACK to read data released    */
+static const u32 mdma_tzmax[]  = { 20,  25,  25  };
+
+/**
+ * Ultra DMA timing table
+ */
+/*               mode:         0    1    2    3    4    5       */
+static const u32 udma_tcycmin[]  = { 112, 73,  54,  39,  25,  17 };
+static const u32 udma_tdvsmin[]  = { 70,  48,  31,  20,  7,   5  };
+static const u32 udma_tenvmax[]  = { 70,  70,  70,  55,  55,  50 };
+static const u32 udma_trpmin[]   = { 160, 125, 100, 100, 100, 85 };
+static const u32 udma_tmin[]     = { 5,   5,   5,   5,   3,   3  };
+
+
+static const u32 udma_tmlimin = 20;
+static const u32 udma_tzahmin = 20;
+static const u32 udma_tenvmin = 20;
+static const u32 udma_tackmin = 20;
+static const u32 udma_tssmin = 50;
+
+/**
+ *
+ *      Function:       num_clocks_min
+ *
+ *      Description:
+ *      calculate number of SCLK cycles to meet minimum timing
+ */
+static unsigned short num_clocks_min(unsigned long tmin,
+                                unsigned long fsclk)
+{
+        unsigned long tmp ;
+        unsigned short result;
+
+        tmp = tmin * (fsclk/1000/1000) / 1000;
+        result = (unsigned short)tmp;
+        if ((tmp*1000*1000) < (tmin*(fsclk/1000))) {
+                result++;
+        }
+
+        return result;
+}
+
+/**
+ *      bfin_set_piomode - Initialize host controller PATA PIO timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: um
+ *
+ *      Set PIO mode for device.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void bfin_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        int mode = adev->pio_mode - XFER_PIO_0;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned int fsclk = get_sclk();
+        unsigned short teoc_reg, t2_reg, teoc_pio;
+        unsigned short t4_reg, t2_pio, t1_reg;
+        unsigned short n0, n6, t6min = 5;
+
+        /* the most restrictive timing value is t6 and tc, the DIOW - data hold
+        * If one SCLK pulse is longer than this minimum value then register
+        * transfers cannot be supported at this frequency.
+        */
+        n6 = num_clocks_min(t6min, fsclk);
+        if (mode >= 0 && mode <= 4 && n6 >= 1) {
+                pr_debug("set piomode: mode=%d, fsclk=%ud\n", mode, fsclk);
+                /* calculate the timing values for register transfers. */
+                while (mode > 0 && pio_fsclk[mode] > fsclk)
+                        mode--;
+
+                /* DIOR/DIOW to end cycle time */
+                t2_reg = num_clocks_min(reg_t2min[mode], fsclk);
+                /* DIOR/DIOW asserted pulse width */
+                teoc_reg = num_clocks_min(reg_teocmin[mode], fsclk);
+                /* Cycle Time */
+                n0  = num_clocks_min(reg_t0min[mode], fsclk);
+
+                /* increase t2 until we meed the minimum cycle length */
+                if (t2_reg + teoc_reg < n0)
+                        t2_reg = n0 - teoc_reg;
+
+                /* calculate the timing values for pio transfers. */
+
+                /* DIOR/DIOW to end cycle time */
+                t2_pio = num_clocks_min(pio_t2min[mode], fsclk);
+                /* DIOR/DIOW asserted pulse width */
+                teoc_pio = num_clocks_min(pio_teocmin[mode], fsclk);
+                /* Cycle Time */
+                n0  = num_clocks_min(pio_t0min[mode], fsclk);
+
+                /* increase t2 until we meed the minimum cycle length */
+                if (t2_pio + teoc_pio < n0)
+                        t2_pio = n0 - teoc_pio;
+
+                /* Address valid to DIOR/DIORW */
+                t1_reg = num_clocks_min(pio_t1min[mode], fsclk);
+
+                /* DIOW data hold */
+                t4_reg = num_clocks_min(pio_t4min[mode], fsclk);
+
+                ATAPI_SET_REG_TIM_0(base, (teoc_reg<<8 | t2_reg));
+                ATAPI_SET_PIO_TIM_0(base, (t4_reg<<12 | t2_pio<<4 | t1_reg));
+                ATAPI_SET_PIO_TIM_1(base, teoc_pio);
+                if (mode > 2) {
+                        ATAPI_SET_CONTROL(base,
+                                ATAPI_GET_CONTROL(base) | IORDY_EN);
+                } else {
+                        ATAPI_SET_CONTROL(base,
+                                ATAPI_GET_CONTROL(base) & ~IORDY_EN);
+                }
+
+                /* Disable host ATAPI PIO interrupts */
+                ATAPI_SET_INT_MASK(base, ATAPI_GET_INT_MASK(base)
+                        & ~(PIO_DONE_MASK | HOST_TERM_XFER_MASK));
+                SSYNC();
+        }
+}
+
+/**
+ *      bfin_set_dmamode - Initialize host controller PATA DMA timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: um
+ *      @udma: udma mode, 0 - 6
+ *
+ *      Set UDMA mode for device.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void bfin_set_dmamode(struct ata_port *ap, struct ata_device *adev)
+{
+        int mode;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned long fsclk = get_sclk();
+        unsigned short tenv, tack, tcyc_tdvs, tdvs, tmli, tss, trp, tzah;
+        unsigned short tm, td, tkr, tkw, teoc, th;
+        unsigned short n0, nf, tfmin = 5;
+        unsigned short nmin, tcyc;
+
+        mode = adev->dma_mode - XFER_UDMA_0;
+        if (mode >= 0 && mode <= 5) {
+                pr_debug("set udmamode: mode=%d\n", mode);
+                /* the most restrictive timing value is t6 and tc,
+                 * the DIOW - data hold. If one SCLK pulse is longer
+                 * than this minimum value then register
+                 * transfers cannot be supported at this frequency.
+                 */
+                while (mode > 0 && udma_fsclk[mode] > fsclk)
+                        mode--;
+
+                nmin = num_clocks_min(udma_tmin[mode], fsclk);
+                if (nmin >= 1) {
+                        /* calculate the timing values for Ultra DMA. */
+                        tdvs = num_clocks_min(udma_tdvsmin[mode], fsclk);
+                        tcyc = num_clocks_min(udma_tcycmin[mode], fsclk);
+                        tcyc_tdvs = 2;
+
+                        /* increase tcyc - tdvs (tcyc_tdvs) until we meed
+                         * the minimum cycle length
+                         */
+                        if (tdvs + tcyc_tdvs < tcyc)
+                                tcyc_tdvs = tcyc - tdvs;
+
+                        /* Mow assign the values required for the timing
+                         * registers
+                         */
+                        if (tcyc_tdvs < 2)
+                                tcyc_tdvs = 2;
+
+                        if (tdvs < 2)
+                                tdvs = 2;
+
+                        tack = num_clocks_min(udma_tackmin, fsclk);
+                        tss = num_clocks_min(udma_tssmin, fsclk);
+                        tmli = num_clocks_min(udma_tmlimin, fsclk);
+                        tzah = num_clocks_min(udma_tzahmin, fsclk);
+                        trp = num_clocks_min(udma_trpmin[mode], fsclk);
+                        tenv = num_clocks_min(udma_tenvmin, fsclk);
+                        if (tenv <= udma_tenvmax[mode]) {
+                                ATAPI_SET_ULTRA_TIM_0(base, (tenv<<8 | tack));
+                                ATAPI_SET_ULTRA_TIM_1(base,
+                                        (tcyc_tdvs<<8 | tdvs));
+                                ATAPI_SET_ULTRA_TIM_2(base, (tmli<<8 | tss));
+                                ATAPI_SET_ULTRA_TIM_3(base, (trp<<8 | tzah));
+
+                                /* Enable host ATAPI Untra DMA interrupts */
+                                ATAPI_SET_INT_MASK(base,
+                                        ATAPI_GET_INT_MASK(base)
+                                        | UDMAIN_DONE_MASK
+                                        | UDMAOUT_DONE_MASK
+                                        | UDMAIN_TERM_MASK
+                                        | UDMAOUT_TERM_MASK);
+                        }
+                }
+        }
+
+        mode = adev->dma_mode - XFER_MW_DMA_0;
+        if (mode >= 0 && mode <= 2) {
+                pr_debug("set mdmamode: mode=%d\n", mode);
+                /* the most restrictive timing value is tf, the DMACK to
+                 * read data released. If one SCLK pulse is longer than
+                 * this maximum value then the MDMA mode
+                 * cannot be supported at this frequency.
+                 */
+                while (mode > 0 && mdma_fsclk[mode] > fsclk)
+                        mode--;
+
+                nf = num_clocks_min(tfmin, fsclk);
+                if (nf >= 1) {
+                        /* calculate the timing values for Multi-word DMA. */
+
+                        /* DIOR/DIOW asserted pulse width */
+                        td = num_clocks_min(mdma_tdmin[mode], fsclk);
+
+                        /* DIOR negated pulse width */
+                        tkw = num_clocks_min(mdma_tkwmin[mode], fsclk);
+
+                        /* Cycle Time */
+                        n0  = num_clocks_min(mdma_t0min[mode], fsclk);
+
+                        /* increase tk until we meed the minimum cycle length */
+                        if (tkw + td < n0)
+                                tkw = n0 - td;
+
+                        /* DIOR negated pulse width - read */
+                        tkr = num_clocks_min(mdma_tkrmin[mode], fsclk);
+                        /* CS{1:0] valid to DIOR/DIOW */
+                        tm = num_clocks_min(mdma_tmmin[mode], fsclk);
+                        /* DIOR/DIOW to DMACK hold */
+                        teoc = num_clocks_min(mdma_tjmin[mode], fsclk);
+                        /* DIOW Data hold */
+                        th = num_clocks_min(mdma_thmin[mode], fsclk);
+
+                        ATAPI_SET_MULTI_TIM_0(base, (tm<<8 | td));
+                        ATAPI_SET_MULTI_TIM_1(base, (tkr<<8 | tkw));
+                        ATAPI_SET_MULTI_TIM_2(base, (teoc<<8 | th));
+
+                        /* Enable host ATAPI Multi DMA interrupts */
+                        ATAPI_SET_INT_MASK(base, ATAPI_GET_INT_MASK(base)
+                                | MULTI_DONE_MASK | MULTI_TERM_MASK);
+                        SSYNC();
+                }
+        }
+        return;
+}
+
+/**
+ *
+ *    Function:       wait_complete
+ *
+ *    Description:    Waits the interrupt from device
+ *
+ */
+static inline void wait_complete(void __iomem *base, unsigned short mask)
+{
+        unsigned short status;
+        unsigned int i = 0;
+
+#define PATA_BF54X_WAIT_TIMEOUT         10000
+
+        for (i = 0; i < PATA_BF54X_WAIT_TIMEOUT; i++) {
+                status = ATAPI_GET_INT_STATUS(base) & mask;
+                if (status)
+                        break;
+        }
+
+        ATAPI_SET_INT_STATUS(base, mask);
+}
+
+/**
+ *
+ *    Function:       write_atapi_register
+ *
+ *    Description:    Writes to ATA Device Resgister
+ *
+ */
+
+static void write_atapi_register(void __iomem *base,
+                unsigned long ata_reg, unsigned short value)
+{
+        /* Program the ATA_DEV_TXBUF register with write data (to be
+         * written into the device).
+         */
+        ATAPI_SET_DEV_TXBUF(base, value);
+
+        /* Program the ATA_DEV_ADDR register with address of the
+         * device register (0x01 to 0x0F).
+         */
+        ATAPI_SET_DEV_ADDR(base, ata_reg);
+
+        /* Program the ATA_CTRL register with dir set to write (1)
+         */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | XFER_DIR));
+
+        /* ensure PIO DMA is not set */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
+
+        /* and start the transfer */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
+
+        /* Wait for the interrupt to indicate the end of the transfer.
+         * (We need to wait on and clear rhe ATA_DEV_INT interrupt status)
+         */
+        wait_complete(base, PIO_DONE_INT);
+}
+
+/**
+ *
+ *      Function:       read_atapi_register
+ *
+ *Description:    Reads from ATA Device Resgister
+ *
+ */
+
+static unsigned short read_atapi_register(void __iomem *base,
+                unsigned long ata_reg)
+{
+        /* Program the ATA_DEV_ADDR register with address of the
+         * device register (0x01 to 0x0F).
+         */
+        ATAPI_SET_DEV_ADDR(base, ata_reg);
+
+        /* Program the ATA_CTRL register with dir set to read (0) and
+         */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~XFER_DIR));
+
+        /* ensure PIO DMA is not set */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
+
+        /* and start the transfer */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
+
+        /* Wait for the interrupt to indicate the end of the transfer.
+         * (PIO_DONE interrupt is set and it doesn't seem to matter
+         * that we don't clear it)
+         */
+        wait_complete(base, PIO_DONE_INT);
+
+        /* Read the ATA_DEV_RXBUF register with write data (to be
+         * written into the device).
+         */
+        return ATAPI_GET_DEV_RXBUF(base);
+}
+
+/**
+ *
+ *    Function:       write_atapi_register_data
+ *
+ *    Description:    Writes to ATA Device Resgister
+ *
+ */
+
+static void write_atapi_data(void __iomem *base,
+                int len, unsigned short *buf)
+{
+        int i;
+
+        /* Set transfer length to 1 */
+        ATAPI_SET_XFER_LEN(base, 1);
+
+        /* Program the ATA_DEV_ADDR register with address of the
+         * ATA_REG_DATA
+         */
+        ATAPI_SET_DEV_ADDR(base, ATA_REG_DATA);
+
+        /* Program the ATA_CTRL register with dir set to write (1)
+         */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | XFER_DIR));
+
+        /* ensure PIO DMA is not set */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
+
+        for (i = 0; i < len; i++) {
+                /* Program the ATA_DEV_TXBUF register with write data (to be
+                 * written into the device).
+                 */
+                ATAPI_SET_DEV_TXBUF(base, buf[i]);
+
+                /* and start the transfer */
+                ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
+
+                /* Wait for the interrupt to indicate the end of the transfer.
+                 * (We need to wait on and clear rhe ATA_DEV_INT
+                 * interrupt status)
+                 */
+                wait_complete(base, PIO_DONE_INT);
+        }
+}
+
+/**
+ *
+ *      Function:       read_atapi_register_data
+ *
+ *      Description:    Reads from ATA Device Resgister
+ *
+ */
+
+static void read_atapi_data(void __iomem *base,
+                int len, unsigned short *buf)
+{
+        int i;
+
+        /* Set transfer length to 1 */
+        ATAPI_SET_XFER_LEN(base, 1);
+
+        /* Program the ATA_DEV_ADDR register with address of the
+         * ATA_REG_DATA
+         */
+        ATAPI_SET_DEV_ADDR(base, ATA_REG_DATA);
+
+        /* Program the ATA_CTRL register with dir set to read (0) and
+         */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~XFER_DIR));
+
+        /* ensure PIO DMA is not set */
+        ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) & ~PIO_USE_DMA));
+
+        for (i = 0; i < len; i++) {
+                /* and start the transfer */
+                ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base) | PIO_START));
+
+                /* Wait for the interrupt to indicate the end of the transfer.
+                 * (PIO_DONE interrupt is set and it doesn't seem to matter
+                 * that we don't clear it)
+                 */
+                wait_complete(base, PIO_DONE_INT);
+
+                /* Read the ATA_DEV_RXBUF register with write data (to be
+                 * written into the device).
+                 */
+                buf[i] = ATAPI_GET_DEV_RXBUF(base);
+        }
+}
+
+/**
+ *      bfin_tf_load - send taskfile registers to host controller
+ *      @ap: Port to which output is sent
+ *      @tf: ATA taskfile register set
+ *
+ *      Note: Original code is ata_tf_load().
+ */
+
+static void bfin_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
+
+        if (tf->ctl != ap->last_ctl) {
+                write_atapi_register(base, ATA_REG_CTRL, tf->ctl);
+                ap->last_ctl = tf->ctl;
+                ata_wait_idle(ap);
+        }
+
+        if (is_addr) {
+                if (tf->flags & ATA_TFLAG_LBA48) {
+                        write_atapi_register(base, ATA_REG_FEATURE,
+                                                tf->hob_feature);
+                        write_atapi_register(base, ATA_REG_NSECT,
+                                                tf->hob_nsect);
+                        write_atapi_register(base, ATA_REG_LBAL, tf->hob_lbal);
+                        write_atapi_register(base, ATA_REG_LBAM, tf->hob_lbam);
+                        write_atapi_register(base, ATA_REG_LBAH, tf->hob_lbah);
+                        pr_debug("hob: feat 0x%X nsect 0x%X, lba 0x%X "
+                                 "0x%X 0x%X\n",
+                                tf->hob_feature,
+                                tf->hob_nsect,
+                                tf->hob_lbal,
+                                tf->hob_lbam,
+                                tf->hob_lbah);
+                }
+
+                write_atapi_register(base, ATA_REG_FEATURE, tf->feature);
+                write_atapi_register(base, ATA_REG_NSECT, tf->nsect);
+                write_atapi_register(base, ATA_REG_LBAL, tf->lbal);
+                write_atapi_register(base, ATA_REG_LBAM, tf->lbam);
+                write_atapi_register(base, ATA_REG_LBAH, tf->lbah);
+                pr_debug("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
+                        tf->feature,
+                        tf->nsect,
+                        tf->lbal,
+                        tf->lbam,
+                        tf->lbah);
+        }
+
+        if (tf->flags & ATA_TFLAG_DEVICE) {
+                write_atapi_register(base, ATA_REG_DEVICE, tf->device);
+                pr_debug("device 0x%X\n", tf->device);
+        }
+
+        ata_wait_idle(ap);
+}
+
+/**
+ *      bfin_check_status - Read device status reg & clear interrupt
+ *      @ap: port where the device is
+ *
+ *      Note: Original code is ata_check_status().
+ */
+
+static u8 bfin_check_status(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        return read_atapi_register(base, ATA_REG_STATUS);
+}
+
+/**
+ *      bfin_tf_read - input device's ATA taskfile shadow registers
+ *      @ap: Port from which input is read
+ *      @tf: ATA taskfile register set for storing input
+ *
+ *      Note: Original code is ata_tf_read().
+ */
+
+static void bfin_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        tf->command = bfin_check_status(ap);
+        tf->feature = read_atapi_register(base, ATA_REG_ERR);
+        tf->nsect = read_atapi_register(base, ATA_REG_NSECT);
+        tf->lbal = read_atapi_register(base, ATA_REG_LBAL);
+        tf->lbam = read_atapi_register(base, ATA_REG_LBAM);
+        tf->lbah = read_atapi_register(base, ATA_REG_LBAH);
+        tf->device = read_atapi_register(base, ATA_REG_DEVICE);
+
+        if (tf->flags & ATA_TFLAG_LBA48) {
+                write_atapi_register(base, ATA_REG_CTRL, tf->ctl | ATA_HOB);
+                tf->hob_feature = read_atapi_register(base, ATA_REG_ERR);
+                tf->hob_nsect = read_atapi_register(base, ATA_REG_NSECT);
+                tf->hob_lbal = read_atapi_register(base, ATA_REG_LBAL);
+                tf->hob_lbam = read_atapi_register(base, ATA_REG_LBAM);
+                tf->hob_lbah = read_atapi_register(base, ATA_REG_LBAH);
+        }
+}
+
+/**
+ *      bfin_exec_command - issue ATA command to host controller
+ *      @ap: port to which command is being issued
+ *      @tf: ATA taskfile register set
+ *
+ *      Note: Original code is ata_exec_command().
+ */
+
+static void bfin_exec_command(struct ata_port *ap,
+                              const struct ata_taskfile *tf)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        pr_debug("ata%u: cmd 0x%X\n", ap->print_id, tf->command);
+
+        write_atapi_register(base, ATA_REG_CMD, tf->command);
+        ata_pause(ap);
+}
+
+/**
+ *      bfin_check_altstatus - Read device alternate status reg
+ *      @ap: port where the device is
+ */
+
+static u8 bfin_check_altstatus(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        return read_atapi_register(base, ATA_REG_ALTSTATUS);
+}
+
+/**
+ *      bfin_std_dev_select - Select device 0/1 on ATA bus
+ *      @ap: ATA channel to manipulate
+ *      @device: ATA device (numbered from zero) to select
+ *
+ *      Note: Original code is ata_std_dev_select().
+ */
+
+static void bfin_std_dev_select(struct ata_port *ap, unsigned int device)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        u8 tmp;
+
+        if (device == 0)
+                tmp = ATA_DEVICE_OBS;
+        else
+                tmp = ATA_DEVICE_OBS | ATA_DEV1;
+
+        write_atapi_register(base, ATA_REG_DEVICE, tmp);
+        ata_pause(ap);
+}
+
+/**
+ *      bfin_bmdma_setup - Set up IDE DMA transaction
+ *      @qc: Info associated with this ATA transaction.
+ *
+ *      Note: Original code is ata_bmdma_setup().
+ */
+
+static void bfin_bmdma_setup(struct ata_queued_cmd *qc)
+{
+        unsigned short config = WDSIZE_16;
+        struct scatterlist *sg;
+
+        pr_debug("in atapi dma setup\n");
+        /* Program the ATA_CTRL register with dir */
+        if (qc->tf.flags & ATA_TFLAG_WRITE) {
+                /* fill the ATAPI DMA controller */
+                set_dma_config(CH_ATAPI_TX, config);
+                set_dma_x_modify(CH_ATAPI_TX, 2);
+                ata_for_each_sg(sg, qc) {
+                        set_dma_start_addr(CH_ATAPI_TX, sg_dma_address(sg));
+                        set_dma_x_count(CH_ATAPI_TX, sg_dma_len(sg) >> 1);
+                }
+        } else {
+                config |= WNR;
+                /* fill the ATAPI DMA controller */
+                set_dma_config(CH_ATAPI_RX, config);
+                set_dma_x_modify(CH_ATAPI_RX, 2);
+                ata_for_each_sg(sg, qc) {
+                        set_dma_start_addr(CH_ATAPI_RX, sg_dma_address(sg));
+                        set_dma_x_count(CH_ATAPI_RX, sg_dma_len(sg) >> 1);
+                }
+        }
+}
+
+/**
+ *      bfin_bmdma_start - Start an IDE DMA transaction
+ *      @qc: Info associated with this ATA transaction.
+ *
+ *      Note: Original code is ata_bmdma_start().
+ */
+
+static void bfin_bmdma_start(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        struct scatterlist *sg;
+
+        pr_debug("in atapi dma start\n");
+        if (!(ap->udma_mask || ap->mwdma_mask))
+                return;
+
+        /* start ATAPI DMA controller*/
+        if (qc->tf.flags & ATA_TFLAG_WRITE) {
+                /*
+                 * On blackfin arch, uncacheable memory is not
+                 * allocated with flag GFP_DMA. DMA buffer from
+                 * common kenel code should be flushed if WB
+                 * data cache is enabled. Otherwise, this loop
+                 * is an empty loop and optimized out.
+                 */
+                ata_for_each_sg(sg, qc) {
+                        flush_dcache_range(sg_dma_address(sg),
+                                sg_dma_address(sg) + sg_dma_len(sg));
+                }
+                enable_dma(CH_ATAPI_TX);
+                pr_debug("enable udma write\n");
+
+                /* Send ATA DMA write command */
+                bfin_exec_command(ap, &qc->tf);
+
+                /* set ATA DMA write direction */
+                ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base)
+                        | XFER_DIR));
+        } else {
+                enable_dma(CH_ATAPI_RX);
+                pr_debug("enable udma read\n");
+
+                /* Send ATA DMA read command */
+                bfin_exec_command(ap, &qc->tf);
+
+                /* set ATA DMA read direction */
+                ATAPI_SET_CONTROL(base, (ATAPI_GET_CONTROL(base)
+                        & ~XFER_DIR));
+        }
+
+        /* Reset all transfer count */
+        ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base) | TFRCNT_RST);
+
+                /* Set transfer length to buffer len */
+        ata_for_each_sg(sg, qc) {
+                ATAPI_SET_XFER_LEN(base, (sg_dma_len(sg) >> 1));
+        }
+
+        /* Enable ATA DMA operation*/
+        if (ap->udma_mask)
+                ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base)
+                        | ULTRA_START);
+        else
+                ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base)
+                        | MULTI_START);
+}
+
+/**
+ *      bfin_bmdma_stop - Stop IDE DMA transfer
+ *      @qc: Command we are ending DMA for
+ */
+
+static void bfin_bmdma_stop(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct scatterlist *sg;
+
+        pr_debug("in atapi dma stop\n");
+        if (!(ap->udma_mask || ap->mwdma_mask))
+                return;
+
+        /* stop ATAPI DMA controller*/
+        if (qc->tf.flags & ATA_TFLAG_WRITE)
+                disable_dma(CH_ATAPI_TX);
+        else {
+                disable_dma(CH_ATAPI_RX);
+                if (ap->hsm_task_state & HSM_ST_LAST) {
+                        /*
+                         * On blackfin arch, uncacheable memory is not
+                         * allocated with flag GFP_DMA. DMA buffer from
+                         * common kenel code should be invalidated if
+                         * data cache is enabled. Otherwise, this loop
+                         * is an empty loop and optimized out.
+                         */
+                        ata_for_each_sg(sg, qc) {
+                                invalidate_dcache_range(
+                                        sg_dma_address(sg),
+                                        sg_dma_address(sg)
+                                        + sg_dma_len(sg));
+                        }
+                }
+        }
+}
+
+/**
+ *      bfin_devchk - PATA device presence detection
+ *      @ap: ATA channel to examine
+ *      @device: Device to examine (starting at zero)
+ *
+ *      Note: Original code is ata_devchk().
+ */
+
+static unsigned int bfin_devchk(struct ata_port *ap,
+                                unsigned int device)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        u8 nsect, lbal;
+
+        bfin_std_dev_select(ap, device);
+
+        write_atapi_register(base, ATA_REG_NSECT, 0x55);
+        write_atapi_register(base, ATA_REG_LBAL, 0xaa);
+
+        write_atapi_register(base, ATA_REG_NSECT, 0xaa);
+        write_atapi_register(base, ATA_REG_LBAL, 0x55);
+
+        write_atapi_register(base, ATA_REG_NSECT, 0x55);
+        write_atapi_register(base, ATA_REG_LBAL, 0xaa);
+
+        nsect = read_atapi_register(base, ATA_REG_NSECT);
+        lbal = read_atapi_register(base, ATA_REG_LBAL);
+
+        if ((nsect == 0x55) && (lbal == 0xaa))
+                return 1;       /* we found a device */
+
+        return 0;               /* nothing found */
+}
+
+/**
+ *      bfin_bus_post_reset - PATA device post reset
+ *
+ *      Note: Original code is ata_bus_post_reset().
+ */
+
+static void bfin_bus_post_reset(struct ata_port *ap, unsigned int devmask)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned int dev0 = devmask & (1 << 0);
+        unsigned int dev1 = devmask & (1 << 1);
+        unsigned long timeout;
+
+        /* if device 0 was found in ata_devchk, wait for its
+         * BSY bit to clear
+         */
+        if (dev0)
+                ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+
+        /* if device 1 was found in ata_devchk, wait for
+         * register access, then wait for BSY to clear
+         */
+        timeout = jiffies + ATA_TMOUT_BOOT;
+        while (dev1) {
+                u8 nsect, lbal;
+
+                bfin_std_dev_select(ap, 1);
+                nsect = read_atapi_register(base, ATA_REG_NSECT);
+                lbal = read_atapi_register(base, ATA_REG_LBAL);
+                if ((nsect == 1) && (lbal == 1))
+                        break;
+                if (time_after(jiffies, timeout)) {
+                        dev1 = 0;
+                        break;
+                }
+                msleep(50);     /* give drive a breather */
+        }
+        if (dev1)
+                ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+
+        /* is all this really necessary? */
+        bfin_std_dev_select(ap, 0);
+        if (dev1)
+                bfin_std_dev_select(ap, 1);
+        if (dev0)
+                bfin_std_dev_select(ap, 0);
+}
+
+/**
+ *      bfin_bus_softreset - PATA device software reset
+ *
+ *      Note: Original code is ata_bus_softreset().
+ */
+
+static unsigned int bfin_bus_softreset(struct ata_port *ap,
+                                       unsigned int devmask)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        /* software reset.  causes dev0 to be selected */
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+        udelay(20);
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl | ATA_SRST);
+        udelay(20);
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+
+        /* spec mandates ">= 2ms" before checking status.
+         * We wait 150ms, because that was the magic delay used for
+         * ATAPI devices in Hale Landis's ATADRVR, for the period of time
+         * between when the ATA command register is written, and then
+         * status is checked.  Because waiting for "a while" before
+         * checking status is fine, post SRST, we perform this magic
+         * delay here as well.
+         *
+         * Old drivers/ide uses the 2mS rule and then waits for ready
+         */
+        msleep(150);
+
+        /* Before we perform post reset processing we want to see if
+         * the bus shows 0xFF because the odd clown forgets the D7
+         * pulldown resistor.
+         */
+        if (bfin_check_status(ap) == 0xFF)
+                return 0;
+
+        bfin_bus_post_reset(ap, devmask);
+
+        return 0;
+}
+
+/**
+ *      bfin_std_softreset - reset host port via ATA SRST
+ *      @ap: port to reset
+ *      @classes: resulting classes of attached devices
+ *
+ *      Note: Original code is ata_std_softreset().
+ */
+
+static int bfin_std_softreset(struct ata_port *ap, unsigned int *classes,
+                unsigned long deadline)
+{
+        unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
+        unsigned int devmask = 0, err_mask;
+        u8 err;
+
+        if (ata_port_offline(ap)) {
+                classes[0] = ATA_DEV_NONE;
+                goto out;
+        }
+
+        /* determine if device 0/1 are present */
+        if (bfin_devchk(ap, 0))
+                devmask |= (1 << 0);
+        if (slave_possible && bfin_devchk(ap, 1))
+                devmask |= (1 << 1);
+
+        /* select device 0 again */
+        bfin_std_dev_select(ap, 0);
+
+        /* issue bus reset */
+        err_mask = bfin_bus_softreset(ap, devmask);
+        if (err_mask) {
+                ata_port_printk(ap, KERN_ERR, "SRST failed (err_mask=0x%x)\n",
+                                err_mask);
+                return -EIO;
+        }
+
+        /* determine by signature whether we have ATA or ATAPI devices */
+        classes[0] = ata_dev_try_classify(ap, 0, &err);
+        if (slave_possible && err != 0x81)
+                classes[1] = ata_dev_try_classify(ap, 1, &err);
+
+ out:
+        return 0;
+}
+
+/**
+ *      bfin_bmdma_status - Read IDE DMA status
+ *      @ap: Port associated with this ATA transaction.
+ */
+
+static unsigned char bfin_bmdma_status(struct ata_port *ap)
+{
+        unsigned char host_stat = 0;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned short int_status = ATAPI_GET_INT_STATUS(base);
+
+        if (ATAPI_GET_STATUS(base) & (MULTI_XFER_ON|ULTRA_XFER_ON)) {
+                host_stat = ATA_DMA_ACTIVE;
+        }
+        if (int_status & (MULTI_DONE_INT|UDMAIN_DONE_INT|UDMAOUT_DONE_INT)) {
+                host_stat = ATA_DMA_INTR;
+        }
+        if (int_status & (MULTI_TERM_INT|UDMAIN_TERM_INT|UDMAOUT_TERM_INT)) {
+                host_stat = ATA_DMA_ERR;
+        }
+
+        return host_stat;
+}
+
+/**
+ *      bfin_data_xfer - Transfer data by PIO
+ *      @adev: device for this I/O
+ *      @buf: data buffer
+ *      @buflen: buffer length
+ *      @write_data: read/write
+ *
+ *      Note: Original code is ata_data_xfer().
+ */
+
+static void bfin_data_xfer(struct ata_device *adev, unsigned char *buf,
+                           unsigned int buflen, int write_data)
+{
+        struct ata_port *ap = adev->ap;
+        unsigned int words = buflen >> 1;
+        unsigned short *buf16 = (u16 *) buf;
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        /* Transfer multiple of 2 bytes */
+        if (write_data) {
+                write_atapi_data(base, words, buf16);
+        } else {
+                read_atapi_data(base, words, buf16);
+        }
+
+        /* Transfer trailing 1 byte, if any. */
+        if (unlikely(buflen & 0x01)) {
+                unsigned short align_buf[1] = { 0 };
+                unsigned char *trailing_buf = buf + buflen - 1;
+
+                if (write_data) {
+                        memcpy(align_buf, trailing_buf, 1);
+                        write_atapi_data(base, 1, align_buf);
+                } else {
+                        read_atapi_data(base, 1, align_buf);
+                        memcpy(trailing_buf, align_buf, 1);
+                }
+        }
+}
+
+/**
+ *      bfin_irq_clear - Clear ATAPI interrupt.
+ *      @ap: Port associated with this ATA transaction.
+ *
+ *      Note: Original code is ata_bmdma_irq_clear().
+ */
+
+static void bfin_irq_clear(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        pr_debug("in atapi irq clear\n");
+        ATAPI_SET_INT_STATUS(base, 0x1FF);
+}
+
+/**
+ *      bfin_irq_on - Enable interrupts on a port.
+ *      @ap: Port on which interrupts are enabled.
+ *
+ *      Note: Original code is ata_irq_on().
+ */
+
+static unsigned char bfin_irq_on(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        u8 tmp;
+
+        pr_debug("in atapi irq on\n");
+        ap->ctl &= ~ATA_NIEN;
+        ap->last_ctl = ap->ctl;
+
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+        tmp = ata_wait_idle(ap);
+
+        bfin_irq_clear(ap);
+
+        return tmp;
+}
+
+/**
+ *      bfin_irq_ack - Acknowledge a device interrupt.
+ *      @ap: Port on which interrupts are enabled.
+ *
+ *      Note: Original code is ata_irq_ack().
+ */
+
+static unsigned char bfin_irq_ack(struct ata_port *ap, unsigned int chk_drq)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
+        unsigned char status;
+
+        pr_debug("in atapi irq ack\n");
+        status = ata_busy_wait(ap, bits, 1000);
+        if (status & bits)
+                if (ata_msg_err(ap))
+                        dev_err(ap->dev, "abnormal status 0x%X\n", status);
+
+        /* get controller status; clear intr, err bits */
+        ATAPI_SET_INT_STATUS(base, ATAPI_GET_INT_STATUS(base)|ATAPI_DEV_INT
+                | MULTI_DONE_INT | UDMAIN_DONE_INT | UDMAOUT_DONE_INT
+                | MULTI_TERM_INT | UDMAIN_TERM_INT | UDMAOUT_TERM_INT);
+
+        return bfin_bmdma_status(ap);
+}
+
+/**
+ *      bfin_bmdma_freeze - Freeze DMA controller port
+ *      @ap: port to freeze
+ *
+ *      Note: Original code is ata_bmdma_freeze().
+ */
+
+static void bfin_bmdma_freeze(struct ata_port *ap)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        pr_debug("in atapi dma freeze\n");
+        ap->ctl |= ATA_NIEN;
+        ap->last_ctl = ap->ctl;
+
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+
+        /* Under certain circumstances, some controllers raise IRQ on
+         * ATA_NIEN manipulation.  Also, many controllers fail to mask
+         * previously pending IRQ on ATA_NIEN assertion.  Clear it.
+         */
+        ata_chk_status(ap);
+
+        bfin_irq_clear(ap);
+}
+
+/**
+ *      bfin_bmdma_thaw - Thaw DMA controller port
+ *      @ap: port to thaw
+ *
+ *      Note: Original code is ata_bmdma_thaw().
+ */
+
+void bfin_bmdma_thaw(struct ata_port *ap)
+{
+        bfin_check_status(ap);
+        bfin_irq_clear(ap);
+        bfin_irq_on(ap);
+}
+
+/**
+ *      bfin_std_postreset - standard postreset callback
+ *      @ap: the target ata_port
+ *      @classes: classes of attached devices
+ *
+ *      Note: Original code is ata_std_postreset().
+ */
+
+static void bfin_std_postreset(struct ata_port *ap, unsigned int *classes)
+{
+        void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
+
+        /* re-enable interrupts */
+        bfin_irq_on(ap);
+
+        /* is double-select really necessary? */
+        if (classes[0] != ATA_DEV_NONE)
+                bfin_std_dev_select(ap, 1);
+        if (classes[1] != ATA_DEV_NONE)
+                bfin_std_dev_select(ap, 0);
+
+        /* bail out if no device is present */
+        if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
+                return;
+        }
+
+        /* set up device control */
+        write_atapi_register(base, ATA_REG_CTRL, ap->ctl);
+}
+
+/**
+ *      bfin_error_handler - Stock error handler for DMA controller
+ *      @ap: port to handle error for
+ */
+
+static void bfin_error_handler(struct ata_port *ap)
+{
+        ata_bmdma_drive_eh(ap, ata_std_prereset, bfin_std_softreset, NULL,
+                           bfin_std_postreset);
+}
+
+static void bfin_port_stop(struct ata_port *ap)
+{
+        pr_debug("in atapi port stop\n");
+        if (ap->udma_mask != 0 || ap->mwdma_mask != 0) {
+                free_dma(CH_ATAPI_RX);
+                free_dma(CH_ATAPI_TX);
+        }
+}
+
+static int bfin_port_start(struct ata_port *ap)
+{
+        pr_debug("in atapi port start\n");
+        if (!(ap->udma_mask || ap->mwdma_mask))
+                return 0;
+
+        if (request_dma(CH_ATAPI_RX, "BFIN ATAPI RX DMA") >= 0) {
+                if (request_dma(CH_ATAPI_TX,
+                        "BFIN ATAPI TX DMA") >= 0)
+                        return 0;
+
+                free_dma(CH_ATAPI_RX);
+        }
+
+        ap->udma_mask = 0;
+        ap->mwdma_mask = 0;
+        dev_err(ap->dev, "Unable to request ATAPI DMA!"
+                " Continue in PIO mode.\n");
+
+        return 0;
+}
+
+static struct scsi_host_template bfin_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = SG_NONE,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = ATA_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .slave_destroy          = ata_scsi_slave_destroy,
+        .bios_param             = ata_std_bios_param,
+#ifdef CONFIG_PM
+        .resume                 = ata_scsi_device_resume,
+        .suspend                = ata_scsi_device_suspend,
+#endif
+};
+
+static const struct ata_port_operations bfin_pata_ops = {
+        .port_disable           = ata_port_disable,
+        .set_piomode            = bfin_set_piomode,
+        .set_dmamode            = bfin_set_dmamode,
+
+        .tf_load                = bfin_tf_load,
+        .tf_read                = bfin_tf_read,
+        .exec_command           = bfin_exec_command,
+        .check_status           = bfin_check_status,
+        .check_altstatus        = bfin_check_altstatus,
+        .dev_select             = bfin_std_dev_select,
+
+        .bmdma_setup            = bfin_bmdma_setup,
+        .bmdma_start            = bfin_bmdma_start,
+        .bmdma_stop             = bfin_bmdma_stop,
+        .bmdma_status           = bfin_bmdma_status,
+        .data_xfer              = bfin_data_xfer,
+
+        .qc_prep                = ata_noop_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+
+        .freeze                 = bfin_bmdma_freeze,
+        .thaw                   = bfin_bmdma_thaw,
+        .error_handler          = bfin_error_handler,
+        .post_internal_cmd      = bfin_bmdma_stop,
+
+        .irq_handler            = ata_interrupt,
+        .irq_clear              = bfin_irq_clear,
+        .irq_on                 = bfin_irq_on,
+        .irq_ack                = bfin_irq_ack,
+
+        .port_start             = bfin_port_start,
+        .port_stop              = bfin_port_stop,
+};
+
+static struct ata_port_info bfin_port_info[] = {
+        {
+                .sht            = &bfin_sht,
+                .flags          = ATA_FLAG_SLAVE_POSS
+                                | ATA_FLAG_MMIO
+                                | ATA_FLAG_NO_LEGACY,
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .mwdma_mask     = 0,
+#ifdef CONFIG_PATA_BF54X_DMA
+                .udma_mask      = ATA_UDMA5,
+#else
+                .udma_mask      = 0,
+#endif
+                .port_ops       = &bfin_pata_ops,
+        },
+};
+
+/**
+ *      bfin_reset_controller - initialize BF54x ATAPI controller.
+ */
+
+static int bfin_reset_controller(struct ata_host *host)
+{
+        void __iomem *base = (void __iomem *)host->ports[0]->ioaddr.ctl_addr;
+        int count;
+        unsigned short status;
+
+        /* Disable all ATAPI interrupts */
+        ATAPI_SET_INT_MASK(base, 0);
+        SSYNC();
+
+        /* Assert the RESET signal 25us*/
+        ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base) | DEV_RST);
+        udelay(30);
+
+        /* Negate the RESET signal for 2ms*/
+        ATAPI_SET_CONTROL(base, ATAPI_GET_CONTROL(base) & ~DEV_RST);
+        msleep(2);
+
+        /* Wait on Busy flag to clear */
+        count = 10000000;
+        do {
+                status = read_atapi_register(base, ATA_REG_STATUS);
+        } while (count-- && (status & ATA_BUSY));
+
+        /* Enable only ATAPI Device interrupt */
+        ATAPI_SET_INT_MASK(base, 1);
+        SSYNC();
+
+        return (!count);
+}
+
+/**
+ *      atapi_io_port - define atapi peripheral port pins.
+ */
+static unsigned short atapi_io_port[] = {
+        P_ATAPI_RESET,
+        P_ATAPI_DIOR,
+        P_ATAPI_DIOW,
+        P_ATAPI_CS0,
+        P_ATAPI_CS1,
+        P_ATAPI_DMACK,
+        P_ATAPI_DMARQ,
+        P_ATAPI_INTRQ,
+        P_ATAPI_IORDY,
+        0
+};
+
+/**
+ *      bfin_atapi_probe        -       attach a bfin atapi interface
+ *      @pdev: platform device
+ *
+ *      Register a bfin atapi interface.
+ *
+ *
+ *      Platform devices are expected to contain 2 resources per port:
+ *
+ *              - I/O Base (IORESOURCE_IO)
+ *              - IRQ      (IORESOURCE_IRQ)
+ *
+ */
+static int __devinit bfin_atapi_probe(struct platform_device *pdev)
+{
+        int board_idx = 0;
+        struct resource *res;
+        struct ata_host *host;
+        const struct ata_port_info *ppi[] =
+                { &bfin_port_info[board_idx], NULL };
+
+        /*
+         * Simple resource validation ..
+         */
+        if (unlikely(pdev->num_resources != 2)) {
+                dev_err(&pdev->dev, "invalid number of resources\n");
+                return -EINVAL;
+        }
+
+        /*
+         * Get the register base first
+         */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL)
+                return -EINVAL;
+
+        /*
+         * Now that that's out of the way, wire up the port..
+         */
+        host = ata_host_alloc_pinfo(&pdev->dev, ppi, 1);
+        if (!host)
+                return -ENOMEM;
+
+        host->ports[0]->ioaddr.ctl_addr = (void *)res->start;
+
+        if (peripheral_request_list(atapi_io_port, "atapi-io-port")) {
+                dev_err(&pdev->dev, "Requesting Peripherals faild\n");
+                return -EFAULT;
+        }
+
+        if (bfin_reset_controller(host)) {
+                peripheral_free_list(atapi_io_port);
+                dev_err(&pdev->dev, "Fail to reset ATAPI device\n");
+                return -EFAULT;
+        }
+
+        if (ata_host_activate(host, platform_get_irq(pdev, 0),
+                ata_interrupt, IRQF_SHARED, &bfin_sht) != 0) {
+                peripheral_free_list(atapi_io_port);
+                dev_err(&pdev->dev, "Fail to attach ATAPI device\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+/**
+ *      bfin_atapi_remove       -       unplug a bfin atapi interface
+ *      @pdev: platform device
+ *
+ *      A bfin atapi device has been unplugged. Perform the needed
+ *      cleanup. Also called on module unload for any active devices.
+ */
+static int __devexit bfin_atapi_remove(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct ata_host *host = dev_get_drvdata(dev);
+
+        ata_host_detach(host);
+
+        peripheral_free_list(atapi_io_port);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+int bfin_atapi_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        return 0;
+}
+
+int bfin_atapi_resume(struct platform_device *pdev)
+{
+        return 0;
+}
+#endif
+
+static struct platform_driver bfin_atapi_driver = {
+        .probe                  = bfin_atapi_probe,
+        .remove                 = __devexit_p(bfin_atapi_remove),
+        .driver = {
+                .name           = DRV_NAME,
+                .owner          = THIS_MODULE,
+#ifdef CONFIG_PM
+                .suspend        = bfin_atapi_suspend,
+                .resume         = bfin_atapi_resume,
+#endif
+        },
+};
+
+static int __init bfin_atapi_init(void)
+{
+        pr_info("register bfin atapi driver\n");
+        return platform_driver_register(&bfin_atapi_driver);
+}
+
+static void __exit bfin_atapi_exit(void)
+{
+        platform_driver_unregister(&bfin_atapi_driver);
+}
+
+module_init(bfin_atapi_init);
+module_exit(bfin_atapi_exit);
+
+MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
+MODULE_DESCRIPTION("PATA driver for blackfin 54x ATAPI controller");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/ata/pata_cmd640.c b/drivers/ata/pata_cmd640.c
index 0feb5ae8c486..43d198f90968 100644
--- a/drivers/ata/pata_cmd640.c
+++ b/drivers/ata/pata_cmd640.c
@@ -153,7 +153,7 @@ static int cmd640_port_start(struct ata_port *ap)
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         struct cmd640_reg *timing;
 
-        int ret = ata_port_start(ap);
+        int ret = ata_sff_port_start(ap);
         if (ret < 0)
                 return ret;
 
@@ -184,7 +184,6 @@ static struct scsi_host_template cmd640_sht = {
 };
 
 static struct ata_port_operations cmd640_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cmd640_set_piomode,
         .mode_filter    = ata_pci_default_filter,
         .tf_load        = ata_tf_load,
@@ -213,7 +212,6 @@ static struct ata_port_operations cmd640_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = cmd640_port_start,
 };
diff --git a/drivers/ata/pata_cmd64x.c b/drivers/ata/pata_cmd64x.c
index e34b632487d7..9e412c26b2a3 100644
--- a/drivers/ata/pata_cmd64x.c
+++ b/drivers/ata/pata_cmd64x.c
@@ -31,7 +31,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_cmd64x"
-#define DRV_VERSION "0.2.4"
+#define DRV_VERSION "0.2.5"
 
 /*
  * CMD64x specific registers definition.
@@ -88,14 +88,15 @@ static int cmd648_cable_detect(struct ata_port *ap)
 }
 
 /**
- *      cmd64x_set_piomode      -       set initial PIO mode data
+ *      cmd64x_set_piomode      -       set PIO and MWDMA timing
  *      @ap: ATA interface
  *      @adev: ATA device
+ *      @mode: mode
  *
- *      Called to do the PIO mode setup.
+ *      Called to do the PIO and MWDMA mode setup.
  */
 
-static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
+static void cmd64x_set_timing(struct ata_port *ap, struct ata_device *adev, u8 mode)
 {
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         struct ata_timing t;
@@ -117,8 +118,9 @@ static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
         int arttim = arttim_port[ap->port_no][adev->devno];
         int drwtim = drwtim_port[ap->port_no][adev->devno];
 
-
-        if (ata_timing_compute(adev, adev->pio_mode, &t, T, 0) < 0) {
+        /* ata_timing_compute is smart and will produce timings for MWDMA
+           that don't violate the drives PIO capabilities. */
+        if (ata_timing_compute(adev, mode, &t, T, 0) < 0) {
                 printk(KERN_ERR DRV_NAME ": mode computation failed.\n");
                 return;
         }
@@ -168,6 +170,20 @@ static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
 }
 
 /**
+ *      cmd64x_set_piomode      -       set initial PIO mode data
+ *      @ap: ATA interface
+ *      @adev: ATA device
+ *
+ *      Used when configuring the devices ot set the PIO timings. All the
+ *      actual work is done by the PIO/MWDMA setting helper
+ */
+
+static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        cmd64x_set_timing(ap, adev, adev->pio_mode);
+}
+
+/**
  *      cmd64x_set_dmamode      -       set initial DMA mode data
  *      @ap: ATA interface
  *      @adev: ATA device
@@ -180,9 +196,6 @@ static void cmd64x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
         static const u8 udma_data[] = {
                 0x30, 0x20, 0x10, 0x20, 0x10, 0x00
         };
-        static const u8 mwdma_data[] = {
-                0x30, 0x20, 0x10
-        };
 
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         u8 regU, regD;
@@ -208,8 +221,10 @@ static void cmd64x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
                 regU |= 1 << adev->devno; /* UDMA on */
                 if (adev->dma_mode > 2) /* 15nS timing */
                         regU |= 4 << adev->devno;
-        } else
-                regD |= mwdma_data[adev->dma_mode - XFER_MW_DMA_0] << shift;
+        } else {
+                regU &= ~ (1 << adev->devno);   /* UDMA off */
+                cmd64x_set_timing(ap, adev, adev->dma_mode);
+        }
 
         regD |= 0x20 << adev->devno;
 
@@ -269,7 +284,6 @@ static struct scsi_host_template cmd64x_sht = {
 };
 
 static struct ata_port_operations cmd64x_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cmd64x_set_piomode,
         .set_dmamode    = cmd64x_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -298,13 +312,11 @@ static struct ata_port_operations cmd64x_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
 
 static struct ata_port_operations cmd646r1_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cmd64x_set_piomode,
         .set_dmamode    = cmd64x_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -333,13 +345,11 @@ static struct ata_port_operations cmd646r1_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
 
 static struct ata_port_operations cmd648_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cmd64x_set_piomode,
         .set_dmamode    = cmd64x_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -368,7 +378,6 @@ static struct ata_port_operations cmd648_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
diff --git a/drivers/ata/pata_cs5520.c b/drivers/ata/pata_cs5520.c
index e2459088cdcd..33f7f0843f4f 100644
--- a/drivers/ata/pata_cs5520.c
+++ b/drivers/ata/pata_cs5520.c
@@ -158,7 +158,6 @@ static struct scsi_host_template cs5520_sht = {
 };
 
 static struct ata_port_operations cs5520_port_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = cs5520_set_piomode,
         .set_dmamode            = cs5520_set_dmamode,
 
@@ -184,13 +183,14 @@ static struct ata_port_operations cs5520_port_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
+        static const unsigned int cmd_port[] = { 0x1F0, 0x170 };
+        static const unsigned int ctl_port[] = { 0x3F6, 0x376 };
         struct ata_port_info pi = {
                 .flags          = ATA_FLAG_SLAVE_POSS,
                 .pio_mask       = 0x1f,
@@ -244,10 +244,10 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
         }
 
         /* Map IO ports and initialize host accordingly */
-        iomap[0] = devm_ioport_map(&pdev->dev, 0x1F0, 8);
-        iomap[1] = devm_ioport_map(&pdev->dev, 0x3F6, 1);
-        iomap[2] = devm_ioport_map(&pdev->dev, 0x170, 8);
-        iomap[3] = devm_ioport_map(&pdev->dev, 0x376, 1);
+        iomap[0] = devm_ioport_map(&pdev->dev, cmd_port[0], 8);
+        iomap[1] = devm_ioport_map(&pdev->dev, ctl_port[0], 1);
+        iomap[2] = devm_ioport_map(&pdev->dev, cmd_port[1], 8);
+        iomap[3] = devm_ioport_map(&pdev->dev, ctl_port[1], 1);
         iomap[4] = pcim_iomap(pdev, 2, 0);
 
         if (!iomap[0] || !iomap[1] || !iomap[2] || !iomap[3] || !iomap[4])
@@ -260,6 +260,10 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
         ioaddr->bmdma_addr = iomap[4];
         ata_std_ports(ioaddr);
 
+        ata_port_desc(host->ports[0],
+                      "cmd 0x%x ctl 0x%x", cmd_port[0], ctl_port[0]);
+        ata_port_pbar_desc(host->ports[0], 4, 0, "bmdma");
+
         ioaddr = &host->ports[1]->ioaddr;
         ioaddr->cmd_addr = iomap[2];
         ioaddr->ctl_addr = iomap[3];
@@ -267,6 +271,10 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
         ioaddr->bmdma_addr = iomap[4] + 8;
         ata_std_ports(ioaddr);
 
+        ata_port_desc(host->ports[1],
+                      "cmd 0x%x ctl 0x%x", cmd_port[1], ctl_port[1]);
+        ata_port_pbar_desc(host->ports[1], 4, 8, "bmdma");
+
         /* activate the host */
         pci_set_master(pdev);
         rc = ata_host_start(host);
@@ -285,33 +293,12 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
                 if (rc)
                         return rc;
 
-                if (i == 0)
-                        host->irq = irq[0];
-                else
-                        host->irq2 = irq[1];
+                ata_port_desc(ap, "irq %d", irq[i]);
         }
 
         return ata_host_register(host, &cs5520_sht);
 }
 
-/**
- *      cs5520_remove_one       -       device unload
- *      @pdev: PCI device being removed
- *
- *      Handle an unplug/unload event for a PCI device. Unload the
- *      PCI driver but do not use the default handler as we manage
- *      resources ourself and *MUST NOT* disable the device as it has
- *      other functions.
- */
-
-static void __devexit cs5520_remove_one(struct pci_dev *pdev)
-{
-        struct device *dev = pci_dev_to_dev(pdev);
-        struct ata_host *host = dev_get_drvdata(dev);
-
-        ata_host_detach(host);
-}
-
 #ifdef CONFIG_PM
 /**
  *      cs5520_reinit_one       -       device resume
@@ -368,7 +355,7 @@ static struct pci_driver cs5520_pci_driver = {
         .name           = DRV_NAME,
         .id_table       = pata_cs5520,
         .probe          = cs5520_init_one,
-        .remove         = cs5520_remove_one,
+        .remove         = ata_pci_remove_one,
 #ifdef CONFIG_PM
         .suspend        = cs5520_pci_device_suspend,
         .resume         = cs5520_reinit_one,
diff --git a/drivers/ata/pata_cs5530.c b/drivers/ata/pata_cs5530.c
index eaaea848b649..57e827e4109e 100644
--- a/drivers/ata/pata_cs5530.c
+++ b/drivers/ata/pata_cs5530.c
@@ -179,7 +179,6 @@ static struct scsi_host_template cs5530_sht = {
 };
 
 static struct ata_port_operations cs5530_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cs5530_set_piomode,
         .set_dmamode    = cs5530_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -209,9 +208,8 @@ static struct ata_port_operations cs5530_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static const struct dmi_system_id palmax_dmi_table[] = {
diff --git a/drivers/ata/pata_cs5535.c b/drivers/ata/pata_cs5535.c
index 360b6f32e17e..3578593a882b 100644
--- a/drivers/ata/pata_cs5535.c
+++ b/drivers/ata/pata_cs5535.c
@@ -176,7 +176,6 @@ static struct scsi_host_template cs5535_sht = {
 };
 
 static struct ata_port_operations cs5535_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cs5535_set_piomode,
         .set_dmamode    = cs5535_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -206,9 +205,8 @@ static struct ata_port_operations cs5535_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_cypress.c b/drivers/ata/pata_cypress.c
index 6cbc8778bf4f..fc5f9c4e5d87 100644
--- a/drivers/ata/pata_cypress.c
+++ b/drivers/ata/pata_cypress.c
@@ -128,7 +128,6 @@ static struct scsi_host_template cy82c693_sht = {
 };
 
 static struct ata_port_operations cy82c693_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = cy82c693_set_piomode,
         .set_dmamode    = cy82c693_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -158,9 +157,8 @@ static struct ata_port_operations cy82c693_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int cy82c693_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_efar.c b/drivers/ata/pata_efar.c
index c8ba59c56114..043dcd35106c 100644
--- a/drivers/ata/pata_efar.c
+++ b/drivers/ata/pata_efar.c
@@ -26,25 +26,26 @@
 
 /**
  *      efar_pre_reset  -       Enable bits
- *      @ap: Port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform cable detection for the EFAR ATA interface. This is
  *      different to the PIIX arrangement
  */
 
-static int efar_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int efar_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits efar_enable_bits[] = {
                 { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
                 { 0x43U, 1U, 0x80UL, 0x80UL },  /* port 1 */
         };
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &efar_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -250,7 +251,6 @@ static struct scsi_host_template efar_sht = {
 };
 
 static const struct ata_port_operations efar_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = efar_set_piomode,
         .set_dmamode            = efar_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -278,9 +278,8 @@ static const struct ata_port_operations efar_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_hpt366.c b/drivers/ata/pata_hpt366.c
index 6f7d34ad19ef..0713872cf65c 100644
--- a/drivers/ata/pata_hpt366.c
+++ b/drivers/ata/pata_hpt366.c
@@ -312,7 +312,6 @@ static struct scsi_host_template hpt36x_sht = {
  */
 
 static struct ata_port_operations hpt366_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt366_set_piomode,
         .set_dmamode    = hpt366_set_dmamode,
         .mode_filter    = hpt366_filter,
@@ -342,9 +341,8 @@ static struct ata_port_operations hpt366_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_hpt37x.c b/drivers/ata/pata_hpt37x.c
index c5ddd937dbf2..e61cb1fd57b2 100644
--- a/drivers/ata/pata_hpt37x.c
+++ b/drivers/ata/pata_hpt37x.c
@@ -304,15 +304,16 @@ static unsigned long hpt370a_filter(struct ata_device *adev, unsigned long mask)
 
 /**
  *      hpt37x_pre_reset        -       reset the hpt37x bus
- *      @ap: ATA port to reset
+ *      @link: ATA link to reset
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the initial reset handling for the 370/372 and 374 func 0
  */
 
-static int hpt37x_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int hpt37x_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         u8 scr2, ata66;
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits hpt37x_enable_bits[] = {
                 { 0x50, 1, 0x04, 0x04 },
@@ -337,7 +338,7 @@ static int hpt37x_pre_reset(struct ata_port *ap, unsigned long deadline)
         pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
         udelay(100);
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -352,7 +353,7 @@ static void hpt37x_error_handler(struct ata_port *ap)
         ata_bmdma_drive_eh(ap, hpt37x_pre_reset, ata_std_softreset, NULL, ata_std_postreset);
 }
 
-static int hpt374_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int hpt374_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits hpt37x_enable_bits[] = {
                 { 0x50, 1, 0x04, 0x04 },
@@ -360,6 +361,7 @@ static int hpt374_pre_reset(struct ata_port *ap, unsigned long deadline)
         };
         u16 mcr3, mcr6;
         u8 ata66;
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &hpt37x_enable_bits[ap->port_no]))
@@ -387,7 +389,7 @@ static int hpt374_pre_reset(struct ata_port *ap, unsigned long deadline)
         pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
         udelay(100);
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -642,7 +644,6 @@ static struct scsi_host_template hpt37x_sht = {
  */
 
 static struct ata_port_operations hpt370_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt370_set_piomode,
         .set_dmamode    = hpt370_set_dmamode,
         .mode_filter    = hpt370_filter,
@@ -671,9 +672,8 @@ static struct ata_port_operations hpt370_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
@@ -681,7 +681,6 @@ static struct ata_port_operations hpt370_port_ops = {
  */
 
 static struct ata_port_operations hpt370a_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt370_set_piomode,
         .set_dmamode    = hpt370_set_dmamode,
         .mode_filter    = hpt370a_filter,
@@ -710,9 +709,8 @@ static struct ata_port_operations hpt370a_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
@@ -721,7 +719,6 @@ static struct ata_port_operations hpt370a_port_ops = {
  */
 
 static struct ata_port_operations hpt372_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt372_set_piomode,
         .set_dmamode    = hpt372_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -750,9 +747,8 @@ static struct ata_port_operations hpt372_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /*
@@ -761,7 +757,6 @@ static struct ata_port_operations hpt372_port_ops = {
  */
 
 static struct ata_port_operations hpt374_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt372_set_piomode,
         .set_dmamode    = hpt372_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -790,9 +785,8 @@ static struct ata_port_operations hpt374_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_hpt3x2n.c b/drivers/ata/pata_hpt3x2n.c
index f8f234bfc8ce..9f1c084f846f 100644
--- a/drivers/ata/pata_hpt3x2n.c
+++ b/drivers/ata/pata_hpt3x2n.c
@@ -141,21 +141,22 @@ static int hpt3x2n_cable_detect(struct ata_port *ap)
 
 /**
  *      hpt3x2n_pre_reset       -       reset the hpt3x2n bus
- *      @ap: ATA port to reset
+ *      @link: ATA link to reset
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the initial reset handling for the 3x2n series controllers.
  *      Reset the hardware and state machine,
  */
 
-static int hpt3xn_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int hpt3xn_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         /* Reset the state machine */
         pci_write_config_byte(pdev, 0x50 + 4 * ap->port_no, 0x37);
         udelay(100);
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -360,7 +361,6 @@ static struct scsi_host_template hpt3x2n_sht = {
  */
 
 static struct ata_port_operations hpt3x2n_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt3x2n_set_piomode,
         .set_dmamode    = hpt3x2n_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -390,9 +390,8 @@ static struct ata_port_operations hpt3x2n_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_hpt3x3.c b/drivers/ata/pata_hpt3x3.c
index be0f05efac6d..cb8bdb6887de 100644
--- a/drivers/ata/pata_hpt3x3.c
+++ b/drivers/ata/pata_hpt3x3.c
@@ -120,7 +120,6 @@ static struct scsi_host_template hpt3x3_sht = {
 };
 
 static struct ata_port_operations hpt3x3_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = hpt3x3_set_piomode,
 #if defined(CONFIG_PATA_HPT3X3_DMA)
         .set_dmamode    = hpt3x3_set_dmamode,
@@ -153,9 +152,8 @@ static struct ata_port_operations hpt3x3_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
@@ -239,7 +237,8 @@ static int hpt3x3_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         base = host->iomap[4];  /* Bus mastering base */
 
         for (i = 0; i < host->n_ports; i++) {
-                struct ata_ioports *ioaddr = &host->ports[i]->ioaddr;
+                struct ata_port *ap = host->ports[i];
+                struct ata_ioports *ioaddr = &ap->ioaddr;
 
                 ioaddr->cmd_addr = base + offset_cmd[i];
                 ioaddr->altstatus_addr =
@@ -247,6 +246,9 @@ static int hpt3x3_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 ioaddr->scr_addr = NULL;
                 ata_std_ports(ioaddr);
                 ioaddr->bmdma_addr = base + 8 * i;
+
+                ata_port_pbar_desc(ap, 4, -1, "ioport");
+                ata_port_pbar_desc(ap, 4, offset_cmd[i], "cmd");
         }
         pci_set_master(pdev);
         return ata_host_activate(host, pdev->irq, ata_interrupt, IRQF_SHARED,
diff --git a/drivers/ata/pata_icside.c b/drivers/ata/pata_icside.c
index 64a711776c45..be30923566c5 100644
--- a/drivers/ata/pata_icside.c
+++ b/drivers/ata/pata_icside.c
@@ -70,6 +70,8 @@ struct pata_icside_info {
         unsigned int            mwdma_mask;
         unsigned int            nr_ports;
         const struct portinfo   *port[2];
+        unsigned long           raw_base;
+        unsigned long           raw_ioc_base;
 };
 
 #define ICS_TYPE_A3IN   0
@@ -357,26 +359,7 @@ static void pata_icside_error_handler(struct ata_port *ap)
                            pata_icside_postreset);
 }
 
-static u8 pata_icside_irq_ack(struct ata_port *ap, unsigned int chk_drq)
-{
-        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
-        u8 status;
-
-        status = ata_busy_wait(ap, bits, 1000);
-        if (status & bits)
-                if (ata_msg_err(ap))
-                        printk(KERN_ERR "abnormal status 0x%X\n", status);
-
-        if (ata_msg_intr(ap))
-                printk(KERN_INFO "%s: irq ack: drv_stat 0x%X\n",
-                        __FUNCTION__, status);
-
-        return status;
-}
-
 static struct ata_port_operations pata_icside_port_ops = {
-        .port_disable           = ata_port_disable,
-
         .set_dmamode            = pata_icside_set_dmamode,
 
         .tf_load                = ata_tf_load,
@@ -403,7 +386,6 @@ static struct ata_port_operations pata_icside_port_ops = {
 
         .irq_clear              = ata_dummy_noret,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = pata_icside_irq_ack,
 
         .port_start             = pata_icside_port_start,
 
@@ -412,9 +394,10 @@ static struct ata_port_operations pata_icside_port_ops = {
 };
 
 static void __devinit
-pata_icside_setup_ioaddr(struct ata_ioports *ioaddr, void __iomem *base,
+pata_icside_setup_ioaddr(struct ata_port *ap, void __iomem *base,
                          const struct portinfo *info)
 {
+        struct ata_ioports *ioaddr = &ap->ioaddr;
         void __iomem *cmd = base + info->dataoffset;
 
         ioaddr->cmd_addr        = cmd;
@@ -431,6 +414,13 @@ pata_icside_setup_ioaddr(struct ata_ioports *ioaddr, void __iomem *base,
 
         ioaddr->ctl_addr        = base + info->ctrloffset;
         ioaddr->altstatus_addr  = ioaddr->ctl_addr;
+
+        ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx",
+                      info->raw_base + info->dataoffset,
+                      info->raw_base + info->ctrloffset);
+
+        if (info->raw_ioc_base)
+                ata_port_desc(ap, "iocbase 0x%lx", info->raw_ioc_base);
 }
 
 static int __devinit pata_icside_register_v5(struct pata_icside_info *info)
@@ -451,6 +441,8 @@ static int __devinit pata_icside_register_v5(struct pata_icside_info *info)
         info->nr_ports = 1;
         info->port[0] = &pata_icside_portinfo_v5;
 
+        info->raw_base = ecard_resource_start(ec, ECARD_RES_MEMC);
+
         return 0;
 }
 
@@ -491,6 +483,9 @@ static int __devinit pata_icside_register_v6(struct pata_icside_info *info)
         info->port[0] = &pata_icside_portinfo_v6_1;
         info->port[1] = &pata_icside_portinfo_v6_2;
 
+        info->raw_base = ecard_resource_start(ec, ECARD_RES_EASI);
+        info->raw_ioc_base = ecard_resource_start(ec, ECARD_RES_IOCFAST);
+
         return icside_dma_init(info);
 }
 
@@ -527,7 +522,7 @@ static int __devinit pata_icside_add_ports(struct pata_icside_info *info)
                 ap->flags |= ATA_FLAG_SLAVE_POSS;
                 ap->ops = &pata_icside_port_ops;
 
-                pata_icside_setup_ioaddr(&ap->ioaddr, info->base, info->port[i]);
+                pata_icside_setup_ioaddr(ap, info->base, info->port[i]);
         }
 
         return ata_host_activate(host, ec->irq, ata_interrupt, 0,
diff --git a/drivers/ata/pata_isapnp.c b/drivers/ata/pata_isapnp.c
index 9e553c54203a..88ab0e1d353f 100644
--- a/drivers/ata/pata_isapnp.c
+++ b/drivers/ata/pata_isapnp.c
@@ -38,7 +38,6 @@ static struct scsi_host_template isapnp_sht = {
 };
 
 static struct ata_port_operations isapnp_port_ops = {
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -58,9 +57,8 @@ static struct ata_port_operations isapnp_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
@@ -112,6 +110,10 @@ static int isapnp_init_one(struct pnp_dev *idev, const struct pnp_device_id *dev
 
         ata_std_ports(&ap->ioaddr);
 
+        ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
+                      (unsigned long long)pnp_port_start(idev, 0),
+                      (unsigned long long)pnp_port_start(idev, 1));
+
         /* activate */
         return ata_host_activate(host, pnp_irq(idev, 0), ata_interrupt, 0,
                                  &isapnp_sht);
diff --git a/drivers/ata/pata_it8213.c b/drivers/ata/pata_it8213.c
index b8af55e89156..1eda821e5e39 100644
--- a/drivers/ata/pata_it8213.c
+++ b/drivers/ata/pata_it8213.c
@@ -23,23 +23,24 @@
 
 /**
  *      it8213_pre_reset        -       check for 40/80 pin
- *      @ap: Port
+ *      @link: link
  *      @deadline: deadline jiffies for the operation
  *
  *      Filter out ports by the enable bits before doing the normal reset
  *      and probe.
  */
 
-static int it8213_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int it8213_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits it8213_enable_bits[] = {
                 { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
         };
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         if (!pci_test_config_bits(pdev, &it8213_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -260,7 +261,6 @@ static struct scsi_host_template it8213_sht = {
 };
 
 static const struct ata_port_operations it8213_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = it8213_set_piomode,
         .set_dmamode            = it8213_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -288,9 +288,8 @@ static const struct ata_port_operations it8213_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_it821x.c b/drivers/ata/pata_it821x.c
index 5d8b91e70ecd..988ef736b936 100644
--- a/drivers/ata/pata_it821x.c
+++ b/drivers/ata/pata_it821x.c
@@ -391,7 +391,7 @@ static void it821x_passthru_dev_select(struct ata_port *ap,
 {
         struct it821x_dev *itdev = ap->private_data;
         if (itdev && device != itdev->last_device) {
-                struct ata_device *adev = &ap->device[device];
+                struct ata_device *adev = &ap->link.device[device];
                 it821x_program(ap, adev, itdev->pio[adev->devno]);
                 itdev->last_device = device;
         }
@@ -450,7 +450,7 @@ static unsigned int it821x_passthru_qc_issue_prot(struct ata_queued_cmd *qc)
 
 /**
  *      it821x_smart_set_mode   -       mode setting
- *      @ap: interface to set up
+ *      @link: interface to set up
  *      @unused: device that failed (error only)
  *
  *      Use a non standard set_mode function. We don't want to be tuned.
@@ -459,12 +459,11 @@ static unsigned int it821x_passthru_qc_issue_prot(struct ata_queued_cmd *qc)
  *      and respect them.
  */
 
-static int it821x_smart_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int it821x_smart_set_mode(struct ata_link *link, struct ata_device **unused)
 {
-        int i;
+        struct ata_device *dev;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         /* We don't really care */
                         dev->pio_mode = XFER_PIO_0;
@@ -564,7 +563,7 @@ static int it821x_port_start(struct ata_port *ap)
         struct it821x_dev *itdev;
         u8 conf;
 
-        int ret = ata_port_start(ap);
+        int ret = ata_sff_port_start(ap);
         if (ret < 0)
                 return ret;
 
@@ -621,7 +620,6 @@ static struct scsi_host_template it821x_sht = {
 
 static struct ata_port_operations it821x_smart_port_ops = {
         .set_mode       = it821x_smart_set_mode,
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .mode_filter    = ata_pci_default_filter,
@@ -651,13 +649,11 @@ static struct ata_port_operations it821x_smart_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = it821x_port_start,
 };
 
 static struct ata_port_operations it821x_passthru_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = it821x_passthru_set_piomode,
         .set_dmamode    = it821x_passthru_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -688,7 +684,6 @@ static struct ata_port_operations it821x_passthru_port_ops = {
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_handler    = ata_interrupt,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = it821x_port_start,
 };
diff --git a/drivers/ata/pata_ixp4xx_cf.c b/drivers/ata/pata_ixp4xx_cf.c
index 5dea3584c6c2..fcd532afbf2e 100644
--- a/drivers/ata/pata_ixp4xx_cf.c
+++ b/drivers/ata/pata_ixp4xx_cf.c
@@ -26,12 +26,11 @@
 #define DRV_NAME        "pata_ixp4xx_cf"
 #define DRV_VERSION     "0.2"
 
-static int ixp4xx_set_mode(struct ata_port *ap, struct ata_device **error)
+static int ixp4xx_set_mode(struct ata_link *link, struct ata_device **error)
 {
-        int i;
+        struct ata_device *dev;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         ata_dev_printk(dev, KERN_INFO, "configured for PIO0\n");
                         dev->pio_mode = XFER_PIO_0;
@@ -49,7 +48,7 @@ static void ixp4xx_mmio_data_xfer(struct ata_device *adev, unsigned char *buf,
         unsigned int i;
         unsigned int words = buflen >> 1;
         u16 *buf16 = (u16 *) buf;
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         void __iomem *mmio = ap->ioaddr.data_addr;
         struct ixp4xx_pata_data *data = ap->host->dev->platform_data;
 
@@ -108,7 +107,6 @@ static struct ata_port_operations ixp4xx_port_ops = {
         .set_mode               = ixp4xx_set_mode,
         .mode_filter            = ata_pci_default_filter,
 
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
@@ -128,14 +126,17 @@ static struct ata_port_operations ixp4xx_port_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_dummy_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static void ixp4xx_setup_port(struct ata_ioports *ioaddr,
-                                struct ixp4xx_pata_data *data)
+                              struct ixp4xx_pata_data *data,
+                              unsigned long raw_cs0, unsigned long raw_cs1)
 {
+        unsigned long raw_cmd = raw_cs0;
+        unsigned long raw_ctl = raw_cs1 + 0x06;
+
         ioaddr->cmd_addr        = data->cs0;
         ioaddr->altstatus_addr  = data->cs1 + 0x06;
         ioaddr->ctl_addr        = data->cs1 + 0x06;
@@ -161,7 +162,12 @@ static void ixp4xx_setup_port(struct ata_ioports *ioaddr,
         *(unsigned long *)&ioaddr->device_addr          ^= 0x03;
         *(unsigned long *)&ioaddr->status_addr          ^= 0x03;
         *(unsigned long *)&ioaddr->command_addr         ^= 0x03;
+
+        raw_cmd ^= 0x03;
+        raw_ctl ^= 0x03;
 #endif
+
+        ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", raw_cmd, raw_ctl);
 }
 
 static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
@@ -206,7 +212,7 @@ static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
         ap->pio_mask = 0x1f; /* PIO4 */
         ap->flags |= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY | ATA_FLAG_NO_ATAPI;
 
-        ixp4xx_setup_port(&ap->ioaddr, data);
+        ixp4xx_setup_port(ap, data, cs0->start, cs1->start);
 
         dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
 
diff --git a/drivers/ata/pata_jmicron.c b/drivers/ata/pata_jmicron.c
index 4d67f238eee2..225a7223a726 100644
--- a/drivers/ata/pata_jmicron.c
+++ b/drivers/ata/pata_jmicron.c
@@ -29,7 +29,7 @@ typedef enum {
 
 /**
  *      jmicron_pre_reset       -       check for 40/80 pin
- *      @ap: Port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the PATA port setup we need.
@@ -39,9 +39,9 @@ typedef enum {
  *      and setup here. We assume that has been done by init_one and the
  *      BIOS.
  */
-
-static int jmicron_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int jmicron_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         u32 control;
         u32 control5;
@@ -103,7 +103,7 @@ static int jmicron_pre_reset(struct ata_port *ap, unsigned long deadline)
                 ap->cbl = ATA_CBL_SATA;
                 break;
         }
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -141,8 +141,6 @@ static struct scsi_host_template jmicron_sht = {
 };
 
 static const struct ata_port_operations jmicron_ops = {
-        .port_disable           = ata_port_disable,
-
         /* Task file is PCI ATA format, use helpers */
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
@@ -168,7 +166,6 @@ static const struct ata_port_operations jmicron_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         /* Generic PATA PCI ATA helpers */
         .port_start             = ata_port_start,
@@ -207,17 +204,8 @@ static int jmicron_init_one (struct pci_dev *pdev, const struct pci_device_id *i
 }
 
 static const struct pci_device_id jmicron_pci_tbl[] = {
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB361,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 361 },
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB363,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 363 },
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB365,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 365 },
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB366,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 366 },
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB368,
-          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 368 },
-
+        { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
+          PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 0 },
         { }     /* terminate list */
 };
 
diff --git a/drivers/ata/pata_legacy.c b/drivers/ata/pata_legacy.c
index edffc25d2d3f..7bed8d806381 100644
--- a/drivers/ata/pata_legacy.c
+++ b/drivers/ata/pata_legacy.c
@@ -96,7 +96,7 @@ static int iordy_mask = 0xFFFFFFFF;	/* Use iordy if available */
 
 /**
  *      legacy_set_mode         -       mode setting
- *      @ap: IDE interface
+ *      @link: IDE link
  *      @unused: Device that failed when error is returned
  *
  *      Use a non standard set_mode function. We don't want to be tuned.
@@ -107,12 +107,11 @@ static int iordy_mask = 0xFFFFFFFF;	/* Use iordy if available */
  *      expand on this as per hdparm in the base kernel.
  */
 
-static int legacy_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int legacy_set_mode(struct ata_link *link, struct ata_device **unused)
 {
-        int i;
+        struct ata_device *dev;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
                         dev->pio_mode = XFER_PIO_0;
@@ -151,7 +150,6 @@ static struct scsi_host_template legacy_sht = {
  */
 
 static struct ata_port_operations simple_port_ops = {
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -172,7 +170,6 @@ static struct ata_port_operations simple_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -180,7 +177,6 @@ static struct ata_port_operations simple_port_ops = {
 static struct ata_port_operations legacy_port_ops = {
         .set_mode       = legacy_set_mode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -201,7 +197,6 @@ static struct ata_port_operations legacy_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -256,7 +251,7 @@ static void pdc20230_set_piomode(struct ata_port *ap, struct ata_device *adev)
 
 static void pdc_data_xfer_vlb(struct ata_device *adev, unsigned char *buf, unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         int slop = buflen & 3;
         unsigned long flags;
 
@@ -296,7 +291,6 @@ static void pdc_data_xfer_vlb(struct ata_device *adev, unsigned char *buf, unsig
 static struct ata_port_operations pdc20230_port_ops = {
         .set_piomode    = pdc20230_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -317,7 +311,6 @@ static struct ata_port_operations pdc20230_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -352,7 +345,6 @@ static void ht6560a_set_piomode(struct ata_port *ap, struct ata_device *adev)
 static struct ata_port_operations ht6560a_port_ops = {
         .set_piomode    = ht6560a_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -373,7 +365,6 @@ static struct ata_port_operations ht6560a_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -419,7 +410,6 @@ static void ht6560b_set_piomode(struct ata_port *ap, struct ata_device *adev)
 static struct ata_port_operations ht6560b_port_ops = {
         .set_piomode    = ht6560b_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -440,7 +430,6 @@ static struct ata_port_operations ht6560b_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -541,7 +530,6 @@ static void opti82c611a_set_piomode(struct ata_port *ap, struct ata_device *adev
 static struct ata_port_operations opti82c611a_port_ops = {
         .set_piomode    = opti82c611a_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -562,7 +550,6 @@ static struct ata_port_operations opti82c611a_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -675,7 +662,6 @@ static unsigned int opti82c46x_qc_issue_prot(struct ata_queued_cmd *qc)
 static struct ata_port_operations opti82c46x_port_ops = {
         .set_piomode    = opti82c46x_set_piomode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -696,7 +682,6 @@ static struct ata_port_operations opti82c46x_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_port_start,
 };
@@ -814,6 +799,8 @@ static __init int legacy_init_one(int port, unsigned long io, unsigned long ctrl
         ata_std_ports(&ap->ioaddr);
         ap->private_data = ld;
 
+        ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", io, ctrl);
+
         ret = ata_host_activate(host, irq, ata_interrupt, 0, &legacy_sht);
         if (ret)
                 goto fail;
diff --git a/drivers/ata/pata_marvell.c b/drivers/ata/pata_marvell.c
index b45506f1ef73..9afc8a32b226 100644
--- a/drivers/ata/pata_marvell.c
+++ b/drivers/ata/pata_marvell.c
@@ -24,14 +24,15 @@
 
 /**
  *      marvell_pre_reset       -       check for 40/80 pin
- *      @ap: Port
+ *      @link: link
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the PATA port setup we need.
  */
 
-static int marvell_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int marvell_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         u32 devices;
         void __iomem *barp;
@@ -54,7 +55,7 @@ static int marvell_pre_reset(struct ata_port *ap, unsigned long deadline)
             (!(devices & 0x10)))        /* PATA enable ? */
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 static int marvell_cable_detect(struct ata_port *ap)
@@ -110,8 +111,6 @@ static struct scsi_host_template marvell_sht = {
 };
 
 static const struct ata_port_operations marvell_ops = {
-        .port_disable           = ata_port_disable,
-
         /* Task file is PCI ATA format, use helpers */
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
@@ -138,10 +137,9 @@ static const struct ata_port_operations marvell_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         /* Generic PATA PCI ATA helpers */
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_mpc52xx.c b/drivers/ata/pata_mpc52xx.c
index 099f4cdc4cd9..412140f02853 100644
--- a/drivers/ata/pata_mpc52xx.c
+++ b/drivers/ata/pata_mpc52xx.c
@@ -283,7 +283,6 @@ static struct scsi_host_template mpc52xx_ata_sht = {
 };
 
 static struct ata_port_operations mpc52xx_ata_port_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = mpc52xx_ata_set_piomode,
         .dev_select             = mpc52xx_ata_dev_select,
         .tf_load                = ata_tf_load,
@@ -299,12 +298,12 @@ static struct ata_port_operations mpc52xx_ata_port_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .port_start             = ata_port_start,
 };
 
 static int __devinit
-mpc52xx_ata_init_one(struct device *dev, struct mpc52xx_ata_priv *priv)
+mpc52xx_ata_init_one(struct device *dev, struct mpc52xx_ata_priv *priv,
+                     unsigned long raw_ata_regs)
 {
         struct ata_host *host;
         struct ata_port *ap;
@@ -338,6 +337,8 @@ mpc52xx_ata_init_one(struct device *dev, struct mpc52xx_ata_priv *priv)
         aio->status_addr        = &priv->ata_regs->tf_command;
         aio->command_addr       = &priv->ata_regs->tf_command;
 
+        ata_port_desc(ap, "ata_regs 0x%lx", raw_ata_regs);
+
         /* activate host */
         return ata_host_activate(host, priv->ata_irq, ata_interrupt, 0,
                                  &mpc52xx_ata_sht);
@@ -434,7 +435,7 @@ mpc52xx_ata_probe(struct of_device *op, const struct of_device_id *match)
         }
 
         /* Register ourselves to libata */
-        rv = mpc52xx_ata_init_one(&op->dev, priv);
+        rv = mpc52xx_ata_init_one(&op->dev, priv, res_mem.start);
         if (rv) {
                 printk(KERN_ERR DRV_NAME ": "
                         "Error while registering to ATA layer\n");
diff --git a/drivers/ata/pata_mpiix.c b/drivers/ata/pata_mpiix.c
index 4ea42838297e..d5483087a3fa 100644
--- a/drivers/ata/pata_mpiix.c
+++ b/drivers/ata/pata_mpiix.c
@@ -46,15 +46,16 @@ enum {
         SECONDARY = (1 << 14)
 };
 
-static int mpiix_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int mpiix_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits mpiix_enable_bits = { 0x6D, 1, 0x80, 0x80 };
 
         if (!pci_test_config_bits(pdev, &mpiix_enable_bits))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -168,7 +169,6 @@ static struct scsi_host_template mpiix_sht = {
 };
 
 static struct ata_port_operations mpiix_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = mpiix_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -189,9 +189,8 @@ static struct ata_port_operations mpiix_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
@@ -202,7 +201,7 @@ static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         struct ata_port *ap;
         void __iomem *cmd_addr, *ctl_addr;
         u16 idetim;
-        int irq;
+        int cmd, ctl, irq;
 
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &dev->dev, "version " DRV_VERSION "\n");
@@ -210,6 +209,7 @@ static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         host = ata_host_alloc(&dev->dev, 1);
         if (!host)
                 return -ENOMEM;
+        ap = host->ports[0];
 
         /* MPIIX has many functions which can be turned on or off according
            to other devices present. Make sure IDE is enabled before we try
@@ -221,25 +221,28 @@ static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 
         /* See if it's primary or secondary channel... */
         if (!(idetim & SECONDARY)) {
+                cmd = 0x1F0;
+                ctl = 0x3F6;
                 irq = 14;
-                cmd_addr = devm_ioport_map(&dev->dev, 0x1F0, 8);
-                ctl_addr = devm_ioport_map(&dev->dev, 0x3F6, 1);
         } else {
+                cmd = 0x170;
+                ctl = 0x376;
                 irq = 15;
-                cmd_addr = devm_ioport_map(&dev->dev, 0x170, 8);
-                ctl_addr = devm_ioport_map(&dev->dev, 0x376, 1);
         }
 
+        cmd_addr = devm_ioport_map(&dev->dev, cmd, 8);
+        ctl_addr = devm_ioport_map(&dev->dev, ctl, 1);
         if (!cmd_addr || !ctl_addr)
                 return -ENOMEM;
 
+        ata_port_desc(ap, "cmd 0x%x ctl 0x%x", cmd, ctl);
+
         /* We do our own plumbing to avoid leaking special cases for whacko
            ancient hardware into the core code. There are two issues to
            worry about.  #1 The chip is a bridge so if in legacy mode and
            without BARs set fools the setup.  #2 If you pci_disable_device
            the MPIIX your box goes castors up */
 
-        ap = host->ports[0];
         ap->ops = &mpiix_port_ops;
         ap->pio_mask = 0x1F;
         ap->flags |= ATA_FLAG_SLAVE_POSS;
diff --git a/drivers/ata/pata_netcell.c b/drivers/ata/pata_netcell.c
index 40eb574828bf..25c922abd554 100644
--- a/drivers/ata/pata_netcell.c
+++ b/drivers/ata/pata_netcell.c
@@ -40,8 +40,6 @@ static struct scsi_host_template netcell_sht = {
 };
 
 static const struct ata_port_operations netcell_ops = {
-        .port_disable           = ata_port_disable,
-
         /* Task file is PCI ATA format, use helpers */
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
@@ -68,10 +66,9 @@ static const struct ata_port_operations netcell_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         /* Generic PATA PCI ATA helpers */
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_ns87410.c b/drivers/ata/pata_ns87410.c
index 2f5d714ebfc4..6e8e55745b7b 100644
--- a/drivers/ata/pata_ns87410.c
+++ b/drivers/ata/pata_ns87410.c
@@ -32,14 +32,15 @@
 
 /**
  *      ns87410_pre_reset               -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Check enabled ports
  */
 
-static int ns87410_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int ns87410_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits ns87410_enable_bits[] = {
                 { 0x43, 1, 0x08, 0x08 },
@@ -49,7 +50,7 @@ static int ns87410_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &ns87410_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -161,7 +162,6 @@ static struct scsi_host_template ns87410_sht = {
 };
 
 static struct ata_port_operations ns87410_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = ns87410_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -184,9 +184,8 @@ static struct ata_port_operations ns87410_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int ns87410_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_ns87415.c b/drivers/ata/pata_ns87415.c
new file mode 100644
index 000000000000..bb97ef583f9b
--- /dev/null
+++ b/drivers/ata/pata_ns87415.c
@@ -0,0 +1,467 @@
+/*
+ *    pata_ns87415.c - NS87415 (non PARISC) PATA
+ *
+ *      (C) 2005 Red Hat <alan@redhat.com>
+ *
+ *    This is a fairly generic MWDMA controller. It has some limitations
+ *    as it requires timing reloads on PIO/DMA transitions but it is otherwise
+ *    fairly well designed.
+ *
+ *    This driver assumes the firmware has left the chip in a valid ST506
+ *    compliant state, either legacy IRQ 14/15 or native INTA shared. You
+ *    may need to add platform code if your system fails to do this.
+ *
+ *    The same cell appears in the 87560 controller used by some PARISC
+ *    systems. This has its own special mountain of errata.
+ *
+ *    TODO:
+ *      Test PARISC SuperIO
+ *      Get someone to test on SPARC
+ *      Implement lazy pio/dma switching for better performance 
+ *      8bit shared timing.
+ *      See if we need to kill the FIFO for ATAPI
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <scsi/scsi_host.h>
+#include <linux/libata.h>
+#include <linux/ata.h>
+
+#define DRV_NAME        "pata_ns87415"
+#define DRV_VERSION     "0.0.1"
+
+/**
+ *      ns87415_set_mode - Initialize host controller mode timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: Device whose timings we are configuring
+ *      @mode: Mode to set
+ *
+ *      Program the mode registers for this controller, channel and
+ *      device. Because the chip is quite an old design we have to do this
+ *      for PIO/DMA switches.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void ns87415_set_mode(struct ata_port *ap, struct ata_device *adev, u8 mode)
+{
+        struct pci_dev *dev     = to_pci_dev(ap->host->dev);
+        int unit                = 2 * ap->port_no + adev->devno;
+        int timing              = 0x44 + 2 * unit;
+        unsigned long T         = 1000000000 / 33333;   /* PCI clocks */
+        struct ata_timing t;
+        u16 clocking;
+        u8 iordy;
+        u8 status;
+        
+        /* Timing register format is 17 - low nybble read timing with
+           the high nybble being 16 - x for recovery time in PCI clocks */
+   
+        ata_timing_compute(adev, adev->pio_mode, &t, T, 0);
+
+        clocking = 17 - FIT(t.active, 2, 17);
+        clocking |= (16 - FIT(t.recover, 1, 16)) << 4;
+        /* Use the same timing for read and write bytes */
+        clocking |= (clocking << 8);
+        pci_write_config_word(dev, timing, clocking);
+        
+        /* Set the IORDY enable versus DMA enable on or off properly */
+        pci_read_config_byte(dev, 0x42, &iordy);
+        iordy &= ~(1 << (4 + unit));
+        if (mode >= XFER_MW_DMA_0 || !ata_pio_need_iordy(adev))
+                iordy |= (1 << (4 + unit));
+
+        /* Paranoia: We shouldn't ever get here with busy write buffers
+           but if so wait */
+
+        pci_read_config_byte(dev, 0x43, &status);
+        while (status & 0x03) {
+                udelay(1);
+                pci_read_config_byte(dev, 0x43, &status);
+        }
+        /* Flip the IORDY/DMA bits now we are sure the write buffers are
+           clear */
+        pci_write_config_byte(dev, 0x42, iordy);
+
+        /* TODO: Set byte 54 command timing to the best 8bit
+           mode shared by all four devices */
+}
+
+/**
+ *      ns87415_set_piomode - Initialize host controller PATA PIO timings
+ *      @ap: Port whose timings we are configuring
+ *      @adev: Device to program
+ *
+ *      Set PIO mode for device, in host controller PCI config space.
+ *
+ *      LOCKING:
+ *      None (inherited from caller).
+ */
+
+static void ns87415_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        ns87415_set_mode(ap, adev, adev->pio_mode);
+}
+
+/**
+ *      ns87415_bmdma_setup             -       Set up DMA
+ *      @qc: Command block
+ *
+ *      Set up for bus masterng DMA. We have to do this ourselves
+ *      rather than use the helper due to a chip erratum
+ */
+
+static void ns87415_bmdma_setup(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
+        u8 dmactl;
+
+        /* load PRD table addr. */
+        mb();   /* make sure PRD table writes are visible to controller */
+        iowrite32(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
+
+        /* specify data direction, triple-check start bit is clear */
+        dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
+        dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
+        /* Due to an erratum we need to write these bits to the wrong
+           place - which does save us an I/O bizarrely */
+        dmactl |= ATA_DMA_INTR | ATA_DMA_ERR;
+        if (!rw)
+                dmactl |= ATA_DMA_WR;
+        iowrite8(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
+        /* issue r/w command */
+        ap->ops->exec_command(ap, &qc->tf);
+}
+
+/**
+ *      ns87415_bmdma_start             -       Begin DMA transfer
+ *      @qc: Command block
+ *
+ *      Switch the timings for the chip and set up for a DMA transfer
+ *      before the DMA burst begins.
+ *
+ *      FIXME: We should do lazy switching on bmdma_start versus
+ *      ata_pio_data_xfer for better performance.
+ */
+
+static void ns87415_bmdma_start(struct ata_queued_cmd *qc)
+{
+        ns87415_set_mode(qc->ap, qc->dev, qc->dev->dma_mode);
+        ata_bmdma_start(qc);
+}
+
+/**
+ *      ns87415_bmdma_stop              -       End DMA transfer
+ *      @qc: Command block
+ *
+ *      End DMA mode and switch the controller back into PIO mode
+ */
+
+static void ns87415_bmdma_stop(struct ata_queued_cmd *qc)
+{
+        ata_bmdma_stop(qc);
+        ns87415_set_mode(qc->ap, qc->dev, qc->dev->pio_mode);
+}
+
+/**
+ *      ns87415_bmdma_irq_clear         -       Clear interrupt
+ *      @ap: Channel to clear
+ *
+ *      Erratum: Due to a chip bug regisers 02 and 0A bit 1 and 2 (the
+ *      error bits) are reset by writing to register 00 or 08.
+ */
+
+static void ns87415_bmdma_irq_clear(struct ata_port *ap)
+{
+        void __iomem *mmio = ap->ioaddr.bmdma_addr;
+
+        if (!mmio)
+                return;
+        iowrite8((ioread8(mmio + ATA_DMA_CMD) | ATA_DMA_INTR | ATA_DMA_ERR), 
+                        mmio + ATA_DMA_CMD);
+}
+
+/**
+ *      ns87415_check_atapi_dma         -       ATAPI DMA filter
+ *      @qc: Command block
+ *
+ *      Disable ATAPI DMA (for now). We may be able to do DMA if we
+ *      kill the prefetching. This isn't clear.
+ */
+
+static int ns87415_check_atapi_dma(struct ata_queued_cmd *qc)
+{
+        return -EOPNOTSUPP;
+}
+
+#if defined(CONFIG_SUPERIO)
+
+/* SUPERIO 87560 is a PoS chip that NatSem denies exists.
+ * Unfortunately, it's built-in on all Astro-based PA-RISC workstations
+ * which use the integrated NS87514 cell for CD-ROM support.
+ * i.e we have to support for CD-ROM installs.
+ * See drivers/parisc/superio.c for more gory details.
+ *
+ * Workarounds taken from drivers/ide/pci/ns87415.c
+ */
+
+#include <asm/superio.h>
+
+/**
+ *      ns87560_read_buggy      -       workaround buggy Super I/O chip
+ *      @port: Port to read
+ *
+ *      Work around chipset problems in the 87560 SuperIO chip
+ */
+
+static u8 ns87560_read_buggy(void __iomem *port)
+{
+        u8 tmp;
+        int retries = SUPERIO_IDE_MAX_RETRIES;
+        do {
+                tmp = ioread8(port);
+                if (tmp != 0)
+                        return tmp;
+                udelay(50);
+        } while(retries-- > 0);
+        return tmp;
+}
+
+/**
+ *      ns87560_check_status
+ *      @ap: channel to check
+ *
+ *      Return the status of the channel working around the
+ *      87560 flaws.
+ */
+
+static u8 ns87560_check_status(struct ata_port *ap)
+{
+        return ns87560_read_buggy(ap->ioaddr.status_addr);
+}
+
+/**
+ *      ns87560_tf_read - input device's ATA taskfile shadow registers
+ *      @ap: Port from which input is read
+ *      @tf: ATA taskfile register set for storing input
+ *
+ *      Reads ATA taskfile registers for currently-selected device
+ *      into @tf. Work around the 87560 bugs.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
+void ns87560_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
+{
+        struct ata_ioports *ioaddr = &ap->ioaddr;
+
+        tf->command = ns87560_check_status(ap);
+        tf->feature = ioread8(ioaddr->error_addr);
+        tf->nsect = ioread8(ioaddr->nsect_addr);
+        tf->lbal = ioread8(ioaddr->lbal_addr);
+        tf->lbam = ioread8(ioaddr->lbam_addr);
+        tf->lbah = ioread8(ioaddr->lbah_addr);
+        tf->device = ns87560_read_buggy(ioaddr->device_addr);
+
+        if (tf->flags & ATA_TFLAG_LBA48) {
+                iowrite8(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
+                tf->hob_feature = ioread8(ioaddr->error_addr);
+                tf->hob_nsect = ioread8(ioaddr->nsect_addr);
+                tf->hob_lbal = ioread8(ioaddr->lbal_addr);
+                tf->hob_lbam = ioread8(ioaddr->lbam_addr);
+                tf->hob_lbah = ioread8(ioaddr->lbah_addr);
+                iowrite8(tf->ctl, ioaddr->ctl_addr);
+                ap->last_ctl = tf->ctl;
+        }
+}
+
+/**
+ *      ns87560_bmdma_status
+ *      @ap: channel to check
+ *
+ *      Return the DMA status of the channel working around the
+ *      87560 flaws.
+ */
+
+static u8 ns87560_bmdma_status(struct ata_port *ap)
+{
+        return ns87560_read_buggy(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
+}
+
+static const struct ata_port_operations ns87560_pata_ops = {
+        .set_piomode            = ns87415_set_piomode,
+        .mode_filter            = ata_pci_default_filter,
+
+        .tf_load                = ata_tf_load,
+        .tf_read                = ns87560_tf_read,
+        .check_status           = ns87560_check_status,
+        .check_atapi_dma        = ns87415_check_atapi_dma,
+        .exec_command           = ata_exec_command,
+        .dev_select             = ata_std_dev_select,
+
+        .freeze                 = ata_bmdma_freeze,
+        .thaw                   = ata_bmdma_thaw,
+        .error_handler          = ata_bmdma_error_handler,
+        .post_internal_cmd      = ata_bmdma_post_internal_cmd,
+        .cable_detect           = ata_cable_40wire,
+
+        .bmdma_setup            = ns87415_bmdma_setup,
+        .bmdma_start            = ns87415_bmdma_start,
+        .bmdma_stop             = ns87415_bmdma_stop,
+        .bmdma_status           = ns87560_bmdma_status,
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+        .data_xfer              = ata_data_xfer,
+
+        .irq_handler            = ata_interrupt,
+        .irq_clear              = ns87415_bmdma_irq_clear,
+        .irq_on                 = ata_irq_on,
+
+        .port_start             = ata_sff_port_start,
+};
+
+#endif          /* 87560 SuperIO Support */
+
+
+static const struct ata_port_operations ns87415_pata_ops = {
+        .set_piomode            = ns87415_set_piomode,
+        .mode_filter            = ata_pci_default_filter,
+
+        .tf_load                = ata_tf_load,
+        .tf_read                = ata_tf_read,
+        .check_status           = ata_check_status,
+        .check_atapi_dma        = ns87415_check_atapi_dma,
+        .exec_command           = ata_exec_command,
+        .dev_select             = ata_std_dev_select,
+
+        .freeze                 = ata_bmdma_freeze,
+        .thaw                   = ata_bmdma_thaw,
+        .error_handler          = ata_bmdma_error_handler,
+        .post_internal_cmd      = ata_bmdma_post_internal_cmd,
+        .cable_detect           = ata_cable_40wire,
+
+        .bmdma_setup            = ns87415_bmdma_setup,
+        .bmdma_start            = ns87415_bmdma_start,
+        .bmdma_stop             = ns87415_bmdma_stop,
+        .bmdma_status           = ata_bmdma_status,
+        .qc_prep                = ata_qc_prep,
+        .qc_issue               = ata_qc_issue_prot,
+        .data_xfer              = ata_data_xfer,
+
+        .irq_handler            = ata_interrupt,
+        .irq_clear              = ns87415_bmdma_irq_clear,
+        .irq_on                 = ata_irq_on,
+
+        .port_start             = ata_sff_port_start,
+};
+
+static struct scsi_host_template ns87415_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .ioctl                  = ata_scsi_ioctl,
+        .queuecommand           = ata_scsi_queuecmd,
+        .can_queue              = ATA_DEF_QUEUE,
+        .this_id                = ATA_SHT_THIS_ID,
+        .sg_tablesize           = LIBATA_MAX_PRD,
+        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
+        .emulated               = ATA_SHT_EMULATED,
+        .use_clustering         = ATA_SHT_USE_CLUSTERING,
+        .proc_name              = DRV_NAME,
+        .dma_boundary           = ATA_DMA_BOUNDARY,
+        .slave_configure        = ata_scsi_slave_config,
+        .slave_destroy          = ata_scsi_slave_destroy,
+        .bios_param             = ata_std_bios_param,
+};
+
+
+/**
+ *      ns87415_init_one - Register 87415 ATA PCI device with kernel services
+ *      @pdev: PCI device to register
+ *      @ent: Entry in ns87415_pci_tbl matching with @pdev
+ *
+ *      Called from kernel PCI layer.  We probe for combined mode (sigh),
+ *      and then hand over control to libata, for it to do the rest.
+ *
+ *      LOCKING:
+ *      Inherited from PCI layer (may sleep).
+ *
+ *      RETURNS:
+ *      Zero on success, or -ERRNO value.
+ */
+
+static int ns87415_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        static int printed_version;
+        static const struct ata_port_info info = {
+                .sht            = &ns87415_sht,
+                .flags          = ATA_FLAG_SLAVE_POSS,
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .port_ops       = &ns87415_pata_ops,
+        };
+        const struct ata_port_info *ppi[] = { &info, NULL };
+#if defined(CONFIG_SUPERIO)
+        static const struct ata_port_info info87560 = {
+                .sht            = &ns87415_sht,
+                .flags          = ATA_FLAG_SLAVE_POSS,
+                .pio_mask       = 0x1f, /* pio0-4 */
+                .mwdma_mask     = 0x07, /* mwdma0-2 */
+                .port_ops       = &ns87560_pata_ops,
+        };
+
+        if (PCI_SLOT(pdev->devfn) == 0x0E)
+                ppi[0] = &info87560;
+#endif
+        if (!printed_version++)
+                dev_printk(KERN_DEBUG, &pdev->dev,
+                           "version " DRV_VERSION "\n");
+        /* Select 512 byte sectors */
+        pci_write_config_byte(pdev, 0x55, 0xEE);
+        /* Select PIO0 8bit clocking */
+        pci_write_config_byte(pdev, 0x54, 0xB7);
+        return ata_pci_init_one(pdev, ppi);
+}
+
+static const struct pci_device_id ns87415_pci_tbl[] = {
+        { PCI_VDEVICE(NS, PCI_DEVICE_ID_NS_87415), },
+
+        { }     /* terminate list */
+};
+
+static struct pci_driver ns87415_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = ns87415_pci_tbl,
+        .probe                  = ns87415_init_one,
+        .remove                 = ata_pci_remove_one,
+#ifdef CONFIG_PM
+        .suspend                = ata_pci_device_suspend,
+        .resume                 = ata_pci_device_resume,
+#endif
+};
+
+static int __init ns87415_init(void)
+{
+        return pci_register_driver(&ns87415_pci_driver);
+}
+
+static void __exit ns87415_exit(void)
+{
+        pci_unregister_driver(&ns87415_pci_driver);
+}
+
+module_init(ns87415_init);
+module_exit(ns87415_exit);
+
+MODULE_AUTHOR("Alan Cox");
+MODULE_DESCRIPTION("ATA low-level driver for NS87415 controllers");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, ns87415_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/ata/pata_oldpiix.c b/drivers/ata/pata_oldpiix.c
index 091a70a0ef1c..3cd5eb2b6c91 100644
--- a/drivers/ata/pata_oldpiix.c
+++ b/drivers/ata/pata_oldpiix.c
@@ -29,14 +29,15 @@
 
 /**
  *      oldpiix_pre_reset               -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int oldpiix_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int oldpiix_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits oldpiix_enable_bits[] = {
                 { 0x41U, 1U, 0x80UL, 0x80UL },  /* port 0 */
@@ -46,7 +47,7 @@ static int oldpiix_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &oldpiix_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -237,7 +238,6 @@ static struct scsi_host_template oldpiix_sht = {
 };
 
 static const struct ata_port_operations oldpiix_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = oldpiix_set_piomode,
         .set_dmamode            = oldpiix_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -265,9 +265,8 @@ static const struct ata_port_operations oldpiix_pata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_opti.c b/drivers/ata/pata_opti.c
index 458bf67f766f..8f79447b6151 100644
--- a/drivers/ata/pata_opti.c
+++ b/drivers/ata/pata_opti.c
@@ -46,14 +46,15 @@ enum {
 
 /**
  *      opti_pre_reset          -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int opti_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int opti_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits opti_enable_bits[] = {
                 { 0x45, 1, 0x80, 0x00 },
@@ -63,7 +64,7 @@ static int opti_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (!pci_test_config_bits(pdev, &opti_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -182,7 +183,6 @@ static struct scsi_host_template opti_sht = {
 };
 
 static struct ata_port_operations opti_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = opti_set_piomode,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
@@ -209,9 +209,8 @@ static struct ata_port_operations opti_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int opti_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_optidma.c b/drivers/ata/pata_optidma.c
index f89bdfde16d0..6b07b5b48532 100644
--- a/drivers/ata/pata_optidma.c
+++ b/drivers/ata/pata_optidma.c
@@ -47,14 +47,15 @@ static int pci_clock;	/* 0 = 33 1 = 25 */
 
 /**
  *      optidma_pre_reset               -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int optidma_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int optidma_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         static const struct pci_bits optidma_enable_bits = {
                 0x40, 1, 0x08, 0x00
@@ -63,7 +64,7 @@ static int optidma_pre_reset(struct ata_port *ap, unsigned long deadline)
         if (ap->port_no && !pci_test_config_bits(pdev, &optidma_enable_bits))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -323,25 +324,26 @@ static u8 optidma_make_bits43(struct ata_device *adev)
 
 /**
  *      optidma_set_mode        -       mode setup
- *      @ap: port to set up
+ *      @link: link to set up
  *
  *      Use the standard setup to tune the chipset and then finalise the
  *      configuration by writing the nibble of extra bits of data into
  *      the chip.
  */
 
-static int optidma_set_mode(struct ata_port *ap, struct ata_device **r_failed)
+static int optidma_set_mode(struct ata_link *link, struct ata_device **r_failed)
 {
+        struct ata_port *ap = link->ap;
         u8 r;
         int nybble = 4 * ap->port_no;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
-        int rc  = ata_do_set_mode(ap, r_failed);
+        int rc  = ata_do_set_mode(link, r_failed);
         if (rc == 0) {
                 pci_read_config_byte(pdev, 0x43, &r);
 
                 r &= (0x0F << nybble);
-                r |= (optidma_make_bits43(&ap->device[0]) +
-                     (optidma_make_bits43(&ap->device[0]) << 2)) << nybble;
+                r |= (optidma_make_bits43(&link->device[0]) +
+                     (optidma_make_bits43(&link->device[0]) << 2)) << nybble;
                 pci_write_config_byte(pdev, 0x43, r);
         }
         return rc;
@@ -366,7 +368,6 @@ static struct scsi_host_template optidma_sht = {
 };
 
 static struct ata_port_operations optidma_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = optidma_set_pio_mode,
         .set_dmamode    = optidma_set_dma_mode,
 
@@ -396,13 +397,11 @@ static struct ata_port_operations optidma_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations optiplus_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = optiplus_set_pio_mode,
         .set_dmamode    = optiplus_set_dma_mode,
 
@@ -432,9 +431,8 @@ static struct ata_port_operations optiplus_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_pcmcia.c b/drivers/ata/pata_pcmcia.c
index 0f2b027624d6..782ff4ada9d1 100644
--- a/drivers/ata/pata_pcmcia.c
+++ b/drivers/ata/pata_pcmcia.c
@@ -56,7 +56,7 @@ struct ata_pcmcia_info {
 
 /**
  *      pcmcia_set_mode -       PCMCIA specific mode setup
- *      @ap: Port
+ *      @link: link
  *      @r_failed_dev: Return pointer for failed device
  *
  *      Perform the tuning and setup of the devices and timings, which
@@ -65,13 +65,13 @@ struct ata_pcmcia_info {
  *      decode, which alas is embarrassingly common in the PC world
  */
 
-static int pcmcia_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
+static int pcmcia_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
 {
-        struct ata_device *master = &ap->device[0];
-        struct ata_device *slave = &ap->device[1];
+        struct ata_device *master = &link->device[0];
+        struct ata_device *slave = &link->device[1];
 
         if (!ata_dev_enabled(master) || !ata_dev_enabled(slave))
-                return ata_do_set_mode(ap, r_failed_dev);
+                return ata_do_set_mode(link, r_failed_dev);
 
         if (memcmp(master->id + ATA_ID_FW_REV,  slave->id + ATA_ID_FW_REV,
                            ATA_ID_FW_REV_LEN + ATA_ID_PROD_LEN) == 0)
@@ -84,7 +84,7 @@ static int pcmcia_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev
                         ata_dev_disable(slave);
                 }
         }
-        return ata_do_set_mode(ap, r_failed_dev);
+        return ata_do_set_mode(link, r_failed_dev);
 }
 
 static struct scsi_host_template pcmcia_sht = {
@@ -107,7 +107,6 @@ static struct scsi_host_template pcmcia_sht = {
 
 static struct ata_port_operations pcmcia_port_ops = {
         .set_mode       = pcmcia_set_mode,
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -127,7 +126,6 @@ static struct ata_port_operations pcmcia_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
         .port_start     = ata_sff_port_start,
 };
@@ -304,6 +302,8 @@ next_entry:
         ap->ioaddr.ctl_addr = ctl_addr;
         ata_std_ports(&ap->ioaddr);
 
+        ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", io_base, ctl_base);
+
         /* activate */
         ret = ata_host_activate(host, pdev->irq.AssignedIRQ, ata_interrupt,
                                 IRQF_SHARED, &pcmcia_sht);
diff --git a/drivers/ata/pata_pdc2027x.c b/drivers/ata/pata_pdc2027x.c
index bb64a986e8f5..3d3f1558cdee 100644
--- a/drivers/ata/pata_pdc2027x.c
+++ b/drivers/ata/pata_pdc2027x.c
@@ -69,7 +69,7 @@ static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev);
 static int pdc2027x_check_atapi_dma(struct ata_queued_cmd *qc);
 static unsigned long pdc2027x_mode_filter(struct ata_device *adev, unsigned long mask);
 static int pdc2027x_cable_detect(struct ata_port *ap);
-static int pdc2027x_set_mode(struct ata_port *ap, struct ata_device **r_failed);
+static int pdc2027x_set_mode(struct ata_link *link, struct ata_device **r_failed);
 
 /*
  * ATA Timing Tables based on 133MHz controller clock.
@@ -147,7 +147,6 @@ static struct scsi_host_template pdc2027x_sht = {
 };
 
 static struct ata_port_operations pdc2027x_pata100_ops = {
-        .port_disable           = ata_port_disable,
         .mode_filter            = ata_pci_default_filter,
 
         .tf_load                = ata_tf_load,
@@ -173,13 +172,11 @@ static struct ata_port_operations pdc2027x_pata100_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static struct ata_port_operations pdc2027x_pata133_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = pdc2027x_set_piomode,
         .set_dmamode            = pdc2027x_set_dmamode,
         .set_mode               = pdc2027x_set_mode,
@@ -208,9 +205,8 @@ static struct ata_port_operations pdc2027x_pata133_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static struct ata_port_info pdc2027x_port_info[] = {
@@ -277,7 +273,7 @@ static int pdc2027x_cable_detect(struct ata_port *ap)
         u32 cgcr;
 
         /* check cable detect results */
-        cgcr = readl(port_mmio(ap, PDC_GLOBAL_CTL));
+        cgcr = ioread32(port_mmio(ap, PDC_GLOBAL_CTL));
         if (cgcr & (1 << 26))
                 goto cbl40;
 
@@ -295,12 +291,12 @@ cbl40:
  */
 static inline int pdc2027x_port_enabled(struct ata_port *ap)
 {
-        return readb(port_mmio(ap, PDC_ATA_CTL)) & 0x02;
+        return ioread8(port_mmio(ap, PDC_ATA_CTL)) & 0x02;
 }
 
 /**
  *      pdc2027x_prereset - prereset for PATA host controller
- *      @ap: Target port
+ *      @link: Target link
  *      @deadline: deadline jiffies for the operation
  *
  *      Probeinit including cable detection.
@@ -309,12 +305,12 @@ static inline int pdc2027x_port_enabled(struct ata_port *ap)
  *      None (inherited from caller).
  */
 
-static int pdc2027x_prereset(struct ata_port *ap, unsigned long deadline)
+static int pdc2027x_prereset(struct ata_link *link, unsigned long deadline)
 {
         /* Check whether port enabled */
-        if (!pdc2027x_port_enabled(ap))
+        if (!pdc2027x_port_enabled(link->ap))
                 return -ENOENT;
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -387,16 +383,16 @@ static void pdc2027x_set_piomode(struct ata_port *ap, struct ata_device *adev)
         /* Set the PIO timing registers using value table for 133MHz */
         PDPRINTK("Set pio regs... \n");
 
-        ctcr0 = readl(dev_mmio(ap, adev, PDC_CTCR0));
+        ctcr0 = ioread32(dev_mmio(ap, adev, PDC_CTCR0));
         ctcr0 &= 0xffff0000;
         ctcr0 |= pdc2027x_pio_timing_tbl[pio].value0 |
                 (pdc2027x_pio_timing_tbl[pio].value1 << 8);
-        writel(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
+        iowrite32(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
 
-        ctcr1 = readl(dev_mmio(ap, adev, PDC_CTCR1));
+        ctcr1 = ioread32(dev_mmio(ap, adev, PDC_CTCR1));
         ctcr1 &= 0x00ffffff;
         ctcr1 |= (pdc2027x_pio_timing_tbl[pio].value2 << 24);
-        writel(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
+        iowrite32(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
 
         PDPRINTK("Set pio regs done\n");
 
@@ -430,18 +426,18 @@ static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
                          * If tHOLD is '1', the hardware will add half clock for data hold time.
                          * This code segment seems to be no effect. tHOLD will be overwritten below.
                          */
-                        ctcr1 = readl(dev_mmio(ap, adev, PDC_CTCR1));
-                        writel(ctcr1 & ~(1 << 7), dev_mmio(ap, adev, PDC_CTCR1));
+                        ctcr1 = ioread32(dev_mmio(ap, adev, PDC_CTCR1));
+                        iowrite32(ctcr1 & ~(1 << 7), dev_mmio(ap, adev, PDC_CTCR1));
                 }
 
                 PDPRINTK("Set udma regs... \n");
 
-                ctcr1 = readl(dev_mmio(ap, adev, PDC_CTCR1));
+                ctcr1 = ioread32(dev_mmio(ap, adev, PDC_CTCR1));
                 ctcr1 &= 0xff000000;
                 ctcr1 |= pdc2027x_udma_timing_tbl[udma_mode].value0 |
                         (pdc2027x_udma_timing_tbl[udma_mode].value1 << 8) |
                         (pdc2027x_udma_timing_tbl[udma_mode].value2 << 16);
-                writel(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
+                iowrite32(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
 
                 PDPRINTK("Set udma regs done\n");
 
@@ -453,13 +449,13 @@ static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
                 unsigned int mdma_mode = dma_mode & 0x07;
 
                 PDPRINTK("Set mdma regs... \n");
-                ctcr0 = readl(dev_mmio(ap, adev, PDC_CTCR0));
+                ctcr0 = ioread32(dev_mmio(ap, adev, PDC_CTCR0));
 
                 ctcr0 &= 0x0000ffff;
                 ctcr0 |= (pdc2027x_mdma_timing_tbl[mdma_mode].value0 << 16) |
                         (pdc2027x_mdma_timing_tbl[mdma_mode].value1 << 24);
 
-                writel(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
+                iowrite32(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
                 PDPRINTK("Set mdma regs done\n");
 
                 PDPRINTK("Set to mdma mode[%u] \n", mdma_mode);
@@ -470,24 +466,24 @@ static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 
 /**
  *      pdc2027x_set_mode - Set the timing registers back to correct values.
- *      @ap: Port to configure
+ *      @link: link to configure
  *      @r_failed: Returned device for failure
  *
  *      The pdc2027x hardware will look at "SET FEATURES" and change the timing registers
  *      automatically. The values set by the hardware might be incorrect, under 133Mhz PLL.
  *      This function overwrites the possibly incorrect values set by the hardware to be correct.
  */
-static int pdc2027x_set_mode(struct ata_port *ap, struct ata_device **r_failed)
+static int pdc2027x_set_mode(struct ata_link *link, struct ata_device **r_failed)
 {
-        int i;
-
-        i = ata_do_set_mode(ap, r_failed);
-        if (i < 0)
-                return i;
+        struct ata_port *ap = link->ap;
+        struct ata_device *dev;
+        int rc;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        rc = ata_do_set_mode(link, r_failed);
+        if (rc < 0)
+                return rc;
 
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
 
                         pdc2027x_set_piomode(ap, dev);
@@ -496,9 +492,9 @@ static int pdc2027x_set_mode(struct ata_port *ap, struct ata_device **r_failed)
                          * Enable prefetch if the device support PIO only.
                          */
                         if (dev->xfer_shift == ATA_SHIFT_PIO) {
-                                u32 ctcr1 = readl(dev_mmio(ap, dev, PDC_CTCR1));
+                                u32 ctcr1 = ioread32(dev_mmio(ap, dev, PDC_CTCR1));
                                 ctcr1 |= (1 << 25);
-                                writel(ctcr1, dev_mmio(ap, dev, PDC_CTCR1));
+                                iowrite32(ctcr1, dev_mmio(ap, dev, PDC_CTCR1));
 
                                 PDPRINTK("Turn on prefetch\n");
                         } else {
@@ -563,14 +559,12 @@ static long pdc_read_counter(struct ata_host *host)
         u32 bccrl, bccrh, bccrlv, bccrhv;
 
 retry:
-        bccrl = readl(mmio_base + PDC_BYTE_COUNT) & 0x7fff;
-        bccrh = readl(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;
-        rmb();
+        bccrl = ioread32(mmio_base + PDC_BYTE_COUNT) & 0x7fff;
+        bccrh = ioread32(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;
 
         /* Read the counter values again for verification */
-        bccrlv = readl(mmio_base + PDC_BYTE_COUNT) & 0x7fff;
-        bccrhv = readl(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;
-        rmb();
+        bccrlv = ioread32(mmio_base + PDC_BYTE_COUNT) & 0x7fff;
+        bccrhv = ioread32(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;
 
         counter = (bccrh << 15) | bccrl;
 
@@ -619,7 +613,7 @@ static void pdc_adjust_pll(struct ata_host *host, long pll_clock, unsigned int b
         /* Show the current clock value of PLL control register
          * (maybe already configured by the firmware)
          */
-        pll_ctl = readw(mmio_base + PDC_PLL_CTL);
+        pll_ctl = ioread16(mmio_base + PDC_PLL_CTL);
 
         PDPRINTK("pll_ctl[%X]\n", pll_ctl);
 #endif
@@ -659,8 +653,8 @@ static void pdc_adjust_pll(struct ata_host *host, long pll_clock, unsigned int b
 
         PDPRINTK("Writing pll_ctl[%X]\n", pll_ctl);
 
-        writew(pll_ctl, mmio_base + PDC_PLL_CTL);
-        readw(mmio_base + PDC_PLL_CTL); /* flush */
+        iowrite16(pll_ctl, mmio_base + PDC_PLL_CTL);
+        ioread16(mmio_base + PDC_PLL_CTL); /* flush */
 
         /* Wait the PLL circuit to be stable */
         mdelay(30);
@@ -670,7 +664,7 @@ static void pdc_adjust_pll(struct ata_host *host, long pll_clock, unsigned int b
          *  Show the current clock value of PLL control register
          * (maybe configured by the firmware)
          */
-        pll_ctl = readw(mmio_base + PDC_PLL_CTL);
+        pll_ctl = ioread16(mmio_base + PDC_PLL_CTL);
 
         PDPRINTK("pll_ctl[%X]\n", pll_ctl);
 #endif
@@ -693,10 +687,10 @@ static long pdc_detect_pll_input_clock(struct ata_host *host)
         long pll_clock, usec_elapsed;
 
         /* Start the test mode */
-        scr = readl(mmio_base + PDC_SYS_CTL);
+        scr = ioread32(mmio_base + PDC_SYS_CTL);
         PDPRINTK("scr[%X]\n", scr);
-        writel(scr | (0x01 << 14), mmio_base + PDC_SYS_CTL);
-        readl(mmio_base + PDC_SYS_CTL); /* flush */
+        iowrite32(scr | (0x01 << 14), mmio_base + PDC_SYS_CTL);
+        ioread32(mmio_base + PDC_SYS_CTL); /* flush */
 
         /* Read current counter value */
         start_count = pdc_read_counter(host);
@@ -710,10 +704,10 @@ static long pdc_detect_pll_input_clock(struct ata_host *host)
         do_gettimeofday(&end_time);
 
         /* Stop the test mode */
-        scr = readl(mmio_base + PDC_SYS_CTL);
+        scr = ioread32(mmio_base + PDC_SYS_CTL);
         PDPRINTK("scr[%X]\n", scr);
-        writel(scr & ~(0x01 << 14), mmio_base + PDC_SYS_CTL);
-        readl(mmio_base + PDC_SYS_CTL); /* flush */
+        iowrite32(scr & ~(0x01 << 14), mmio_base + PDC_SYS_CTL);
+        ioread32(mmio_base + PDC_SYS_CTL); /* flush */
 
         /* calculate the input clock in Hz */
         usec_elapsed = (end_time.tv_sec - start_time.tv_sec) * 1000000 +
@@ -745,9 +739,6 @@ static int pdc_hardware_init(struct ata_host *host, unsigned int board_idx)
          */
         pll_clock = pdc_detect_pll_input_clock(host);
 
-        if (pll_clock < 0) /* counter overflow? Try again. */
-                pll_clock = pdc_detect_pll_input_clock(host);
-
         dev_printk(KERN_INFO, host->dev, "PLL input clock %ld kHz\n", pll_clock/1000);
 
         /* Adjust PLL control register */
@@ -791,12 +782,14 @@ static void pdc_ata_setup_port(struct ata_ioports *port, void __iomem *base)
 static int __devinit pdc2027x_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         static int printed_version;
+        static const unsigned long cmd_offset[] = { 0x17c0, 0x15c0 };
+        static const unsigned long bmdma_offset[] = { 0x1000, 0x1008 };
         unsigned int board_idx = (unsigned int) ent->driver_data;
         const struct ata_port_info *ppi[] =
                 { &pdc2027x_port_info[board_idx], NULL };
         struct ata_host *host;
         void __iomem *mmio_base;
-        int rc;
+        int i, rc;
 
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
@@ -826,10 +819,15 @@ static int __devinit pdc2027x_init_one(struct pci_dev *pdev, const struct pci_de
 
         mmio_base = host->iomap[PDC_MMIO_BAR];
 
-        pdc_ata_setup_port(&host->ports[0]->ioaddr, mmio_base + 0x17c0);
-        host->ports[0]->ioaddr.bmdma_addr = mmio_base + 0x1000;
-        pdc_ata_setup_port(&host->ports[1]->ioaddr, mmio_base + 0x15c0);
-        host->ports[1]->ioaddr.bmdma_addr = mmio_base + 0x1008;
+        for (i = 0; i < 2; i++) {
+                struct ata_port *ap = host->ports[i];
+
+                pdc_ata_setup_port(&ap->ioaddr, mmio_base + cmd_offset[i]);
+                ap->ioaddr.bmdma_addr = mmio_base + bmdma_offset[i];
+
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, cmd_offset[i], "cmd");
+        }
 
         //pci_enable_intx(pdev);
 
diff --git a/drivers/ata/pata_pdc202xx_old.c b/drivers/ata/pata_pdc202xx_old.c
index 92447bed5e77..65d951618c60 100644
--- a/drivers/ata/pata_pdc202xx_old.c
+++ b/drivers/ata/pata_pdc202xx_old.c
@@ -9,7 +9,7 @@
  * First cut with LBA48/ATAPI
  *
  * TODO:
- *      Channel interlock/reset on both required
+ *      Channel interlock/reset on both required ?
  */
 
 #include <linux/kernel.h>
@@ -22,7 +22,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME "pata_pdc202xx_old"
-#define DRV_VERSION "0.4.2"
+#define DRV_VERSION "0.4.3"
 
 static int pdc2026x_cable_detect(struct ata_port *ap)
 {
@@ -106,9 +106,9 @@ static void pdc202xx_set_dmamode(struct ata_port *ap, struct ata_device *adev)
                 { 0x20, 0x01 }
         };
         static u8 mdma_timing[3][2] = {
-                { 0x60, 0x03 },
-                { 0x60, 0x04 },
                 { 0xe0, 0x0f },
+                { 0x60, 0x04 },
+                { 0x60, 0x03 },
         };
         u8 r_bp, r_cp;
 
@@ -139,6 +139,9 @@ static void pdc202xx_set_dmamode(struct ata_port *ap, struct ata_device *adev)
  *
  *      In UDMA3 or higher we have to clock switch for the duration of the
  *      DMA transfer sequence.
+ *
+ *      Note: The host lock held by the libata layer protects
+ *      us from two channels both trying to set DMA bits at once
  */
 
 static void pdc2026x_bmdma_start(struct ata_queued_cmd *qc)
@@ -187,6 +190,9 @@ static void pdc2026x_bmdma_start(struct ata_queued_cmd *qc)
  *
  *      After a DMA completes we need to put the clock back to 33MHz for
  *      PIO timings.
+ *
+ *      Note: The host lock held by the libata layer protects
+ *      us from two channels both trying to set DMA bits at once
  */
 
 static void pdc2026x_bmdma_stop(struct ata_queued_cmd *qc)
@@ -206,7 +212,6 @@ static void pdc2026x_bmdma_stop(struct ata_queued_cmd *qc)
                 iowrite32(0, atapi_reg);
                 iowrite8(ioread8(clock) & ~sel66, clock);
         }
-        /* Check we keep host level locking here */
         /* Flip back to 33Mhz for PIO */
         if (adev->dma_mode >= XFER_UDMA_2)
                 iowrite8(ioread8(clock) & ~sel66, clock);
@@ -247,7 +252,6 @@ static struct scsi_host_template pdc202xx_sht = {
 };
 
 static struct ata_port_operations pdc2024x_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = pdc202xx_set_piomode,
         .set_dmamode    = pdc202xx_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -275,13 +279,11 @@ static struct ata_port_operations pdc2024x_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations pdc2026x_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = pdc202xx_set_piomode,
         .set_dmamode    = pdc202xx_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -310,9 +312,8 @@ static struct ata_port_operations pdc2026x_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int pdc202xx_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_platform.c b/drivers/ata/pata_platform.c
index 5086d03f2d7c..fc72a965643d 100644
--- a/drivers/ata/pata_platform.c
+++ b/drivers/ata/pata_platform.c
@@ -30,13 +30,11 @@ static int pio_mask = 1;
  * Provide our own set_mode() as we don't want to change anything that has
  * already been configured..
  */
-static int pata_platform_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int pata_platform_set_mode(struct ata_link *link, struct ata_device **unused)
 {
-        int i;
-
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        struct ata_device *dev;
 
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         /* We don't really care */
                         dev->pio_mode = dev->xfer_mode = XFER_PIO_0;
@@ -71,7 +69,6 @@ static struct scsi_host_template pata_platform_sht = {
 static struct ata_port_operations pata_platform_port_ops = {
         .set_mode               = pata_platform_set_mode,
 
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -91,7 +88,6 @@ static struct ata_port_operations pata_platform_port_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_dummy_ret0,
 };
@@ -209,9 +205,13 @@ static int __devinit pata_platform_probe(struct platform_device *pdev)
 
         ap->ioaddr.altstatus_addr = ap->ioaddr.ctl_addr;
 
-        pp_info = (struct pata_platform_info *)(pdev->dev.platform_data);
+        pp_info = pdev->dev.platform_data;
         pata_platform_setup_port(&ap->ioaddr, pp_info);
 
+        ata_port_desc(ap, "%s cmd 0x%llx ctl 0x%llx", mmio ? "mmio" : "ioport",
+                      (unsigned long long)io_res->start,
+                      (unsigned long long)ctl_res->start);
+
         /* activate */
         return ata_host_activate(host, platform_get_irq(pdev, 0),
                                  ata_interrupt, pp_info ? pp_info->irq_flags
diff --git a/drivers/ata/pata_qdi.c b/drivers/ata/pata_qdi.c
index 1998c19e8743..7d4c696c4cb6 100644
--- a/drivers/ata/pata_qdi.c
+++ b/drivers/ata/pata_qdi.c
@@ -126,7 +126,7 @@ static unsigned int qdi_qc_issue_prot(struct ata_queued_cmd *qc)
 
 static void qdi_data_xfer(struct ata_device *adev, unsigned char *buf, unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         int slop = buflen & 3;
 
         if (ata_id_has_dword_io(adev->id)) {
@@ -170,7 +170,6 @@ static struct scsi_host_template qdi_sht = {
 };
 
 static struct ata_port_operations qdi6500_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = qdi6500_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -192,13 +191,11 @@ static struct ata_port_operations qdi6500_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations qdi6580_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = qdi6580_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -220,9 +217,8 @@ static struct ata_port_operations qdi6580_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
@@ -238,6 +234,7 @@ static struct ata_port_operations qdi6580_port_ops = {
 
 static __init int qdi_init_one(unsigned long port, int type, unsigned long io, int irq, int fast)
 {
+        unsigned long ctl = io + 0x206;
         struct platform_device *pdev;
         struct ata_host *host;
         struct ata_port *ap;
@@ -254,7 +251,7 @@ static __init int qdi_init_one(unsigned long port, int type, unsigned long io, i
 
         ret = -ENOMEM;
         io_addr = devm_ioport_map(&pdev->dev, io, 8);
-        ctl_addr = devm_ioport_map(&pdev->dev, io + 0x206, 1);
+        ctl_addr = devm_ioport_map(&pdev->dev, ctl, 1);
         if (!io_addr || !ctl_addr)
                 goto fail;
 
@@ -279,6 +276,8 @@ static __init int qdi_init_one(unsigned long port, int type, unsigned long io, i
         ap->ioaddr.ctl_addr = ctl_addr;
         ata_std_ports(&ap->ioaddr);
 
+        ata_port_desc(ap, "cmd %lx ctl %lx", io, ctl);
+
         /*
          *      Hook in a private data structure per channel
          */
diff --git a/drivers/ata/pata_radisys.c b/drivers/ata/pata_radisys.c
index 7d1aabed422d..d5b76497f4a2 100644
--- a/drivers/ata/pata_radisys.c
+++ b/drivers/ata/pata_radisys.c
@@ -203,7 +203,6 @@ static struct scsi_host_template radisys_sht = {
 };
 
 static const struct ata_port_operations radisys_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = radisys_set_piomode,
         .set_dmamode            = radisys_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -231,9 +230,8 @@ static const struct ata_port_operations radisys_pata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 
diff --git a/drivers/ata/pata_rz1000.c b/drivers/ata/pata_rz1000.c
index 7632fcb070ca..ba8a31c55edb 100644
--- a/drivers/ata/pata_rz1000.c
+++ b/drivers/ata/pata_rz1000.c
@@ -26,7 +26,7 @@
 
 /**
  *      rz1000_set_mode         -       mode setting function
- *      @ap: ATA interface
+ *      @link: ATA link
  *      @unused: returned device on set_mode failure
  *
  *      Use a non standard set_mode function. We don't want to be tuned. We
@@ -34,12 +34,11 @@
  *      whacked out.
  */
 
-static int rz1000_set_mode(struct ata_port *ap, struct ata_device **unused)
+static int rz1000_set_mode(struct ata_link *link, struct ata_device **unused)
 {
-        int i;
+        struct ata_device *dev;
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (ata_dev_enabled(dev)) {
                         /* We don't really care */
                         dev->pio_mode = XFER_PIO_0;
@@ -74,7 +73,6 @@ static struct scsi_host_template rz1000_sht = {
 static struct ata_port_operations rz1000_port_ops = {
         .set_mode       = rz1000_set_mode,
 
-        .port_disable   = ata_port_disable,
         .tf_load        = ata_tf_load,
         .tf_read        = ata_tf_read,
         .check_status   = ata_check_status,
@@ -100,9 +98,8 @@ static struct ata_port_operations rz1000_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int rz1000_fifo_disable(struct pci_dev *pdev)
diff --git a/drivers/ata/pata_sc1200.c b/drivers/ata/pata_sc1200.c
index 5edf67b1f3bf..21ebc485ca4b 100644
--- a/drivers/ata/pata_sc1200.c
+++ b/drivers/ata/pata_sc1200.c
@@ -197,7 +197,6 @@ static struct scsi_host_template sc1200_sht = {
 };
 
 static struct ata_port_operations sc1200_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = sc1200_set_piomode,
         .set_dmamode    = sc1200_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -227,9 +226,8 @@ static struct ata_port_operations sc1200_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_scc.c b/drivers/ata/pata_scc.c
index 2d048ef25a5a..55576138faea 100644
--- a/drivers/ata/pata_scc.c
+++ b/drivers/ata/pata_scc.c
@@ -603,16 +603,17 @@ static unsigned int scc_bus_softreset(struct ata_port *ap, unsigned int devmask,
  *      Note: Original code is ata_std_softreset().
  */
 
-static int scc_std_softreset (struct ata_port *ap, unsigned int *classes,
-                              unsigned long deadline)
+static int scc_std_softreset(struct ata_link *link, unsigned int *classes,
+                             unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
         unsigned int devmask = 0, err_mask;
         u8 err;
 
         DPRINTK("ENTER\n");
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 classes[0] = ATA_DEV_NONE;
                 goto out;
         }
@@ -636,9 +637,11 @@ static int scc_std_softreset (struct ata_port *ap, unsigned int *classes,
         }
 
         /* determine by signature whether we have ATA or ATAPI devices */
-        classes[0] = ata_dev_try_classify(ap, 0, &err);
+        classes[0] = ata_dev_try_classify(&ap->link.device[0],
+                                          devmask & (1 << 0), &err);
         if (slave_possible && err != 0x81)
-                classes[1] = ata_dev_try_classify(ap, 1, &err);
+                classes[1] = ata_dev_try_classify(&ap->link.device[1],
+                                                  devmask & (1 << 1), &err);
 
  out:
         DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
@@ -701,7 +704,7 @@ static void scc_bmdma_stop (struct ata_queued_cmd *qc)
                         printk(KERN_WARNING "%s: Internal Bus Error\n", DRV_NAME);
                         out_be32(bmid_base + SCC_DMA_INTST, INTSTS_BMSINT);
                         /* TBD: SW reset */
-                        scc_std_softreset(ap, &classes, deadline);
+                        scc_std_softreset(&ap->link, &classes, deadline);
                         continue;
                 }
 
@@ -740,7 +743,7 @@ static u8 scc_bmdma_status (struct ata_port *ap)
         void __iomem *mmio = ap->ioaddr.bmdma_addr;
         u8 host_stat = in_be32(mmio + SCC_DMA_STATUS);
         u32 int_status = in_be32(mmio + SCC_DMA_INTST);
-        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
         static int retry = 0;
 
         /* return if IOS_SS is cleared */
@@ -785,7 +788,7 @@ static u8 scc_bmdma_status (struct ata_port *ap)
 static void scc_data_xfer (struct ata_device *adev, unsigned char *buf,
                            unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         unsigned int words = buflen >> 1;
         unsigned int i;
         u16 *buf16 = (u16 *) buf;
@@ -839,38 +842,6 @@ static u8 scc_irq_on (struct ata_port *ap)
 }
 
 /**
- *      scc_irq_ack - Acknowledge a device interrupt.
- *      @ap: Port on which interrupts are enabled.
- *
- *      Note: Original code is ata_irq_ack().
- */
-
-static u8 scc_irq_ack (struct ata_port *ap, unsigned int chk_drq)
-{
-        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
-        u8 host_stat, post_stat, status;
-
-        status = ata_busy_wait(ap, bits, 1000);
-        if (status & bits)
-                if (ata_msg_err(ap))
-                        printk(KERN_ERR "abnormal status 0x%X\n", status);
-
-        /* get controller status; clear intr, err bits */
-        host_stat = in_be32(ap->ioaddr.bmdma_addr + SCC_DMA_STATUS);
-        out_be32(ap->ioaddr.bmdma_addr + SCC_DMA_STATUS,
-                 host_stat | ATA_DMA_INTR | ATA_DMA_ERR);
-
-        post_stat = in_be32(ap->ioaddr.bmdma_addr + SCC_DMA_STATUS);
-
-        if (ata_msg_intr(ap))
-                printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
-                       __FUNCTION__,
-                       host_stat, post_stat, status);
-
-        return status;
-}
-
-/**
  *      scc_bmdma_freeze - Freeze BMDMA controller port
  *      @ap: port to freeze
  *
@@ -901,10 +872,10 @@ static void scc_bmdma_freeze (struct ata_port *ap)
  *      @deadline: deadline jiffies for the operation
  */
 
-static int scc_pata_prereset(struct ata_port *ap, unsigned long deadline)
+static int scc_pata_prereset(struct ata_link *link, unsigned long deadline)
 {
-        ap->cbl = ATA_CBL_PATA80;
-        return ata_std_prereset(ap, deadline);
+        link->ap->cbl = ATA_CBL_PATA80;
+        return ata_std_prereset(link, deadline);
 }
 
 /**
@@ -915,8 +886,10 @@ static int scc_pata_prereset(struct ata_port *ap, unsigned long deadline)
  *      Note: Original code is ata_std_postreset().
  */
 
-static void scc_std_postreset (struct ata_port *ap, unsigned int *classes)
+static void scc_std_postreset(struct ata_link *link, unsigned int *classes)
 {
+        struct ata_port *ap = link->ap;
+
         DPRINTK("ENTER\n");
 
         /* is double-select really necessary? */
@@ -1020,7 +993,6 @@ static struct scsi_host_template scc_sht = {
 };
 
 static const struct ata_port_operations scc_pata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = scc_set_piomode,
         .set_dmamode            = scc_set_dmamode,
         .mode_filter            = scc_mode_filter,
@@ -1047,7 +1019,6 @@ static const struct ata_port_operations scc_pata_ops = {
 
         .irq_clear              = scc_bmdma_irq_clear,
         .irq_on                 = scc_irq_on,
-        .irq_ack                = scc_irq_ack,
 
         .port_start             = scc_port_start,
         .port_stop              = scc_port_stop,
@@ -1193,6 +1164,9 @@ static int scc_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 return rc;
         host->iomap = pcim_iomap_table(pdev);
 
+        ata_port_pbar_desc(host->ports[0], SCC_CTRL_BAR, -1, "ctrl");
+        ata_port_pbar_desc(host->ports[0], SCC_BMID_BAR, -1, "bmid");
+
         rc = scc_host_init(host);
         if (rc)
                 return rc;
diff --git a/drivers/ata/pata_serverworks.c b/drivers/ata/pata_serverworks.c
index 0faf99c8f13e..df68806df4be 100644
--- a/drivers/ata/pata_serverworks.c
+++ b/drivers/ata/pata_serverworks.c
@@ -318,7 +318,6 @@ static struct scsi_host_template serverworks_sht = {
 };
 
 static struct ata_port_operations serverworks_osb4_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = serverworks_set_piomode,
         .set_dmamode    = serverworks_set_dmamode,
         .mode_filter    = serverworks_osb4_filter,
@@ -348,13 +347,11 @@ static struct ata_port_operations serverworks_osb4_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations serverworks_csb_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = serverworks_set_piomode,
         .set_dmamode    = serverworks_set_dmamode,
         .mode_filter    = serverworks_csb_filter,
@@ -384,9 +381,8 @@ static struct ata_port_operations serverworks_csb_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int serverworks_fixup_osb4(struct pci_dev *pdev)
diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
index 40395804a66f..2eb75cd74a96 100644
--- a/drivers/ata/pata_sil680.c
+++ b/drivers/ata/pata_sil680.c
@@ -95,15 +95,16 @@ static int sil680_cable_detect(struct ata_port *ap) {
 
 /**
  *      sil680_bus_reset        -       reset the SIL680 bus
- *      @ap: ATA port to reset
+ *      @link: ATA link to reset
  *      @deadline: deadline jiffies for the operation
  *
  *      Perform the SIL680 housekeeping when doing an ATA bus reset
  */
 
-static int sil680_bus_reset(struct ata_port *ap,unsigned int *classes,
+static int sil680_bus_reset(struct ata_link *link, unsigned int *classes,
                             unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         unsigned long addr = sil680_selreg(ap, 0);
         u8 reset;
@@ -112,7 +113,7 @@ static int sil680_bus_reset(struct ata_port *ap,unsigned int *classes,
         pci_write_config_byte(pdev, addr, reset | 0x03);
         udelay(25);
         pci_write_config_byte(pdev, addr, reset);
-        return ata_std_softreset(ap, classes, deadline);
+        return ata_std_softreset(link, classes, deadline);
 }
 
 static void sil680_error_handler(struct ata_port *ap)
@@ -237,7 +238,6 @@ static struct scsi_host_template sil680_sht = {
 };
 
 static struct ata_port_operations sil680_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = sil680_set_piomode,
         .set_dmamode    = sil680_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -266,9 +266,8 @@ static struct ata_port_operations sil680_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_sis.c b/drivers/ata/pata_sis.c
index cce2834b2b60..3b5be77e861c 100644
--- a/drivers/ata/pata_sis.c
+++ b/drivers/ata/pata_sis.c
@@ -84,7 +84,7 @@ static int sis_short_ata40(struct pci_dev *dev)
 
 static int sis_old_port_base(struct ata_device *adev)
 {
-        return  0x40 + (4 * adev->ap->port_no) +  (2 * adev->devno);
+        return  0x40 + (4 * adev->link->ap->port_no) +  (2 * adev->devno);
 }
 
 /**
@@ -133,19 +133,20 @@ static int sis_66_cable_detect(struct ata_port *ap)
 
 /**
  *      sis_pre_reset           -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int sis_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int sis_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits sis_enable_bits[] = {
                 { 0x4aU, 1U, 0x02UL, 0x02UL },  /* port 0 */
                 { 0x4aU, 1U, 0x04UL, 0x04UL },  /* port 1 */
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &sis_enable_bits[ap->port_no]))
@@ -154,7 +155,7 @@ static int sis_pre_reset(struct ata_port *ap, unsigned long deadline)
         /* Clear the FIFO settings. We can't enable the FIFO until
            we know we are poking at a disk */
         pci_write_config_byte(pdev, 0x4B, 0);
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 
@@ -530,7 +531,6 @@ static struct scsi_host_template sis_sht = {
 };
 
 static const struct ata_port_operations sis_133_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_133_set_piomode,
         .set_dmamode            = sis_133_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -558,13 +558,11 @@ static const struct ata_port_operations sis_133_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_133_for_sata_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_133_set_piomode,
         .set_dmamode            = sis_133_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -592,13 +590,11 @@ static const struct ata_port_operations sis_133_for_sata_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_133_early_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_100_set_piomode,
         .set_dmamode            = sis_133_early_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -626,13 +622,11 @@ static const struct ata_port_operations sis_133_early_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_100_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_100_set_piomode,
         .set_dmamode            = sis_100_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -660,13 +654,11 @@ static const struct ata_port_operations sis_100_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_66_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_old_set_piomode,
         .set_dmamode            = sis_66_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -694,13 +686,11 @@ static const struct ata_port_operations sis_66_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_operations sis_old_ops = {
-        .port_disable           = ata_port_disable,
         .set_piomode            = sis_old_set_piomode,
         .set_dmamode            = sis_old_set_dmamode,
         .mode_filter            = ata_pci_default_filter,
@@ -728,9 +718,8 @@ static const struct ata_port_operations sis_old_ops = {
         .irq_handler            = ata_interrupt,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
-        .port_start             = ata_port_start,
+        .port_start             = ata_sff_port_start,
 };
 
 static const struct ata_port_info sis_info = {
diff --git a/drivers/ata/pata_sl82c105.c b/drivers/ata/pata_sl82c105.c
index c0f43bb25956..1388cef52c07 100644
--- a/drivers/ata/pata_sl82c105.c
+++ b/drivers/ata/pata_sl82c105.c
@@ -43,23 +43,24 @@ enum {
 
 /**
  *      sl82c105_pre_reset              -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int sl82c105_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int sl82c105_pre_reset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits sl82c105_enable_bits[] = {
                 { 0x40, 1, 0x01, 0x01 },
                 { 0x40, 1, 0x10, 0x10 }
         };
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (ap->port_no && !pci_test_config_bits(pdev, &sl82c105_enable_bits[ap->port_no]))
                 return -ENOENT;
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 
@@ -224,7 +225,6 @@ static struct scsi_host_template sl82c105_sht = {
 };
 
 static struct ata_port_operations sl82c105_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = sl82c105_set_piomode,
         .mode_filter    = ata_pci_default_filter,
 
@@ -253,9 +253,8 @@ static struct ata_port_operations sl82c105_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_triflex.c b/drivers/ata/pata_triflex.c
index af21f443db6e..403eafcffe12 100644
--- a/drivers/ata/pata_triflex.c
+++ b/drivers/ata/pata_triflex.c
@@ -47,25 +47,26 @@
 
 /**
  *      triflex_prereset                -       probe begin
- *      @ap: ATA port
+ *      @link: ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      Set up cable type and use generic probe init
  */
 
-static int triflex_prereset(struct ata_port *ap, unsigned long deadline)
+static int triflex_prereset(struct ata_link *link, unsigned long deadline)
 {
         static const struct pci_bits triflex_enable_bits[] = {
                 { 0x80, 1, 0x01, 0x01 },
                 { 0x80, 1, 0x02, 0x02 }
         };
 
+        struct ata_port *ap = link->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 
         if (!pci_test_config_bits(pdev, &triflex_enable_bits[ap->port_no]))
                 return -ENOENT;
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 
@@ -197,7 +198,6 @@ static struct scsi_host_template triflex_sht = {
 };
 
 static struct ata_port_operations triflex_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = triflex_set_piomode,
         .mode_filter    = ata_pci_default_filter,
 
@@ -226,9 +226,8 @@ static struct ata_port_operations triflex_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static int triflex_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index f143db4559e0..5d41b6612d7f 100644
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -184,11 +184,15 @@ static int via_cable_detect(struct ata_port *ap) {
            two drives */
         if (ata66 & (0x10100000 >> (16 * ap->port_no)))
                 return ATA_CBL_PATA80;
+        /* Check with ACPI so we can spot BIOS reported SATA bridges */
+        if (ata_acpi_cbl_80wire(ap))
+                return ATA_CBL_PATA80;
         return ATA_CBL_PATA40;
 }
 
-static int via_pre_reset(struct ata_port *ap, unsigned long deadline)
+static int via_pre_reset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         const struct via_isa_bridge *config = ap->host->private_data;
 
         if (!(config->flags & VIA_NO_ENABLES)) {
@@ -201,7 +205,7 @@ static int via_pre_reset(struct ata_port *ap, unsigned long deadline)
                         return -ENOENT;
         }
 
-        return ata_std_prereset(ap, deadline);
+        return ata_std_prereset(link, deadline);
 }
 
 
@@ -344,7 +348,6 @@ static struct scsi_host_template via_sht = {
 };
 
 static struct ata_port_operations via_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = via_set_piomode,
         .set_dmamode    = via_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -374,13 +377,11 @@ static struct ata_port_operations via_port_ops = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 static struct ata_port_operations via_port_ops_noirq = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = via_set_piomode,
         .set_dmamode    = via_set_dmamode,
         .mode_filter    = ata_pci_default_filter,
@@ -410,9 +411,8 @@ static struct ata_port_operations via_port_ops_noirq = {
         .irq_handler    = ata_interrupt,
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
diff --git a/drivers/ata/pata_winbond.c b/drivers/ata/pata_winbond.c
index 83abfeca4057..549cbbe9fd07 100644
--- a/drivers/ata/pata_winbond.c
+++ b/drivers/ata/pata_winbond.c
@@ -94,7 +94,7 @@ static void winbond_set_piomode(struct ata_port *ap, struct ata_device *adev)
 
 static void winbond_data_xfer(struct ata_device *adev, unsigned char *buf, unsigned int buflen, int write_data)
 {
-        struct ata_port *ap = adev->ap;
+        struct ata_port *ap = adev->link->ap;
         int slop = buflen & 3;
 
         if (ata_id_has_dword_io(adev->id)) {
@@ -138,7 +138,6 @@ static struct scsi_host_template winbond_sht = {
 };
 
 static struct ata_port_operations winbond_port_ops = {
-        .port_disable   = ata_port_disable,
         .set_piomode    = winbond_set_piomode,
 
         .tf_load        = ata_tf_load,
@@ -160,9 +159,8 @@ static struct ata_port_operations winbond_port_ops = {
 
         .irq_clear      = ata_bmdma_irq_clear,
         .irq_on         = ata_irq_on,
-        .irq_ack        = ata_irq_ack,
 
-        .port_start     = ata_port_start,
+        .port_start     = ata_sff_port_start,
 };
 
 /**
@@ -199,6 +197,7 @@ static __init int winbond_init_one(unsigned long port)
 
         for (i = 0; i < 2 ; i ++) {
                 unsigned long cmd_port = 0x1F0 - (0x80 * i);
+                unsigned long ctl_port = cmd_port + 0x206;
                 struct ata_host *host;
                 struct ata_port *ap;
                 void __iomem *cmd_addr, *ctl_addr;
@@ -214,14 +213,16 @@ static __init int winbond_init_one(unsigned long port)
                 host = ata_host_alloc(&pdev->dev, 1);
                 if (!host)
                         goto err_unregister;
+                ap = host->ports[0];
 
                 rc = -ENOMEM;
                 cmd_addr = devm_ioport_map(&pdev->dev, cmd_port, 8);
-                ctl_addr = devm_ioport_map(&pdev->dev, cmd_port + 0x0206, 1);
+                ctl_addr = devm_ioport_map(&pdev->dev, ctl_port, 1);
                 if (!cmd_addr || !ctl_addr)
                         goto err_unregister;
 
-                ap = host->ports[0];
+                ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", cmd_port, ctl_port);
+
                 ap->ops = &winbond_port_ops;
                 ap->pio_mask = 0x1F;
                 ap->flags |= ATA_FLAG_SLAVE_POSS;
diff --git a/drivers/ata/pdc_adma.c b/drivers/ata/pdc_adma.c
index 5c79271401af..8d1b03d5bcb1 100644
--- a/drivers/ata/pdc_adma.c
+++ b/drivers/ata/pdc_adma.c
@@ -92,6 +92,8 @@ enum {
 
         /* CPB bits */
         cDONE                   = (1 << 0),
+        cATERR                  = (1 << 3),
+
         cVLD                    = (1 << 0),
         cDAT                    = (1 << 2),
         cIEN                    = (1 << 3),
@@ -131,14 +133,15 @@ static int adma_ata_init_one (struct pci_dev *pdev,
 static int adma_port_start(struct ata_port *ap);
 static void adma_host_stop(struct ata_host *host);
 static void adma_port_stop(struct ata_port *ap);
-static void adma_phy_reset(struct ata_port *ap);
 static void adma_qc_prep(struct ata_queued_cmd *qc);
 static unsigned int adma_qc_issue(struct ata_queued_cmd *qc);
 static int adma_check_atapi_dma(struct ata_queued_cmd *qc);
 static void adma_bmdma_stop(struct ata_queued_cmd *qc);
 static u8 adma_bmdma_status(struct ata_port *ap);
 static void adma_irq_clear(struct ata_port *ap);
-static void adma_eng_timeout(struct ata_port *ap);
+static void adma_freeze(struct ata_port *ap);
+static void adma_thaw(struct ata_port *ap);
+static void adma_error_handler(struct ata_port *ap);
 
 static struct scsi_host_template adma_ata_sht = {
         .module                 = THIS_MODULE,
@@ -159,21 +162,20 @@ static struct scsi_host_template adma_ata_sht = {
 };
 
 static const struct ata_port_operations adma_ata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
         .check_status           = ata_check_status,
         .dev_select             = ata_std_dev_select,
-        .phy_reset              = adma_phy_reset,
         .check_atapi_dma        = adma_check_atapi_dma,
         .data_xfer              = ata_data_xfer,
         .qc_prep                = adma_qc_prep,
         .qc_issue               = adma_qc_issue,
-        .eng_timeout            = adma_eng_timeout,
+        .freeze                 = adma_freeze,
+        .thaw                   = adma_thaw,
+        .error_handler          = adma_error_handler,
         .irq_clear              = adma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .port_start             = adma_port_start,
         .port_stop              = adma_port_stop,
         .host_stop              = adma_host_stop,
@@ -184,7 +186,7 @@ static const struct ata_port_operations adma_ata_ops = {
 static struct ata_port_info adma_port_info[] = {
         /* board_1841_idx */
         {
-                .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST |
+                .flags          = ATA_FLAG_SLAVE_POSS |
                                   ATA_FLAG_NO_LEGACY | ATA_FLAG_MMIO |
                                   ATA_FLAG_PIO_POLLING,
                 .pio_mask       = 0x10, /* pio4 */
@@ -273,24 +275,42 @@ static inline void adma_enter_reg_mode(struct ata_port *ap)
         readb(chan + ADMA_STATUS);      /* flush */
 }
 
-static void adma_phy_reset(struct ata_port *ap)
+static void adma_freeze(struct ata_port *ap)
 {
-        struct adma_port_priv *pp = ap->private_data;
+        void __iomem *chan = ADMA_PORT_REGS(ap);
+
+        /* mask/clear ATA interrupts */
+        writeb(ATA_NIEN, ap->ioaddr.ctl_addr);
+        ata_check_status(ap);
 
-        pp->state = adma_state_idle;
+        /* reset ADMA to idle state */
+        writew(aPIOMD4 | aNIEN | aRSTADM, chan + ADMA_CONTROL);
+        udelay(2);
+        writew(aPIOMD4 | aNIEN, chan + ADMA_CONTROL);
+        udelay(2);
+}
+
+static void adma_thaw(struct ata_port *ap)
+{
         adma_reinit_engine(ap);
-        ata_port_probe(ap);
-        ata_bus_reset(ap);
 }
 
-static void adma_eng_timeout(struct ata_port *ap)
+static int adma_prereset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct adma_port_priv *pp = ap->private_data;
 
         if (pp->state != adma_state_idle) /* healthy paranoia */
                 pp->state = adma_state_mmio;
         adma_reinit_engine(ap);
-        ata_eng_timeout(ap);
+
+        return ata_std_prereset(link, deadline);
+}
+
+static void adma_error_handler(struct ata_port *ap)
+{
+        ata_do_eh(ap, adma_prereset, ata_std_softreset, NULL,
+                  ata_std_postreset);
 }
 
 static int adma_fill_sg(struct ata_queued_cmd *qc)
@@ -464,14 +484,33 @@ static inline unsigned int adma_intr_pkt(struct ata_host *host)
                 pp = ap->private_data;
                 if (!pp || pp->state != adma_state_pkt)
                         continue;
-                qc = ata_qc_from_tag(ap, ap->active_tag);
+                qc = ata_qc_from_tag(ap, ap->link.active_tag);
                 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
-                        if ((status & (aPERR | aPSD | aUIRQ)))
+                        if (status & aPERR)
+                                qc->err_mask |= AC_ERR_HOST_BUS;
+                        else if ((status & (aPSD | aUIRQ)))
                                 qc->err_mask |= AC_ERR_OTHER;
+
+                        if (pp->pkt[0] & cATERR)
+                                qc->err_mask |= AC_ERR_DEV;
                         else if (pp->pkt[0] != cDONE)
                                 qc->err_mask |= AC_ERR_OTHER;
 
-                        ata_qc_complete(qc);
+                        if (!qc->err_mask)
+                                ata_qc_complete(qc);
+                        else {
+                                struct ata_eh_info *ehi = &ap->link.eh_info;
+                                ata_ehi_clear_desc(ehi);
+                                ata_ehi_push_desc(ehi,
+                                        "ADMA-status 0x%02X", status);
+                                ata_ehi_push_desc(ehi,
+                                        "pkt[0] 0x%02X", pp->pkt[0]);
+
+                                if (qc->err_mask == AC_ERR_DEV)
+                                        ata_port_abort(ap);
+                                else
+                                        ata_port_freeze(ap);
+                        }
                 }
         }
         return handled;
@@ -489,7 +528,7 @@ static inline unsigned int adma_intr_mmio(struct ata_host *host)
                         struct adma_port_priv *pp = ap->private_data;
                         if (!pp || pp->state != adma_state_mmio)
                                 continue;
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
 
                                 /* check main status, clearing INTRQ */
@@ -502,7 +541,20 @@ static inline unsigned int adma_intr_mmio(struct ata_host *host)
                                 /* complete taskfile transaction */
                                 pp->state = adma_state_idle;
                                 qc->err_mask |= ac_err_mask(status);
-                                ata_qc_complete(qc);
+                                if (!qc->err_mask)
+                                        ata_qc_complete(qc);
+                                else {
+                                        struct ata_eh_info *ehi =
+                                                &ap->link.eh_info;
+                                        ata_ehi_clear_desc(ehi);
+                                        ata_ehi_push_desc(ehi,
+                                                "status 0x%02X", status);
+
+                                        if (qc->err_mask == AC_ERR_DEV)
+                                                ata_port_abort(ap);
+                                        else
+                                                ata_port_freeze(ap);
+                                }
                                 handled = 1;
                         }
                 }
@@ -652,9 +704,16 @@ static int adma_ata_init_one(struct pci_dev *pdev,
         if (rc)
                 return rc;
 
-        for (port_no = 0; port_no < ADMA_PORTS; ++port_no)
-                adma_ata_setup_port(&host->ports[port_no]->ioaddr,
-                                    ADMA_ATA_REGS(mmio_base, port_no));
+        for (port_no = 0; port_no < ADMA_PORTS; ++port_no) {
+                struct ata_port *ap = host->ports[port_no];
+                void __iomem *port_base = ADMA_ATA_REGS(mmio_base, port_no);
+                unsigned int offset = port_base - mmio_base;
+
+                adma_ata_setup_port(&ap->ioaddr, port_base);
+
+                ata_port_pbar_desc(ap, ADMA_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, ADMA_MMIO_BAR, offset, "port");
+        }
 
         /* initialize adapter */
         adma_host_init(host, board_idx);
diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index fdbed8ecdfc2..08595f34b3e8 100644
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -285,7 +285,7 @@ static void inic_irq_clear(struct ata_port *ap)
 static void inic_host_intr(struct ata_port *ap)
 {
         void __iomem *port_base = inic_port_base(ap);
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
         u8 irq_stat;
 
         /* fetch and clear irq */
@@ -293,7 +293,8 @@ static void inic_host_intr(struct ata_port *ap)
         writeb(irq_stat, port_base + PORT_IRQ_STAT);
 
         if (likely(!(irq_stat & PIRQ_ERR))) {
-                struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+                struct ata_queued_cmd *qc =
+                        ata_qc_from_tag(ap, ap->link.active_tag);
 
                 if (unlikely(!qc || (qc->tf.flags & ATA_TFLAG_POLLING))) {
                         ata_chk_status(ap);     /* clear ATA interrupt */
@@ -416,12 +417,13 @@ static void inic_thaw(struct ata_port *ap)
  * SRST and SControl hardreset don't give valid signature on this
  * controller.  Only controller specific hardreset mechanism works.
  */
-static int inic_hardreset(struct ata_port *ap, unsigned int *class,
+static int inic_hardreset(struct ata_link *link, unsigned int *class,
                           unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         void __iomem *port_base = inic_port_base(ap);
         void __iomem *idma_ctl = port_base + PORT_IDMA_CTL;
-        const unsigned long *timing = sata_ehc_deb_timing(&ap->eh_context);
+        const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
         u16 val;
         int rc;
 
@@ -434,15 +436,15 @@ static int inic_hardreset(struct ata_port *ap, unsigned int *class,
         msleep(1);
         writew(val & ~IDMA_CTL_RST_ATA, idma_ctl);
 
-        rc = sata_phy_resume(ap, timing, deadline);
+        rc = sata_link_resume(link, timing, deadline);
         if (rc) {
-                ata_port_printk(ap, KERN_WARNING, "failed to resume "
+                ata_link_printk(link, KERN_WARNING, "failed to resume "
                                 "link after reset (errno=%d)\n", rc);
                 return rc;
         }
 
         *class = ATA_DEV_NONE;
-        if (ata_port_online(ap)) {
+        if (ata_link_online(link)) {
                 struct ata_taskfile tf;
 
                 /* wait a while before checking status */
@@ -451,7 +453,7 @@ static int inic_hardreset(struct ata_port *ap, unsigned int *class,
                 rc = ata_wait_ready(ap, deadline);
                 /* link occupied, -ENODEV too is an error */
                 if (rc) {
-                        ata_port_printk(ap, KERN_WARNING, "device not ready "
+                        ata_link_printk(link, KERN_WARNING, "device not ready "
                                         "after hardreset (errno=%d)\n", rc);
                         return rc;
                 }
@@ -550,7 +552,6 @@ static int inic_port_start(struct ata_port *ap)
 }
 
 static struct ata_port_operations inic_port_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -567,7 +568,6 @@ static struct ata_port_operations inic_port_ops = {
 
         .irq_clear              = inic_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .qc_prep                = ata_qc_prep,
         .qc_issue               = inic_qc_issue,
@@ -693,16 +693,24 @@ static int inic_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         host->iomap = iomap = pcim_iomap_table(pdev);
 
         for (i = 0; i < NR_PORTS; i++) {
-                struct ata_ioports *port = &host->ports[i]->ioaddr;
-                void __iomem *port_base = iomap[MMIO_BAR] + i * PORT_SIZE;
+                struct ata_port *ap = host->ports[i];
+                struct ata_ioports *port = &ap->ioaddr;
+                unsigned int offset = i * PORT_SIZE;
 
                 port->cmd_addr = iomap[2 * i];
                 port->altstatus_addr =
                 port->ctl_addr = (void __iomem *)
                         ((unsigned long)iomap[2 * i + 1] | ATA_PCI_CTL_OFS);
-                port->scr_addr = port_base + PORT_SCR;
+                port->scr_addr = iomap[MMIO_BAR] + offset + PORT_SCR;
 
                 ata_std_ports(port);
+
+                ata_port_pbar_desc(ap, MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, MMIO_BAR, offset, "port");
+                ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
+                  (unsigned long long)pci_resource_start(pdev, 2 * i),
+                  (unsigned long long)pci_resource_start(pdev, (2 * i + 1)) |
+                                      ATA_PCI_CTL_OFS);
         }
 
         hpriv->cached_hctl = readw(iomap[MMIO_BAR] + HOST_CTL);
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index d9832e234e44..4df8311968e9 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -483,8 +483,6 @@ static struct scsi_host_template mv6_sht = {
 };
 
 static const struct ata_port_operations mv5_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -499,7 +497,6 @@ static const struct ata_port_operations mv5_ops = {
 
         .irq_clear              = mv_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .error_handler          = mv_error_handler,
         .post_internal_cmd      = mv_post_int_cmd,
@@ -514,8 +511,6 @@ static const struct ata_port_operations mv5_ops = {
 };
 
 static const struct ata_port_operations mv6_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -530,7 +525,6 @@ static const struct ata_port_operations mv6_ops = {
 
         .irq_clear              = mv_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .error_handler          = mv_error_handler,
         .post_internal_cmd      = mv_post_int_cmd,
@@ -545,8 +539,6 @@ static const struct ata_port_operations mv6_ops = {
 };
 
 static const struct ata_port_operations mv_iie_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -561,7 +553,6 @@ static const struct ata_port_operations mv_iie_ops = {
 
         .irq_clear              = mv_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .error_handler          = mv_error_handler,
         .post_internal_cmd      = mv_post_int_cmd,
@@ -1415,7 +1406,7 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
         struct mv_host_priv *hpriv = ap->host->private_data;
         unsigned int edma_enabled = (pp->pp_flags & MV_PP_FLAG_EDMA_EN);
         unsigned int action = 0, err_mask = 0;
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
 
         ata_ehi_clear_desc(ehi);
 
@@ -1423,8 +1414,8 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
                 /* just a guess: do we need to do this? should we
                  * expand this, and do it in all cases?
                  */
-                sata_scr_read(ap, SCR_ERROR, &serr);
-                sata_scr_write_flush(ap, SCR_ERROR, serr);
+                sata_scr_read(&ap->link, SCR_ERROR, &serr);
+                sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
         }
 
         edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
@@ -1468,8 +1459,8 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
                 }
 
                 if (edma_err_cause & EDMA_ERR_SERR) {
-                        sata_scr_read(ap, SCR_ERROR, &serr);
-                        sata_scr_write_flush(ap, SCR_ERROR, serr);
+                        sata_scr_read(&ap->link, SCR_ERROR, &serr);
+                        sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
                         err_mask = AC_ERR_ATA_BUS;
                         action |= ATA_EH_HARDRESET;
                 }
@@ -1508,7 +1499,7 @@ static void mv_intr_pio(struct ata_port *ap)
                 return;
 
         /* get active ATA command */
-        qc = ata_qc_from_tag(ap, ap->active_tag);
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
         if (unlikely(!qc))                      /* no active tag */
                 return;
         if (qc->tf.flags & ATA_TFLAG_POLLING)   /* polling; we don't own qc */
@@ -1543,7 +1534,7 @@ static void mv_intr_edma(struct ata_port *ap)
 
                 /* 50xx: get active ATA command */
                 if (IS_GEN_I(hpriv))
-                        tag = ap->active_tag;
+                        tag = ap->link.active_tag;
 
                 /* Gen II/IIE: get active ATA command via tag, to enable
                  * support for queueing.  this works transparently for
@@ -1646,7 +1637,7 @@ static void mv_host_intr(struct ata_host *host, u32 relevant, unsigned int hc)
                 if (unlikely(have_err_bits)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (qc->tf.flags & ATA_TFLAG_POLLING))
                                 continue;
 
@@ -1687,15 +1678,15 @@ static void mv_pci_error(struct ata_host *host, void __iomem *mmio)
 
         for (i = 0; i < host->n_ports; i++) {
                 ap = host->ports[i];
-                if (!ata_port_offline(ap)) {
-                        ehi = &ap->eh_info;
+                if (!ata_link_offline(&ap->link)) {
+                        ehi = &ap->link.eh_info;
                         ata_ehi_clear_desc(ehi);
                         if (!printed++)
                                 ata_ehi_push_desc(ehi,
                                         "PCI err cause 0x%08x", err_cause);
                         err_mask = AC_ERR_HOST_BUS;
                         ehi->action = ATA_EH_HARDRESET;
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc)
                                 qc->err_mask |= err_mask;
                         else
@@ -2198,14 +2189,14 @@ static void mv_phy_reset(struct ata_port *ap, unsigned int *class,
 
         /* Issue COMRESET via SControl */
 comreset_retry:
-        sata_scr_write_flush(ap, SCR_CONTROL, 0x301);
+        sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x301);
         msleep(1);
 
-        sata_scr_write_flush(ap, SCR_CONTROL, 0x300);
+        sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x300);
         msleep(20);
 
         do {
-                sata_scr_read(ap, SCR_STATUS, &sstatus);
+                sata_scr_read(&ap->link, SCR_STATUS, &sstatus);
                 if (((sstatus & 0x3) == 3) || ((sstatus & 0x3) == 0))
                         break;
 
@@ -2230,7 +2221,7 @@ comreset_retry:
         }
 #endif
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(&ap->link)) {
                 *class = ATA_DEV_NONE;
                 return;
         }
@@ -2257,7 +2248,7 @@ comreset_retry:
          */
 
         /* finally, read device signature from TF registers */
-        *class = ata_dev_try_classify(ap, 0, NULL);
+        *class = ata_dev_try_classify(ap->link.device, 1, NULL);
 
         writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
 
@@ -2266,10 +2257,11 @@ comreset_retry:
         VPRINTK("EXIT\n");
 }
 
-static int mv_prereset(struct ata_port *ap, unsigned long deadline)
+static int mv_prereset(struct ata_link *link, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct mv_port_priv *pp = ap->private_data;
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_eh_context *ehc = &link->eh_context;
         int rc;
 
         rc = mv_stop_dma(ap);
@@ -2285,7 +2277,7 @@ static int mv_prereset(struct ata_port *ap, unsigned long deadline)
         if (ehc->i.action & ATA_EH_HARDRESET)
                 return 0;
 
-        if (ata_port_online(ap))
+        if (ata_link_online(link))
                 rc = ata_wait_ready(ap, deadline);
         else
                 rc = -ENODEV;
@@ -2293,9 +2285,10 @@ static int mv_prereset(struct ata_port *ap, unsigned long deadline)
         return rc;
 }
 
-static int mv_hardreset(struct ata_port *ap, unsigned int *class,
+static int mv_hardreset(struct ata_link *link, unsigned int *class,
                         unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         struct mv_host_priv *hpriv = ap->host->private_data;
         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
 
@@ -2308,16 +2301,17 @@ static int mv_hardreset(struct ata_port *ap, unsigned int *class,
         return 0;
 }
 
-static void mv_postreset(struct ata_port *ap, unsigned int *classes)
+static void mv_postreset(struct ata_link *link, unsigned int *classes)
 {
+        struct ata_port *ap = link->ap;
         u32 serr;
 
         /* print link status */
-        sata_print_link_status(ap);
+        sata_print_link_status(link);
 
         /* clear SError */
-        sata_scr_read(ap, SCR_ERROR, &serr);
-        sata_scr_write_flush(ap, SCR_ERROR, serr);
+        sata_scr_read(link, SCR_ERROR, &serr);
+        sata_scr_write_flush(link, SCR_ERROR, serr);
 
         /* bail out if no device is present */
         if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
@@ -2590,8 +2584,14 @@ static int mv_init_host(struct ata_host *host, unsigned int board_idx)
         }
 
         for (port = 0; port < host->n_ports; port++) {
+                struct ata_port *ap = host->ports[port];
                 void __iomem *port_mmio = mv_port_base(mmio, port);
-                mv_port_init(&host->ports[port]->ioaddr, port_mmio);
+                unsigned int offset = port_mmio - mmio;
+
+                mv_port_init(&ap->ioaddr, port_mmio);
+
+                ata_port_pbar_desc(ap, MV_PRIMARY_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, MV_PRIMARY_BAR, offset, "port");
         }
 
         for (hc = 0; hc < n_hc; hc++) {
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 40dc73139858..40557fe2ffdf 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -340,7 +340,6 @@ static struct scsi_host_template nv_adma_sht = {
 };
 
 static const struct ata_port_operations nv_generic_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
@@ -359,14 +358,12 @@ static const struct ata_port_operations nv_generic_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = nv_scr_read,
         .scr_write              = nv_scr_write,
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations nv_nf2_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
@@ -385,14 +382,12 @@ static const struct ata_port_operations nv_nf2_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = nv_scr_read,
         .scr_write              = nv_scr_write,
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations nv_ck804_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .exec_command           = ata_exec_command,
@@ -411,7 +406,6 @@ static const struct ata_port_operations nv_ck804_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = nv_scr_read,
         .scr_write              = nv_scr_write,
         .port_start             = ata_port_start,
@@ -419,7 +413,6 @@ static const struct ata_port_operations nv_ck804_ops = {
 };
 
 static const struct ata_port_operations nv_adma_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = nv_adma_tf_read,
         .check_atapi_dma        = nv_adma_check_atapi_dma,
@@ -430,6 +423,7 @@ static const struct ata_port_operations nv_adma_ops = {
         .bmdma_start            = ata_bmdma_start,
         .bmdma_stop             = ata_bmdma_stop,
         .bmdma_status           = ata_bmdma_status,
+        .qc_defer               = ata_std_qc_defer,
         .qc_prep                = nv_adma_qc_prep,
         .qc_issue               = nv_adma_qc_issue,
         .freeze                 = nv_adma_freeze,
@@ -439,7 +433,6 @@ static const struct ata_port_operations nv_adma_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = nv_adma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = nv_scr_read,
         .scr_write              = nv_scr_write,
         .port_start             = nv_adma_port_start,
@@ -455,8 +448,8 @@ static const struct ata_port_info nv_port_info[] = {
         /* generic */
         {
                 .sht            = &nv_sht,
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_HRST_TO_RESUME,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .link_flags     = ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -466,8 +459,8 @@ static const struct ata_port_info nv_port_info[] = {
         /* nforce2/3 */
         {
                 .sht            = &nv_sht,
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_HRST_TO_RESUME,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .link_flags     = ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -477,8 +470,8 @@ static const struct ata_port_info nv_port_info[] = {
         /* ck804 */
         {
                 .sht            = &nv_sht,
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_HRST_TO_RESUME,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .link_flags     = ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -489,8 +482,8 @@ static const struct ata_port_info nv_port_info[] = {
         {
                 .sht            = &nv_adma_sht,
                 .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_HRST_TO_RESUME |
                                   ATA_FLAG_MMIO | ATA_FLAG_NCQ,
+                .link_flags     = ATA_LFLAG_HRST_TO_RESUME,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -594,7 +587,7 @@ static int nv_adma_slave_config(struct scsi_device *sdev)
                 /* Not a proper libata device, ignore */
                 return rc;
 
-        if (ap->device[sdev->id].class == ATA_DEV_ATAPI) {
+        if (ap->link.device[sdev->id].class == ATA_DEV_ATAPI) {
                 /*
                  * NVIDIA reports that ADMA mode does not support ATAPI commands.
                  * Therefore ATAPI commands are sent through the legacy interface.
@@ -711,7 +704,7 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
                      flags & (NV_CPB_RESP_ATA_ERR |
                               NV_CPB_RESP_CMD_ERR |
                               NV_CPB_RESP_CPB_ERR)))) {
-                struct ata_eh_info *ehi = &ap->eh_info;
+                struct ata_eh_info *ehi = &ap->link.eh_info;
                 int freeze = 0;
 
                 ata_ehi_clear_desc(ehi);
@@ -747,7 +740,7 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
                         DPRINTK("Completing qc from tag %d\n",cpb_num);
                         ata_qc_complete(qc);
                 } else {
-                        struct ata_eh_info *ehi = &ap->eh_info;
+                        struct ata_eh_info *ehi = &ap->link.eh_info;
                         /* Notifier bits set without a command may indicate the drive
                            is misbehaving. Raise host state machine violation on this
                            condition. */
@@ -764,7 +757,7 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
 
 static int nv_host_intr(struct ata_port *ap, u8 irq_stat)
 {
-        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
 
         /* freeze if hotplugged */
         if (unlikely(irq_stat & (NV_INT_ADDED | NV_INT_REMOVED))) {
@@ -817,7 +810,7 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                         if (pp->flags & NV_ADMA_PORT_REGISTER_MODE) {
                                 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
                                         >> (NV_INT_PORT_SHIFT * i);
-                                if(ata_tag_valid(ap->active_tag))
+                                if(ata_tag_valid(ap->link.active_tag))
                                         /** NV_INT_DEV indication seems unreliable at times
                                             at least in ADMA mode. Force it on always when a
                                             command is active, to prevent losing interrupts. */
@@ -852,7 +845,7 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                                                NV_ADMA_STAT_HOTUNPLUG |
                                                NV_ADMA_STAT_TIMEOUT |
                                                NV_ADMA_STAT_SERROR))) {
-                                struct ata_eh_info *ehi = &ap->eh_info;
+                                struct ata_eh_info *ehi = &ap->link.eh_info;
 
                                 ata_ehi_clear_desc(ehi);
                                 __ata_ehi_push_desc(ehi, "ADMA status 0x%08x: ", status );
@@ -879,10 +872,10 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                                 u32 check_commands;
                                 int pos, error = 0;
 
-                                if(ata_tag_valid(ap->active_tag))
-                                        check_commands = 1 << ap->active_tag;
+                                if(ata_tag_valid(ap->link.active_tag))
+                                        check_commands = 1 << ap->link.active_tag;
                                 else
-                                        check_commands = ap->sactive;
+                                        check_commands = ap->link.sactive;
 
                                 /** Check CPBs for completed commands */
                                 while ((pos = ffs(check_commands)) && !error) {
@@ -1333,7 +1326,7 @@ static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance)
                     !(ap->flags & ATA_FLAG_DISABLED)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                 handled += ata_host_intr(ap, qc);
                         else
@@ -1459,7 +1452,7 @@ static void nv_ck804_thaw(struct ata_port *ap)
         writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
 }
 
-static int nv_hardreset(struct ata_port *ap, unsigned int *class,
+static int nv_hardreset(struct ata_link *link, unsigned int *class,
                         unsigned long deadline)
 {
         unsigned int dummy;
@@ -1468,7 +1461,7 @@ static int nv_hardreset(struct ata_port *ap, unsigned int *class,
          * some controllers.  Don't classify on hardreset.  For more
          * info, see http://bugme.osdl.org/show_bug.cgi?id=3352
          */
-        return sata_std_hardreset(ap, &dummy, deadline);
+        return sata_std_hardreset(link, &dummy, deadline);
 }
 
 static void nv_error_handler(struct ata_port *ap)
@@ -1485,7 +1478,7 @@ static void nv_adma_error_handler(struct ata_port *ap)
                 int i;
                 u16 tmp;
 
-                if(ata_tag_valid(ap->active_tag) || ap->sactive) {
+                if(ata_tag_valid(ap->link.active_tag) || ap->link.sactive) {
                         u32 notifier = readl(mmio + NV_ADMA_NOTIFIER);
                         u32 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
                         u32 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
@@ -1501,8 +1494,8 @@ static void nv_adma_error_handler(struct ata_port *ap)
 
                         for( i=0;i<NV_ADMA_MAX_CPBS;i++) {
                                 struct nv_adma_cpb *cpb = &pp->cpb[i];
-                                if( (ata_tag_valid(ap->active_tag) && i == ap->active_tag) ||
-                                    ap->sactive & (1 << i) )
+                                if( (ata_tag_valid(ap->link.active_tag) && i == ap->link.active_tag) ||
+                                    ap->link.sactive & (1 << i) )
                                         ata_port_printk(ap, KERN_ERR,
                                                 "CPB %d: ctl_flags 0x%x, resp_flags 0x%x\n",
                                                 i, cpb->ctl_flags, cpb->resp_flags);
diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index 25698cf0dce0..903213153b5d 100644
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -167,7 +167,6 @@ static struct scsi_host_template pdc_ata_sht = {
 };
 
 static const struct ata_port_operations pdc_sata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -185,7 +184,6 @@ static const struct ata_port_operations pdc_sata_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = pdc_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .scr_read               = pdc_sata_scr_read,
         .scr_write              = pdc_sata_scr_write,
@@ -194,7 +192,6 @@ static const struct ata_port_operations pdc_sata_ops = {
 
 /* First-generation chips need a more restrictive ->check_atapi_dma op */
 static const struct ata_port_operations pdc_old_sata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -212,7 +209,6 @@ static const struct ata_port_operations pdc_old_sata_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = pdc_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .scr_read               = pdc_sata_scr_read,
         .scr_write              = pdc_sata_scr_write,
@@ -220,7 +216,6 @@ static const struct ata_port_operations pdc_old_sata_ops = {
 };
 
 static const struct ata_port_operations pdc_pata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -238,7 +233,6 @@ static const struct ata_port_operations pdc_pata_ops = {
         .data_xfer              = ata_data_xfer,
         .irq_clear              = pdc_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = pdc_common_port_start,
 };
@@ -475,7 +469,7 @@ static void pdc_atapi_pkt(struct ata_queued_cmd *qc)
         buf32[2] = 0;                           /* no next-packet */
 
         /* select drive */
-        if (sata_scr_valid(ap)) {
+        if (sata_scr_valid(&ap->link)) {
                 dev_sel = PDC_DEVICE_SATA;
         } else {
                 dev_sel = ATA_DEVICE_OBS;
@@ -626,7 +620,7 @@ static void pdc_post_internal_cmd(struct ata_queued_cmd *qc)
 static void pdc_error_intr(struct ata_port *ap, struct ata_queued_cmd *qc,
                            u32 port_status, u32 err_mask)
 {
-        struct ata_eh_info *ehi = &ap->eh_info;
+        struct ata_eh_info *ehi = &ap->link.eh_info;
         unsigned int ac_err_mask = 0;
 
         ata_ehi_clear_desc(ehi);
@@ -643,7 +637,7 @@ static void pdc_error_intr(struct ata_port *ap, struct ata_queued_cmd *qc,
                            | PDC_PCI_SYS_ERR | PDC1_PCI_PARITY_ERR))
                 ac_err_mask |= AC_ERR_HOST_BUS;
 
-        if (sata_scr_valid(ap)) {
+        if (sata_scr_valid(&ap->link)) {
                 u32 serror;
 
                 pdc_sata_scr_read(ap, SCR_ERROR, &serror);
@@ -773,7 +767,7 @@ static irqreturn_t pdc_interrupt (int irq, void *dev_instance)
                 tmp = hotplug_status & (0x11 << ata_no);
                 if (tmp && ap &&
                     !(ap->flags & ATA_FLAG_DISABLED)) {
-                        struct ata_eh_info *ehi = &ap->eh_info;
+                        struct ata_eh_info *ehi = &ap->link.eh_info;
                         ata_ehi_clear_desc(ehi);
                         ata_ehi_hotplugged(ehi);
                         ata_ehi_push_desc(ehi, "hotplug_status %#x", tmp);
@@ -788,7 +782,7 @@ static irqreturn_t pdc_interrupt (int irq, void *dev_instance)
                     !(ap->flags & ATA_FLAG_DISABLED)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                 handled += pdc_host_intr(ap, qc);
                 }
@@ -1009,10 +1003,15 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
 
         is_sataii_tx4 = pdc_is_sataii_tx4(pi->flags);
         for (i = 0; i < host->n_ports; i++) {
+                struct ata_port *ap = host->ports[i];
                 unsigned int ata_no = pdc_port_no_to_ata_no(i, is_sataii_tx4);
-                pdc_ata_setup_port(host->ports[i],
-                                   base + 0x200 + ata_no * 0x80,
-                                   base + 0x400 + ata_no * 0x100);
+                unsigned int port_offset = 0x200 + ata_no * 0x80;
+                unsigned int scr_offset = 0x400 + ata_no * 0x100;
+
+                pdc_ata_setup_port(ap, base + port_offset, base + scr_offset);
+
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, port_offset, "port");
         }
 
         /* initialize adapter */
diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index 5e1dfdda698f..c4c4cd29eebb 100644
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -145,7 +145,6 @@ static struct scsi_host_template qs_ata_sht = {
 };
 
 static const struct ata_port_operations qs_ata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -159,7 +158,6 @@ static const struct ata_port_operations qs_ata_ops = {
         .eng_timeout            = qs_eng_timeout,
         .irq_clear              = qs_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = qs_scr_read,
         .scr_write              = qs_scr_write,
         .port_start             = qs_port_start,
@@ -404,7 +402,7 @@ static inline unsigned int qs_intr_pkt(struct ata_host *host)
                                 struct qs_port_priv *pp = ap->private_data;
                                 if (!pp || pp->state != qs_state_pkt)
                                         continue;
-                                qc = ata_qc_from_tag(ap, ap->active_tag);
+                                qc = ata_qc_from_tag(ap, ap->link.active_tag);
                                 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
                                         switch (sHST) {
                                         case 0: /* successful CPB */
@@ -437,7 +435,7 @@ static inline unsigned int qs_intr_mmio(struct ata_host *host)
                         struct qs_port_priv *pp = ap->private_data;
                         if (!pp || pp->state != qs_state_mmio)
                                 continue;
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
 
                                 /* check main status, clearing INTRQ */
@@ -637,9 +635,14 @@ static int qs_ata_init_one(struct pci_dev *pdev,
                 return rc;
 
         for (port_no = 0; port_no < host->n_ports; ++port_no) {
-                void __iomem *chan =
-                        host->iomap[QS_MMIO_BAR] + (port_no * 0x4000);
-                qs_ata_setup_port(&host->ports[port_no]->ioaddr, chan);
+                struct ata_port *ap = host->ports[port_no];
+                unsigned int offset = port_no * 0x4000;
+                void __iomem *chan = host->iomap[QS_MMIO_BAR] + offset;
+
+                qs_ata_setup_port(&ap->ioaddr, chan);
+
+                ata_port_pbar_desc(ap, QS_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, QS_MMIO_BAR, offset, "port");
         }
 
         /* initialize adapter */
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 8c72e714b456..ea3a0ab7e027 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -59,7 +59,8 @@ enum {
         SIL_FLAG_MOD15WRITE     = (1 << 30),
 
         SIL_DFL_PORT_FLAGS      = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_HRST_TO_RESUME,
+                                  ATA_FLAG_MMIO,
+        SIL_DFL_LINK_FLAGS      = ATA_LFLAG_HRST_TO_RESUME,
 
         /*
          * Controller IDs
@@ -117,7 +118,7 @@ static int sil_pci_device_resume(struct pci_dev *pdev);
 static void sil_dev_config(struct ata_device *dev);
 static int sil_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
 static int sil_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
-static int sil_set_mode (struct ata_port *ap, struct ata_device **r_failed);
+static int sil_set_mode(struct ata_link *link, struct ata_device **r_failed);
 static void sil_freeze(struct ata_port *ap);
 static void sil_thaw(struct ata_port *ap);
 
@@ -185,7 +186,6 @@ static struct scsi_host_template sil_sht = {
 };
 
 static const struct ata_port_operations sil_ops = {
-        .port_disable           = ata_port_disable,
         .dev_config             = sil_dev_config,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
@@ -206,7 +206,6 @@ static const struct ata_port_operations sil_ops = {
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = sil_scr_read,
         .scr_write              = sil_scr_write,
         .port_start             = ata_port_start,
@@ -216,6 +215,7 @@ static const struct ata_port_info sil_port_info[] = {
         /* sil_3112 */
         {
                 .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_MOD15WRITE,
+                .link_flags     = SIL_DFL_LINK_FLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,
@@ -225,6 +225,7 @@ static const struct ata_port_info sil_port_info[] = {
         {
                 .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_MOD15WRITE |
                                   SIL_FLAG_NO_SATA_IRQ,
+                .link_flags     = SIL_DFL_LINK_FLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,
@@ -233,6 +234,7 @@ static const struct ata_port_info sil_port_info[] = {
         /* sil_3512 */
         {
                 .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_RERR_ON_DMA_ACT,
+                .link_flags     = SIL_DFL_LINK_FLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,
@@ -241,6 +243,7 @@ static const struct ata_port_info sil_port_info[] = {
         /* sil_3114 */
         {
                 .flags          = SIL_DFL_PORT_FLAGS | SIL_FLAG_RERR_ON_DMA_ACT,
+                .link_flags     = SIL_DFL_LINK_FLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,
@@ -290,35 +293,33 @@ static unsigned char sil_get_device_cache_line(struct pci_dev *pdev)
 
 /**
  *      sil_set_mode            -       wrap set_mode functions
- *      @ap: port to set up
+ *      @link: link to set up
  *      @r_failed: returned device when we fail
  *
  *      Wrap the libata method for device setup as after the setup we need
  *      to inspect the results and do some configuration work
  */
 
-static int sil_set_mode (struct ata_port *ap, struct ata_device **r_failed)
+static int sil_set_mode(struct ata_link *link, struct ata_device **r_failed)
 {
-        struct ata_host *host = ap->host;
-        struct ata_device *dev;
-        void __iomem *mmio_base = host->iomap[SIL_MMIO_BAR];
+        struct ata_port *ap = link->ap;
+        void __iomem *mmio_base = ap->host->iomap[SIL_MMIO_BAR];
         void __iomem *addr = mmio_base + sil_port[ap->port_no].xfer_mode;
-        u32 tmp, dev_mode[2];
-        unsigned int i;
+        struct ata_device *dev;
+        u32 tmp, dev_mode[2] = { };
         int rc;
 
-        rc = ata_do_set_mode(ap, r_failed);
+        rc = ata_do_set_mode(link, r_failed);
         if (rc)
                 return rc;
 
-        for (i = 0; i < 2; i++) {
-                dev = &ap->device[i];
+        ata_link_for_each_dev(dev, link) {
                 if (!ata_dev_enabled(dev))
-                        dev_mode[i] = 0;        /* PIO0/1/2 */
+                        dev_mode[dev->devno] = 0;       /* PIO0/1/2 */
                 else if (dev->flags & ATA_DFLAG_PIO)
-                        dev_mode[i] = 1;        /* PIO3/4 */
+                        dev_mode[dev->devno] = 1;       /* PIO3/4 */
                 else
-                        dev_mode[i] = 3;        /* UDMA */
+                        dev_mode[dev->devno] = 3;       /* UDMA */
                 /* value 2 indicates MDMA */
         }
 
@@ -374,8 +375,8 @@ static int sil_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 
 static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
 {
-        struct ata_eh_info *ehi = &ap->eh_info;
-        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
+        struct ata_eh_info *ehi = &ap->link.eh_info;
+        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
         u8 status;
 
         if (unlikely(bmdma2 & SIL_DMA_SATA_IRQ)) {
@@ -394,8 +395,8 @@ static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
                  * repeat probing needlessly.
                  */
                 if (!(ap->pflags & ATA_PFLAG_FROZEN)) {
-                        ata_ehi_hotplugged(&ap->eh_info);
-                        ap->eh_info.serror |= serror;
+                        ata_ehi_hotplugged(&ap->link.eh_info);
+                        ap->link.eh_info.serror |= serror;
                 }
 
                 goto freeze;
@@ -562,8 +563,8 @@ static void sil_thaw(struct ata_port *ap)
  */
 static void sil_dev_config(struct ata_device *dev)
 {
-        struct ata_port *ap = dev->ap;
-        int print_info = ap->eh_context.i.flags & ATA_EHI_PRINTINFO;
+        struct ata_port *ap = dev->link->ap;
+        int print_info = ap->link.eh_context.i.flags & ATA_EHI_PRINTINFO;
         unsigned int n, quirks = 0;
         unsigned char model_num[ATA_ID_PROD_LEN + 1];
 
@@ -686,7 +687,8 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         mmio_base = host->iomap[SIL_MMIO_BAR];
 
         for (i = 0; i < host->n_ports; i++) {
-                struct ata_ioports *ioaddr = &host->ports[i]->ioaddr;
+                struct ata_port *ap = host->ports[i];
+                struct ata_ioports *ioaddr = &ap->ioaddr;
 
                 ioaddr->cmd_addr = mmio_base + sil_port[i].tf;
                 ioaddr->altstatus_addr =
@@ -694,6 +696,9 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 ioaddr->bmdma_addr = mmio_base + sil_port[i].bmdma;
                 ioaddr->scr_addr = mmio_base + sil_port[i].scr;
                 ata_std_ports(ioaddr);
+
+                ata_port_pbar_desc(ap, SIL_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, SIL_MMIO_BAR, sil_port[i].tf, "tf");
         }
 
         /* initialize and activate */
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 233e88693395..b0619278454a 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -30,7 +30,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME        "sata_sil24"
-#define DRV_VERSION     "1.0"
+#define DRV_VERSION     "1.1"
 
 /*
  * Port request block (PRB) 32 bytes
@@ -168,7 +168,7 @@ enum {
 
         DEF_PORT_IRQ            = PORT_IRQ_COMPLETE | PORT_IRQ_ERROR |
                                   PORT_IRQ_PHYRDY_CHG | PORT_IRQ_DEV_XCHG |
-                                  PORT_IRQ_UNK_FIS,
+                                  PORT_IRQ_UNK_FIS | PORT_IRQ_SDB_NOTIFY,
 
         /* bits[27:16] are unmasked (raw) */
         PORT_IRQ_RAW_SHIFT      = 16,
@@ -237,8 +237,9 @@ enum {
         /* host flags */
         SIL24_COMMON_FLAGS      = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                   ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
-                                  ATA_FLAG_NCQ | ATA_FLAG_SKIP_D2H_BSY |
-                                  ATA_FLAG_ACPI_SATA,
+                                  ATA_FLAG_NCQ | ATA_FLAG_ACPI_SATA |
+                                  ATA_FLAG_AN | ATA_FLAG_PMP,
+        SIL24_COMMON_LFLAGS     = ATA_LFLAG_SKIP_D2H_BSY,
         SIL24_FLAG_PCIX_IRQ_WOC = (1 << 24), /* IRQ loss errata on PCI-X */
 
         IRQ_STAT_4PORTS         = 0xf,
@@ -322,6 +323,7 @@ struct sil24_port_priv {
         union sil24_cmd_block *cmd_block;       /* 32 cmd blocks */
         dma_addr_t cmd_block_dma;               /* DMA base addr for them */
         struct ata_taskfile tf;                 /* Cached taskfile registers */
+        int do_port_rst;
 };
 
 static void sil24_dev_config(struct ata_device *dev);
@@ -329,9 +331,12 @@ static u8 sil24_check_status(struct ata_port *ap);
 static int sil24_scr_read(struct ata_port *ap, unsigned sc_reg, u32 *val);
 static int sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val);
 static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
+static int sil24_qc_defer(struct ata_queued_cmd *qc);
 static void sil24_qc_prep(struct ata_queued_cmd *qc);
 static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc);
 static void sil24_irq_clear(struct ata_port *ap);
+static void sil24_pmp_attach(struct ata_port *ap);
+static void sil24_pmp_detach(struct ata_port *ap);
 static void sil24_freeze(struct ata_port *ap);
 static void sil24_thaw(struct ata_port *ap);
 static void sil24_error_handler(struct ata_port *ap);
@@ -340,6 +345,7 @@ static int sil24_port_start(struct ata_port *ap);
 static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 #ifdef CONFIG_PM
 static int sil24_pci_device_resume(struct pci_dev *pdev);
+static int sil24_port_resume(struct ata_port *ap);
 #endif
 
 static const struct pci_device_id sil24_pci_tbl[] = {
@@ -384,8 +390,6 @@ static struct scsi_host_template sil24_sht = {
 };
 
 static const struct ata_port_operations sil24_ops = {
-        .port_disable           = ata_port_disable,
-
         .dev_config             = sil24_dev_config,
 
         .check_status           = sil24_check_status,
@@ -394,22 +398,28 @@ static const struct ata_port_operations sil24_ops = {
 
         .tf_read                = sil24_tf_read,
 
+        .qc_defer               = sil24_qc_defer,
         .qc_prep                = sil24_qc_prep,
         .qc_issue               = sil24_qc_issue,
 
         .irq_clear              = sil24_irq_clear,
-        .irq_on                 = ata_dummy_irq_on,
-        .irq_ack                = ata_dummy_irq_ack,
 
         .scr_read               = sil24_scr_read,
         .scr_write              = sil24_scr_write,
 
+        .pmp_attach             = sil24_pmp_attach,
+        .pmp_detach             = sil24_pmp_detach,
+
         .freeze                 = sil24_freeze,
         .thaw                   = sil24_thaw,
         .error_handler          = sil24_error_handler,
         .post_internal_cmd      = sil24_post_internal_cmd,
 
         .port_start             = sil24_port_start,
+
+#ifdef CONFIG_PM
+        .port_resume            = sil24_port_resume,
+#endif
 };
 
 /*
@@ -424,6 +434,7 @@ static const struct ata_port_info sil24_port_info[] = {
         {
                 .flags          = SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(4) |
                                   SIL24_FLAG_PCIX_IRQ_WOC,
+                .link_flags     = SIL24_COMMON_LFLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,            /* udma0-5 */
@@ -432,6 +443,7 @@ static const struct ata_port_info sil24_port_info[] = {
         /* sil_3132 */
         {
                 .flags          = SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(2),
+                .link_flags     = SIL24_COMMON_LFLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,            /* udma0-5 */
@@ -440,6 +452,7 @@ static const struct ata_port_info sil24_port_info[] = {
         /* sil_3131/sil_3531 */
         {
                 .flags          = SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(1),
+                .link_flags     = SIL24_COMMON_LFLAGS,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = ATA_UDMA5,            /* udma0-5 */
@@ -456,7 +469,7 @@ static int sil24_tag(int tag)
 
 static void sil24_dev_config(struct ata_device *dev)
 {
-        void __iomem *port = dev->ap->ioaddr.cmd_addr;
+        void __iomem *port = dev->link->ap->ioaddr.cmd_addr;
 
         if (dev->cdb_len == 16)
                 writel(PORT_CS_CDB16, port + PORT_CTRL_STAT);
@@ -520,19 +533,78 @@ static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
         *tf = pp->tf;
 }
 
+static void sil24_config_port(struct ata_port *ap)
+{
+        void __iomem *port = ap->ioaddr.cmd_addr;
+
+        /* configure IRQ WoC */
+        if (ap->flags & SIL24_FLAG_PCIX_IRQ_WOC)
+                writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_STAT);
+        else
+                writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_CLR);
+
+        /* zero error counters. */
+        writel(0x8000, port + PORT_DECODE_ERR_THRESH);
+        writel(0x8000, port + PORT_CRC_ERR_THRESH);
+        writel(0x8000, port + PORT_HSHK_ERR_THRESH);
+        writel(0x0000, port + PORT_DECODE_ERR_CNT);
+        writel(0x0000, port + PORT_CRC_ERR_CNT);
+        writel(0x0000, port + PORT_HSHK_ERR_CNT);
+
+        /* always use 64bit activation */
+        writel(PORT_CS_32BIT_ACTV, port + PORT_CTRL_CLR);
+
+        /* clear port multiplier enable and resume bits */
+        writel(PORT_CS_PMP_EN | PORT_CS_PMP_RESUME, port + PORT_CTRL_CLR);
+}
+
+static void sil24_config_pmp(struct ata_port *ap, int attached)
+{
+        void __iomem *port = ap->ioaddr.cmd_addr;
+
+        if (attached)
+                writel(PORT_CS_PMP_EN, port + PORT_CTRL_STAT);
+        else
+                writel(PORT_CS_PMP_EN, port + PORT_CTRL_CLR);
+}
+
+static void sil24_clear_pmp(struct ata_port *ap)
+{
+        void __iomem *port = ap->ioaddr.cmd_addr;
+        int i;
+
+        writel(PORT_CS_PMP_RESUME, port + PORT_CTRL_CLR);
+
+        for (i = 0; i < SATA_PMP_MAX_PORTS; i++) {
+                void __iomem *pmp_base = port + PORT_PMP + i * PORT_PMP_SIZE;
+
+                writel(0, pmp_base + PORT_PMP_STATUS);
+                writel(0, pmp_base + PORT_PMP_QACTIVE);
+        }
+}
+
 static int sil24_init_port(struct ata_port *ap)
 {
         void __iomem *port = ap->ioaddr.cmd_addr;
+        struct sil24_port_priv *pp = ap->private_data;
         u32 tmp;
 
+        /* clear PMP error status */
+        if (ap->nr_pmp_links)
+                sil24_clear_pmp(ap);
+
         writel(PORT_CS_INIT, port + PORT_CTRL_STAT);
         ata_wait_register(port + PORT_CTRL_STAT,
                           PORT_CS_INIT, PORT_CS_INIT, 10, 100);
         tmp = ata_wait_register(port + PORT_CTRL_STAT,
                                 PORT_CS_RDY, 0, 10, 100);
 
-        if ((tmp & (PORT_CS_INIT | PORT_CS_RDY)) != PORT_CS_RDY)
+        if ((tmp & (PORT_CS_INIT | PORT_CS_RDY)) != PORT_CS_RDY) {
+                pp->do_port_rst = 1;
+                ap->link.eh_context.i.action |= ATA_EH_HARDRESET;
                 return -EIO;
+        }
+
         return 0;
 }
 
@@ -583,9 +655,10 @@ static int sil24_exec_polled_cmd(struct ata_port *ap, int pmp,
         return rc;
 }
 
-static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
+static int sil24_do_softreset(struct ata_link *link, unsigned int *class,
                               int pmp, unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         unsigned long timeout_msec = 0;
         struct ata_taskfile tf;
         const char *reason;
@@ -593,7 +666,7 @@ static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
 
         DPRINTK("ENTER\n");
 
-        if (ata_port_offline(ap)) {
+        if (ata_link_offline(link)) {
                 DPRINTK("PHY reports no device\n");
                 *class = ATA_DEV_NONE;
                 goto out;
@@ -609,7 +682,7 @@ static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
         if (time_after(deadline, jiffies))
                 timeout_msec = jiffies_to_msecs(deadline - jiffies);
 
-        ata_tf_init(ap->device, &tf);   /* doesn't really matter */
+        ata_tf_init(link->device, &tf); /* doesn't really matter */
         rc = sil24_exec_polled_cmd(ap, pmp, &tf, 0, PRB_CTRL_SRST,
                                    timeout_msec);
         if (rc == -EBUSY) {
@@ -631,29 +704,54 @@ static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
         return 0;
 
  err:
-        ata_port_printk(ap, KERN_ERR, "softreset failed (%s)\n", reason);
+        ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason);
         return -EIO;
 }
 
-static int sil24_softreset(struct ata_port *ap, unsigned int *class,
+static int sil24_softreset(struct ata_link *link, unsigned int *class,
                            unsigned long deadline)
 {
-        return sil24_do_softreset(ap, class, 0, deadline);
+        return sil24_do_softreset(link, class, SATA_PMP_CTRL_PORT, deadline);
 }
 
-static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
+static int sil24_hardreset(struct ata_link *link, unsigned int *class,
                            unsigned long deadline)
 {
+        struct ata_port *ap = link->ap;
         void __iomem *port = ap->ioaddr.cmd_addr;
+        struct sil24_port_priv *pp = ap->private_data;
+        int did_port_rst = 0;
         const char *reason;
         int tout_msec, rc;
         u32 tmp;
 
+ retry:
+        /* Sometimes, DEV_RST is not enough to recover the controller.
+         * This happens often after PM DMA CS errata.
+         */
+        if (pp->do_port_rst) {
+                ata_port_printk(ap, KERN_WARNING, "controller in dubious "
+                                "state, performing PORT_RST\n");
+
+                writel(PORT_CS_PORT_RST, port + PORT_CTRL_STAT);
+                msleep(10);
+                writel(PORT_CS_PORT_RST, port + PORT_CTRL_CLR);
+                ata_wait_register(port + PORT_CTRL_STAT, PORT_CS_RDY, 0,
+                                  10, 5000);
+
+                /* restore port configuration */
+                sil24_config_port(ap);
+                sil24_config_pmp(ap, ap->nr_pmp_links);
+
+                pp->do_port_rst = 0;
+                did_port_rst = 1;
+        }
+
         /* sil24 does the right thing(tm) without any protection */
-        sata_set_spd(ap);
+        sata_set_spd(link);
 
         tout_msec = 100;
-        if (ata_port_online(ap))
+        if (ata_link_online(link))
                 tout_msec = 5000;
 
         writel(PORT_CS_DEV_RST, port + PORT_CTRL_STAT);
@@ -663,14 +761,14 @@ static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
         /* SStatus oscillates between zero and valid status after
          * DEV_RST, debounce it.
          */
-        rc = sata_phy_debounce(ap, sata_deb_timing_long, deadline);
+        rc = sata_link_debounce(link, sata_deb_timing_long, deadline);
         if (rc) {
                 reason = "PHY debouncing failed";
                 goto err;
         }
 
         if (tmp & PORT_CS_DEV_RST) {
-                if (ata_port_offline(ap))
+                if (ata_link_offline(link))
                         return 0;
                 reason = "link not ready";
                 goto err;
@@ -685,7 +783,12 @@ static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
         return -EAGAIN;
 
  err:
-        ata_port_printk(ap, KERN_ERR, "hardreset failed (%s)\n", reason);
+        if (!did_port_rst) {
+                pp->do_port_rst = 1;
+                goto retry;
+        }
+
+        ata_link_printk(link, KERN_ERR, "hardreset failed (%s)\n", reason);
         return -EIO;
 }
 
@@ -705,6 +808,38 @@ static inline void sil24_fill_sg(struct ata_queued_cmd *qc,
         }
 }
 
+static int sil24_qc_defer(struct ata_queued_cmd *qc)
+{
+        struct ata_link *link = qc->dev->link;
+        struct ata_port *ap = link->ap;
+        u8 prot = qc->tf.protocol;
+        int is_atapi = (prot == ATA_PROT_ATAPI ||
+                        prot == ATA_PROT_ATAPI_NODATA ||
+                        prot == ATA_PROT_ATAPI_DMA);
+
+        /* ATAPI commands completing with CHECK_SENSE cause various
+         * weird problems if other commands are active.  PMP DMA CS
+         * errata doesn't cover all and HSM violation occurs even with
+         * only one other device active.  Always run an ATAPI command
+         * by itself.
+         */
+        if (unlikely(ap->excl_link)) {
+                if (link == ap->excl_link) {
+                        if (ap->nr_active_links)
+                                return ATA_DEFER_PORT;
+                        qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
+                } else
+                        return ATA_DEFER_PORT;
+        } else if (unlikely(is_atapi)) {
+                ap->excl_link = link;
+                if (ap->nr_active_links)
+                        return ATA_DEFER_PORT;
+                qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
+        }
+
+        return ata_std_qc_defer(qc);
+}
+
 static void sil24_qc_prep(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
@@ -748,7 +883,7 @@ static void sil24_qc_prep(struct ata_queued_cmd *qc)
         }
 
         prb->ctrl = cpu_to_le16(ctrl);
-        ata_tf_to_fis(&qc->tf, 0, 1, prb->fis);
+        ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, prb->fis);
 
         if (qc->flags & ATA_QCFLAG_DMAMAP)
                 sil24_fill_sg(qc, sge);
@@ -777,6 +912,39 @@ static void sil24_irq_clear(struct ata_port *ap)
         /* unused */
 }
 
+static void sil24_pmp_attach(struct ata_port *ap)
+{
+        sil24_config_pmp(ap, 1);
+        sil24_init_port(ap);
+}
+
+static void sil24_pmp_detach(struct ata_port *ap)
+{
+        sil24_init_port(ap);
+        sil24_config_pmp(ap, 0);
+}
+
+static int sil24_pmp_softreset(struct ata_link *link, unsigned int *class,
+                               unsigned long deadline)
+{
+        return sil24_do_softreset(link, class, link->pmp, deadline);
+}
+
+static int sil24_pmp_hardreset(struct ata_link *link, unsigned int *class,
+                               unsigned long deadline)
+{
+        int rc;
+
+        rc = sil24_init_port(link->ap);
+        if (rc) {
+                ata_link_printk(link, KERN_ERR,
+                                "hardreset failed (port not ready)\n");
+                return rc;
+        }
+
+        return sata_pmp_std_hardreset(link, class, deadline);
+}
+
 static void sil24_freeze(struct ata_port *ap)
 {
         void __iomem *port = ap->ioaddr.cmd_addr;
@@ -804,8 +972,10 @@ static void sil24_error_intr(struct ata_port *ap)
 {
         void __iomem *port = ap->ioaddr.cmd_addr;
         struct sil24_port_priv *pp = ap->private_data;
-        struct ata_eh_info *ehi = &ap->eh_info;
-        int freeze = 0;
+        struct ata_queued_cmd *qc = NULL;
+        struct ata_link *link;
+        struct ata_eh_info *ehi;
+        int abort = 0, freeze = 0;
         u32 irq_stat;
 
         /* on error, we need to clear IRQ explicitly */
@@ -813,10 +983,17 @@ static void sil24_error_intr(struct ata_port *ap)
         writel(irq_stat, port + PORT_IRQ_STAT);
 
         /* first, analyze and record host port events */
+        link = &ap->link;
+        ehi = &link->eh_info;
         ata_ehi_clear_desc(ehi);
 
         ata_ehi_push_desc(ehi, "irq_stat 0x%08x", irq_stat);
 
+        if (irq_stat & PORT_IRQ_SDB_NOTIFY) {
+                ata_ehi_push_desc(ehi, "SDB notify");
+                sata_async_notification(ap);
+        }
+
         if (irq_stat & (PORT_IRQ_PHYRDY_CHG | PORT_IRQ_DEV_XCHG)) {
                 ata_ehi_hotplugged(ehi);
                 ata_ehi_push_desc(ehi, "%s",
@@ -836,8 +1013,44 @@ static void sil24_error_intr(struct ata_port *ap)
         if (irq_stat & PORT_IRQ_ERROR) {
                 struct sil24_cerr_info *ci = NULL;
                 unsigned int err_mask = 0, action = 0;
-                struct ata_queued_cmd *qc;
-                u32 cerr;
+                u32 context, cerr;
+                int pmp;
+
+                abort = 1;
+
+                /* DMA Context Switch Failure in Port Multiplier Mode
+                 * errata.  If we have active commands to 3 or more
+                 * devices, any error condition on active devices can
+                 * corrupt DMA context switching.
+                 */
+                if (ap->nr_active_links >= 3) {
+                        ehi->err_mask |= AC_ERR_OTHER;
+                        ehi->action |= ATA_EH_HARDRESET;
+                        ata_ehi_push_desc(ehi, "PMP DMA CS errata");
+                        pp->do_port_rst = 1;
+                        freeze = 1;
+                }
+
+                /* find out the offending link and qc */
+                if (ap->nr_pmp_links) {
+                        context = readl(port + PORT_CONTEXT);
+                        pmp = (context >> 5) & 0xf;
+
+                        if (pmp < ap->nr_pmp_links) {
+                                link = &ap->pmp_link[pmp];
+                                ehi = &link->eh_info;
+                                qc = ata_qc_from_tag(ap, link->active_tag);
+
+                                ata_ehi_clear_desc(ehi);
+                                ata_ehi_push_desc(ehi, "irq_stat 0x%08x",
+                                                  irq_stat);
+                        } else {
+                                err_mask |= AC_ERR_HSM;
+                                action |= ATA_EH_HARDRESET;
+                                freeze = 1;
+                        }
+                } else
+                        qc = ata_qc_from_tag(ap, link->active_tag);
 
                 /* analyze CMD_ERR */
                 cerr = readl(port + PORT_CMD_ERR);
@@ -856,7 +1069,6 @@ static void sil24_error_intr(struct ata_port *ap)
                 }
 
                 /* record error info */
-                qc = ata_qc_from_tag(ap, ap->active_tag);
                 if (qc) {
                         sil24_read_tf(ap, qc->tag, &pp->tf);
                         qc->err_mask |= err_mask;
@@ -864,13 +1076,21 @@ static void sil24_error_intr(struct ata_port *ap)
                         ehi->err_mask |= err_mask;
 
                 ehi->action |= action;
+
+                /* if PMP, resume */
+                if (ap->nr_pmp_links)
+                        writel(PORT_CS_PMP_RESUME, port + PORT_CTRL_STAT);
         }
 
         /* freeze or abort */
         if (freeze)
                 ata_port_freeze(ap);
-        else
-                ata_port_abort(ap);
+        else if (abort) {
+                if (qc)
+                        ata_link_abort(qc->dev->link);
+                else
+                        ata_port_abort(ap);
+        }
 }
 
 static void sil24_finish_qc(struct ata_queued_cmd *qc)
@@ -910,7 +1130,7 @@ static inline void sil24_host_intr(struct ata_port *ap)
         if (rc > 0)
                 return;
         if (rc < 0) {
-                struct ata_eh_info *ehi = &ap->eh_info;
+                struct ata_eh_info *ehi = &ap->link.eh_info;
                 ehi->err_mask |= AC_ERR_HSM;
                 ehi->action |= ATA_EH_SOFTRESET;
                 ata_port_freeze(ap);
@@ -921,7 +1141,7 @@ static inline void sil24_host_intr(struct ata_port *ap)
         if (!(ap->flags & SIL24_FLAG_PCIX_IRQ_WOC) && ata_ratelimit())
                 ata_port_printk(ap, KERN_INFO, "spurious interrupt "
                         "(slot_stat 0x%x active_tag %d sactive 0x%x)\n",
-                        slot_stat, ap->active_tag, ap->sactive);
+                        slot_stat, ap->link.active_tag, ap->link.sactive);
 }
 
 static irqreturn_t sil24_interrupt(int irq, void *dev_instance)
@@ -963,16 +1183,18 @@ static irqreturn_t sil24_interrupt(int irq, void *dev_instance)
 
 static void sil24_error_handler(struct ata_port *ap)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct sil24_port_priv *pp = ap->private_data;
 
-        if (sil24_init_port(ap)) {
+        if (sil24_init_port(ap))
                 ata_eh_freeze_port(ap);
-                ehc->i.action |= ATA_EH_HARDRESET;
-        }
 
         /* perform recovery */
-        ata_do_eh(ap, ata_std_prereset, sil24_softreset, sil24_hardreset,
-                  ata_std_postreset);
+        sata_pmp_do_eh(ap, ata_std_prereset, sil24_softreset, sil24_hardreset,
+                       ata_std_postreset, sata_pmp_std_prereset,
+                       sil24_pmp_softreset, sil24_pmp_hardreset,
+                       sata_pmp_std_postreset);
+
+        pp->do_port_rst = 0;
 }
 
 static void sil24_post_internal_cmd(struct ata_queued_cmd *qc)
@@ -980,8 +1202,8 @@ static void sil24_post_internal_cmd(struct ata_queued_cmd *qc)
         struct ata_port *ap = qc->ap;
 
         /* make DMA engine forget about the failed command */
-        if (qc->flags & ATA_QCFLAG_FAILED)
-                sil24_init_port(ap);
+        if ((qc->flags & ATA_QCFLAG_FAILED) && sil24_init_port(ap))
+                ata_eh_freeze_port(ap);
 }
 
 static int sil24_port_start(struct ata_port *ap)
@@ -1019,7 +1241,6 @@ static int sil24_port_start(struct ata_port *ap)
 static void sil24_init_controller(struct ata_host *host)
 {
         void __iomem *host_base = host->iomap[SIL24_HOST_BAR];
-        void __iomem *port_base = host->iomap[SIL24_PORT_BAR];
         u32 tmp;
         int i;
 
@@ -1031,7 +1252,8 @@ static void sil24_init_controller(struct ata_host *host)
 
         /* init ports */
         for (i = 0; i < host->n_ports; i++) {
-                void __iomem *port = port_base + i * PORT_REGS_SIZE;
+                struct ata_port *ap = host->ports[i];
+                void __iomem *port = ap->ioaddr.cmd_addr;
 
                 /* Initial PHY setting */
                 writel(0x20c, port + PORT_PHY_CFG);
@@ -1048,26 +1270,8 @@ static void sil24_init_controller(struct ata_host *host)
                                            "failed to clear port RST\n");
                 }
 
-                /* Configure IRQ WoC */
-                if (host->ports[0]->flags & SIL24_FLAG_PCIX_IRQ_WOC)
-                        writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_STAT);
-                else
-                        writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_CLR);
-
-                /* Zero error counters. */
-                writel(0x8000, port + PORT_DECODE_ERR_THRESH);
-                writel(0x8000, port + PORT_CRC_ERR_THRESH);
-                writel(0x8000, port + PORT_HSHK_ERR_THRESH);
-                writel(0x0000, port + PORT_DECODE_ERR_CNT);
-                writel(0x0000, port + PORT_CRC_ERR_CNT);
-                writel(0x0000, port + PORT_HSHK_ERR_CNT);
-
-                /* Always use 64bit activation */
-                writel(PORT_CS_32BIT_ACTV, port + PORT_CTRL_CLR);
-
-                /* Clear port multiplier enable and resume bits */
-                writel(PORT_CS_PMP_EN | PORT_CS_PMP_RESUME,
-                       port + PORT_CTRL_CLR);
+                /* configure port */
+                sil24_config_port(ap);
         }
 
         /* Turn on interrupts */
@@ -1118,12 +1322,15 @@ static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         host->iomap = iomap;
 
         for (i = 0; i < host->n_ports; i++) {
-                void __iomem *port = iomap[SIL24_PORT_BAR] + i * PORT_REGS_SIZE;
+                struct ata_port *ap = host->ports[i];
+                size_t offset = ap->port_no * PORT_REGS_SIZE;
+                void __iomem *port = iomap[SIL24_PORT_BAR] + offset;
 
                 host->ports[i]->ioaddr.cmd_addr = port;
                 host->ports[i]->ioaddr.scr_addr = port + PORT_SCONTROL;
 
-                ata_std_ports(&host->ports[i]->ioaddr);
+                ata_port_pbar_desc(ap, SIL24_HOST_BAR, -1, "host");
+                ata_port_pbar_desc(ap, SIL24_PORT_BAR, offset, "port");
         }
 
         /* configure and activate the device */
@@ -1179,6 +1386,12 @@ static int sil24_pci_device_resume(struct pci_dev *pdev)
 
         return 0;
 }
+
+static int sil24_port_resume(struct ata_port *ap)
+{
+        sil24_config_pmp(ap, ap->nr_pmp_links);
+        return 0;
+}
 #endif
 
 static int __init sil24_init(void)
diff --git a/drivers/ata/sata_sis.c b/drivers/ata/sata_sis.c
index 41c1d6e8f1fe..8d98a9fb0a42 100644
--- a/drivers/ata/sata_sis.c
+++ b/drivers/ata/sata_sis.c
@@ -104,7 +104,6 @@ static struct scsi_host_template sis_sht = {
 };
 
 static const struct ata_port_operations sis_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -123,7 +122,6 @@ static const struct ata_port_operations sis_ops = {
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = sis_scr_read,
         .scr_write              = sis_scr_write,
         .port_start             = ata_port_start,
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index d9678e7bc3a9..12d613c48c19 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -329,7 +329,6 @@ static struct scsi_host_template k2_sata_sht = {
 
 
 static const struct ata_port_operations k2_sata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = k2_sata_tf_load,
         .tf_read                = k2_sata_tf_read,
         .check_status           = k2_stat_check_status,
@@ -349,7 +348,6 @@ static const struct ata_port_operations k2_sata_ops = {
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = k2_sata_scr_read,
         .scr_write              = k2_sata_scr_write,
         .port_start             = ata_port_start,
@@ -445,9 +443,15 @@ static int k2_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         /* different controllers have different number of ports - currently 4 or 8 */
         /* All ports are on the same function. Multi-function device is no
          * longer available. This should not be seen in any system. */
-        for (i = 0; i < host->n_ports; i++)
-                k2_sata_setup_port(&host->ports[i]->ioaddr,
-                                   mmio_base + i * K2_SATA_PORT_OFFSET);
+        for (i = 0; i < host->n_ports; i++) {
+                struct ata_port *ap = host->ports[i];
+                unsigned int offset = i * K2_SATA_PORT_OFFSET;
+
+                k2_sata_setup_port(&ap->ioaddr, mmio_base + offset);
+
+                ata_port_pbar_desc(ap, 5, -1, "mmio");
+                ata_port_pbar_desc(ap, 5, offset, "port");
+        }
 
         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
         if (rc)
diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index 97aefdd87be4..9f9f7b30654a 100644
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -254,7 +254,6 @@ static struct scsi_host_template pdc_sata_sht = {
 };
 
 static const struct ata_port_operations pdc_20621_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -267,7 +266,6 @@ static const struct ata_port_operations pdc_20621_ops = {
         .eng_timeout            = pdc_eng_timeout,
         .irq_clear              = pdc20621_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .port_start             = pdc_port_start,
 };
 
@@ -854,7 +852,7 @@ static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance)
                     !(ap->flags & ATA_FLAG_DISABLED)) {
                         struct ata_queued_cmd *qc;
 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                        qc = ata_qc_from_tag(ap, ap->link.active_tag);
                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                 handled += pdc20621_host_intr(ap, qc, (i > 4),
                                                               mmio_base);
@@ -881,7 +879,7 @@ static void pdc_eng_timeout(struct ata_port *ap)
 
         spin_lock_irqsave(&host->lock, flags);
 
-        qc = ata_qc_from_tag(ap, ap->active_tag);
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
 
         switch (qc->tf.protocol) {
         case ATA_PROT_DMA:
@@ -1383,9 +1381,8 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
         const struct ata_port_info *ppi[] =
                 { &pdc_port_info[ent->driver_data], NULL };
         struct ata_host *host;
-        void __iomem *base;
         struct pdc_host_priv *hpriv;
-        int rc;
+        int i, rc;
 
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
@@ -1411,11 +1408,17 @@ static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *
                 return rc;
         host->iomap = pcim_iomap_table(pdev);
 
-        base = host->iomap[PDC_MMIO_BAR] + PDC_CHIP0_OFS;
-        pdc_sata_setup_port(&host->ports[0]->ioaddr, base + 0x200);
-        pdc_sata_setup_port(&host->ports[1]->ioaddr, base + 0x280);
-        pdc_sata_setup_port(&host->ports[2]->ioaddr, base + 0x300);
-        pdc_sata_setup_port(&host->ports[3]->ioaddr, base + 0x380);
+        for (i = 0; i < 4; i++) {
+                struct ata_port *ap = host->ports[i];
+                void __iomem *base = host->iomap[PDC_MMIO_BAR] + PDC_CHIP0_OFS;
+                unsigned int offset = 0x200 + i * 0x80;
+
+                pdc_sata_setup_port(&ap->ioaddr, base + offset);
+
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, PDC_DIMM_BAR, -1, "dimm");
+                ata_port_pbar_desc(ap, PDC_MMIO_BAR, offset, "port");
+        }
 
         /* configure and activate */
         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
diff --git a/drivers/ata/sata_uli.c b/drivers/ata/sata_uli.c
index e6b8b45279af..d394da085ae4 100644
--- a/drivers/ata/sata_uli.c
+++ b/drivers/ata/sata_uli.c
@@ -94,8 +94,6 @@ static struct scsi_host_template uli_sht = {
 };
 
 static const struct ata_port_operations uli_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -117,7 +115,6 @@ static const struct ata_port_operations uli_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .scr_read               = uli_scr_read,
         .scr_write              = uli_scr_write,
@@ -242,6 +239,12 @@ static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 hpriv->scr_cfg_addr[2] = ULI5287_BASE + ULI5287_OFFS*4;
                 ata_std_ports(ioaddr);
 
+                ata_port_desc(host->ports[2],
+                        "cmd 0x%llx ctl 0x%llx bmdma 0x%llx",
+                        (unsigned long long)pci_resource_start(pdev, 0) + 8,
+                        ((unsigned long long)pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS) + 4,
+                        (unsigned long long)pci_resource_start(pdev, 4) + 16);
+
                 ioaddr = &host->ports[3]->ioaddr;
                 ioaddr->cmd_addr = iomap[2] + 8;
                 ioaddr->altstatus_addr =
@@ -250,6 +253,13 @@ static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 ioaddr->bmdma_addr = iomap[4] + 24;
                 hpriv->scr_cfg_addr[3] = ULI5287_BASE + ULI5287_OFFS*5;
                 ata_std_ports(ioaddr);
+
+                ata_port_desc(host->ports[2],
+                        "cmd 0x%llx ctl 0x%llx bmdma 0x%llx",
+                        (unsigned long long)pci_resource_start(pdev, 2) + 9,
+                        ((unsigned long long)pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS) + 4,
+                        (unsigned long long)pci_resource_start(pdev, 4) + 24);
+
                 break;
 
         case uli_5289:
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index 57fd30de8f0d..1dc9b4f2b2dc 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -57,7 +57,6 @@ enum {
         SATA_CHAN_ENAB          = 0x40, /* SATA channel enable */
         SATA_INT_GATE           = 0x41, /* SATA interrupt gating */
         SATA_NATIVE_MODE        = 0x42, /* Native mode enable */
-        SATA_PATA_SHARING       = 0x49, /* PATA/SATA sharing func ctrl */
         PATA_UDMA_TIMING        = 0xB3, /* PATA timing for DMA/ cable detect */
         PATA_PIO_TIMING         = 0xAB, /* PATA timing register */
 
@@ -68,7 +67,6 @@ enum {
         NATIVE_MODE_ALL         = (1 << 7) | (1 << 6) | (1 << 5) | (1 << 4),
 
         SATA_EXT_PHY            = (1 << 6), /* 0==use PATA, 1==ext phy */
-        SATA_2DEV               = (1 << 5), /* SATA is master/slave */
 };
 
 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
@@ -122,8 +120,6 @@ static struct scsi_host_template svia_sht = {
 };
 
 static const struct ata_port_operations vt6420_sata_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -146,14 +142,11 @@ static const struct ata_port_operations vt6420_sata_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations vt6421_pata_ops = {
-        .port_disable           = ata_port_disable,
-
         .set_piomode            = vt6421_set_pio_mode,
         .set_dmamode            = vt6421_set_dma_mode,
 
@@ -180,14 +173,11 @@ static const struct ata_port_operations vt6421_pata_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .port_start             = ata_port_start,
 };
 
 static const struct ata_port_operations vt6421_sata_ops = {
-        .port_disable           = ata_port_disable,
-
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
         .check_status           = ata_check_status,
@@ -211,7 +201,6 @@ static const struct ata_port_operations vt6421_sata_ops = {
 
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
 
         .scr_read               = svia_scr_read,
         .scr_write              = svia_scr_write,
@@ -276,7 +265,7 @@ static void svia_noop_freeze(struct ata_port *ap)
 
 /**
  *      vt6420_prereset - prereset for vt6420
- *      @ap: target ATA port
+ *      @link: target ATA link
  *      @deadline: deadline jiffies for the operation
  *
  *      SCR registers on vt6420 are pieces of shit and may hang the
@@ -294,9 +283,10 @@ static void svia_noop_freeze(struct ata_port *ap)
  *      RETURNS:
  *      0 on success, -errno otherwise.
  */
-static int vt6420_prereset(struct ata_port *ap, unsigned long deadline)
+static int vt6420_prereset(struct ata_link *link, unsigned long deadline)
 {
-        struct ata_eh_context *ehc = &ap->eh_context;
+        struct ata_port *ap = link->ap;
+        struct ata_eh_context *ehc = &ap->link.eh_context;
         unsigned long timeout = jiffies + (HZ * 5);
         u32 sstatus, scontrol;
         int online;
@@ -407,6 +397,9 @@ static void vt6421_init_addrs(struct ata_port *ap)
         ioaddr->scr_addr = vt6421_scr_addr(iomap[5], ap->port_no);
 
         ata_std_ports(ioaddr);
+
+        ata_port_pbar_desc(ap, ap->port_no, -1, "port");
+        ata_port_pbar_desc(ap, 4, ap->port_no * 8, "bmdma");
 }
 
 static int vt6420_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
@@ -513,7 +506,6 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         struct ata_host *host;
         int board_id = (int) ent->driver_data;
         const int *bar_sizes;
-        u8 tmp8;
 
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
@@ -522,19 +514,10 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc)
                 return rc;
 
-        if (board_id == vt6420) {
-                pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
-                if (tmp8 & SATA_2DEV) {
-                        dev_printk(KERN_ERR, &pdev->dev,
-                                   "SATA master/slave not supported (0x%x)\n",
-                                   (int) tmp8);
-                        return -EIO;
-                }
-
+        if (board_id == vt6420)
                 bar_sizes = &svia_bar_sizes[0];
-        } else {
+        else
                 bar_sizes = &vt6421_bar_sizes[0];
-        }
 
         for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
                 if ((pci_resource_start(pdev, i) == 0) ||
diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index 1920915dfa2c..0d9be1684873 100644
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -240,7 +240,7 @@ static void vsc_port_intr(u8 port_status, struct ata_port *ap)
                 return;
         }
 
-        qc = ata_qc_from_tag(ap, ap->active_tag);
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
         if (qc && likely(!(qc->tf.flags & ATA_TFLAG_POLLING)))
                 handled = ata_host_intr(ap, qc);
 
@@ -317,7 +317,6 @@ static struct scsi_host_template vsc_sata_sht = {
 
 
 static const struct ata_port_operations vsc_sata_ops = {
-        .port_disable           = ata_port_disable,
         .tf_load                = vsc_sata_tf_load,
         .tf_read                = vsc_sata_tf_read,
         .exec_command           = ata_exec_command,
@@ -336,7 +335,6 @@ static const struct ata_port_operations vsc_sata_ops = {
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
         .irq_clear              = ata_bmdma_irq_clear,
         .irq_on                 = ata_irq_on,
-        .irq_ack                = ata_irq_ack,
         .scr_read               = vsc_sata_scr_read,
         .scr_write              = vsc_sata_scr_write,
         .port_start             = ata_port_start,
@@ -408,9 +406,15 @@ static int __devinit vsc_sata_init_one (struct pci_dev *pdev, const struct pci_d
 
         mmio_base = host->iomap[VSC_MMIO_BAR];
 
-        for (i = 0; i < host->n_ports; i++)
-                vsc_sata_setup_port(&host->ports[i]->ioaddr,
-                                    mmio_base + (i + 1) * VSC_SATA_PORT_OFFSET);
+        for (i = 0; i < host->n_ports; i++) {
+                struct ata_port *ap = host->ports[i];
+                unsigned int offset = (i + 1) * VSC_SATA_PORT_OFFSET;
+
+                vsc_sata_setup_port(&ap->ioaddr, mmio_base + offset);
+
+                ata_port_pbar_desc(ap, VSC_MMIO_BAR, -1, "mmio");
+                ata_port_pbar_desc(ap, VSC_MMIO_BAR, offset, "port");
+        }
 
         /*
          * Use 32 bit DMA mask, because 64 bit address support is poor.
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index f142eafb6fc7..b41dfb539021 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -3829,18 +3829,18 @@ static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
 
 /**
  * ipr_sata_reset - Reset the SATA port
- * @ap:         SATA port to reset
+ * @link:       SATA link to reset
  * @classes:    class of the attached device
  *
- * This function issues a SATA phy reset to the affected ATA port.
+ * This function issues a SATA phy reset to the affected ATA link.
  *
  * Return value:
  *      0 on success / non-zero on failure
  **/
-static int ipr_sata_reset(struct ata_port *ap, unsigned int *classes,
+static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
                                 unsigned long deadline)
 {
-        struct ipr_sata_port *sata_port = ap->private_data;
+        struct ipr_sata_port *sata_port = link->ap->private_data;
         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
         struct ipr_resource_entry *res;
         unsigned long lock_flags = 0;
@@ -4981,22 +4981,22 @@ static void ipr_ata_phy_reset(struct ata_port *ap)
         rc = ipr_device_reset(ioa_cfg, res);
 
         if (rc) {
-                ap->ops->port_disable(ap);
+                ata_port_disable(ap);
                 goto out_unlock;
         }
 
         switch(res->cfgte.proto) {
         case IPR_PROTO_SATA:
         case IPR_PROTO_SAS_STP:
-                ap->device[0].class = ATA_DEV_ATA;
+                ap->link.device[0].class = ATA_DEV_ATA;
                 break;
         case IPR_PROTO_SATA_ATAPI:
         case IPR_PROTO_SAS_STP_ATAPI:
-                ap->device[0].class = ATA_DEV_ATAPI;
+                ap->link.device[0].class = ATA_DEV_ATAPI;
                 break;
         default:
-                ap->device[0].class = ATA_DEV_UNKNOWN;
-                ap->ops->port_disable(ap);
+                ap->link.device[0].class = ATA_DEV_UNKNOWN;
+                ata_port_disable(ap);
                 break;
         };
 
@@ -5262,7 +5262,6 @@ static u8 ipr_ata_check_altstatus(struct ata_port *ap)
 }
 
 static struct ata_port_operations ipr_sata_ops = {
-        .port_disable = ata_port_disable,
         .check_status = ipr_ata_check_status,
         .check_altstatus = ipr_ata_check_altstatus,
         .dev_select = ata_noop_dev_select,
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index 5e573efcf0a7..0829b55c64d2 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -249,17 +249,17 @@ static void sas_ata_phy_reset(struct ata_port *ap)
         switch (dev->sata_dev.command_set) {
                 case ATA_COMMAND_SET:
                         SAS_DPRINTK("%s: Found ATA device.\n", __FUNCTION__);
-                        ap->device[0].class = ATA_DEV_ATA;
+                        ap->link.device[0].class = ATA_DEV_ATA;
                         break;
                 case ATAPI_COMMAND_SET:
                         SAS_DPRINTK("%s: Found ATAPI device.\n", __FUNCTION__);
-                        ap->device[0].class = ATA_DEV_ATAPI;
+                        ap->link.device[0].class = ATA_DEV_ATAPI;
                         break;
                 default:
                         SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
                                     __FUNCTION__,
                                     dev->sata_dev.command_set);
-                        ap->device[0].class = ATA_DEV_UNKNOWN;
+                        ap->link.device[0].class = ATA_DEV_UNKNOWN;
                         break;
         }
 
@@ -317,7 +317,7 @@ static int sas_ata_scr_write(struct ata_port *ap, unsigned int sc_reg_in,
                         dev->sata_dev.serror = val;
                         break;
                 case SCR_ACTIVE:
-                        dev->sata_dev.ap->sactive = val;
+                        dev->sata_dev.ap->link.sactive = val;
                         break;
                 default:
                         return -EINVAL;
@@ -342,7 +342,7 @@ static int sas_ata_scr_read(struct ata_port *ap, unsigned int sc_reg_in,
                         *val = dev->sata_dev.serror;
                         return 0;
                 case SCR_ACTIVE:
-                        *val = dev->sata_dev.ap->sactive;
+                        *val = dev->sata_dev.ap->link.sactive;
                         return 0;
                 default:
                         return -EINVAL;
@@ -350,7 +350,6 @@ static int sas_ata_scr_read(struct ata_port *ap, unsigned int sc_reg_in,
 }
 
 static struct ata_port_operations sas_sata_ops = {
-        .port_disable           = ata_port_disable,
         .check_status           = sas_ata_check_status,
         .check_altstatus        = sas_ata_check_status,
         .dev_select             = ata_noop_dev_select,
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