71 files changed, 4325 insertions, 1302 deletions

diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 11ec911016c6..75afa75a515e 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -2,6 +2,14 @@
 # SATA/PATA driver configuration
 #
 
+config HAVE_PATA_PLATFORM
+        bool
+        help
+          This is an internal configuration node for any machine that
+          uses pata-platform driver to enable the relevant driver in the
+          configuration structure without having to submit endless patches
+          to update the PATA_PLATFORM entry.
+
 menuconfig ATA
         tristate "Serial ATA and Parallel ATA drivers"
         depends on HAS_IOMEM
@@ -90,6 +98,14 @@ config SATA_INIC162X
         help
           This option enables support for Initio 162x Serial ATA.
 
+config SATA_ACARD_AHCI
+        tristate "ACard AHCI variant (ATP 8620)"
+        depends on PCI
+        help
+          This option enables support for Acard.
+
+          If unsure, say N.
+
 config SATA_SIL24
         tristate "Silicon Image 3124/3132 SATA support"
         depends on PCI
@@ -128,16 +144,6 @@ config PDC_ADMA
 
           If unsure, say N.
 
-config PATA_MPC52xx
-        tristate "Freescale MPC52xx SoC internal IDE"
-        depends on PPC_MPC52xx && PPC_BESTCOMM
-        select PPC_BESTCOMM_ATA
-        help
-          This option enables support for integrated IDE controller
-          of the Freescale MPC52xx SoC.
-
-          If unsure, say N.
-
 config PATA_OCTEON_CF
         tristate "OCTEON Boot Bus Compact Flash support"
         depends on CPU_CAVIUM_OCTEON
@@ -196,6 +202,18 @@ config SATA_DWC
 
           If unsure, say N.
 
+config SATA_DWC_DEBUG
+        bool "Debugging driver version"
+        depends on SATA_DWC
+        help
+          This option enables debugging output in the driver.
+
+config SATA_DWC_VDEBUG
+        bool "Verbose debug output"
+        depends on SATA_DWC_DEBUG
+        help
+          This option enables the taskfile dumping and NCQ debugging.
+
 config SATA_MV
         tristate "Marvell SATA support"
         help
@@ -293,6 +311,12 @@ config PATA_AMD
 
           If unsure, say N.
 
+config PATA_ARASAN_CF
+        tristate "ARASAN CompactFlash PATA Controller Support"
+        select DMA_ENGINE
+        help
+          Say Y here to support the ARASAN CompactFlash PATA controller
+
 config PATA_ARTOP
         tristate "ARTOP 6210/6260 PATA support"
         depends on PCI
@@ -366,7 +390,7 @@ config PATA_CS5535
 
 config PATA_CS5536
         tristate "CS5536 PATA support"
-        depends on PCI && X86 && !X86_64
+        depends on PCI
         help
           This option enables support for the AMD CS5536
           companion chip used with the Geode LX processor family.
@@ -410,11 +434,11 @@ config PATA_HPT37X
           If unsure, say N.
 
 config PATA_HPT3X2N
-        tristate "HPT 372N/302N PATA support"
+        tristate "HPT 371N/372N/302N PATA support"
         depends on PCI
         help
           This option enables support for the N variant HPT PATA
-          controllers via the new ATA layer
+          controllers via the new ATA layer.
 
           If unsure, say N.
 
@@ -491,6 +515,16 @@ config PATA_MARVELL
 
           If unsure, say N.
 
+config PATA_MPC52xx
+        tristate "Freescale MPC52xx SoC internal IDE"
+        depends on PPC_MPC52xx && PPC_BESTCOMM
+        select PPC_BESTCOMM_ATA
+        help
+          This option enables support for integrated IDE controller
+          of the Freescale MPC52xx SoC.
+
+          If unsure, say N.
+
 config PATA_NETCELL
         tristate "NETCELL Revolution RAID support"
         depends on PCI
@@ -765,17 +799,9 @@ config PATA_PCMCIA
 
           If unsure, say N.
 
-config HAVE_PATA_PLATFORM
-        bool
-        help
-          This is an internal configuration node for any machine that
-          uses pata-platform driver to enable the relevant driver in the
-          configuration structure without having to submit endless patches
-          to update the PATA_PLATFORM entry.
-
 config PATA_PLATFORM
         tristate "Generic platform device PATA support"
-        depends on EMBEDDED || PPC || HAVE_PATA_PLATFORM
+        depends on EXPERT || PPC || HAVE_PATA_PLATFORM
         help
           This option enables support for generic directly connected ATA
           devices commonly found on embedded systems.
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index d5df04a395ca..8ac64e1aa051 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -3,6 +3,7 @@ obj-$(CONFIG_ATA)		+= libata.o
 
 # non-SFF interface
 obj-$(CONFIG_SATA_AHCI)         += ahci.o libahci.o
+obj-$(CONFIG_SATA_ACARD_AHCI)   += acard-ahci.o libahci.o
 obj-$(CONFIG_SATA_AHCI_PLATFORM) += ahci_platform.o libahci.o
 obj-$(CONFIG_SATA_FSL)          += sata_fsl.o
 obj-$(CONFIG_SATA_INIC162X)     += sata_inic162x.o
@@ -11,7 +12,7 @@ obj-$(CONFIG_SATA_DWC)		+= sata_dwc_460ex.o
 
 # SFF w/ custom DMA
 obj-$(CONFIG_PDC_ADMA)          += pdc_adma.o
-obj-$(CONFIG_PATA_MPC52xx)      += pata_mpc52xx.o
+obj-$(CONFIG_PATA_ARASAN_CF)    += pata_arasan_cf.o
 obj-$(CONFIG_PATA_OCTEON_CF)    += pata_octeon_cf.o
 obj-$(CONFIG_SATA_QSTOR)        += sata_qstor.o
 obj-$(CONFIG_SATA_SX4)          += sata_sx4.o
@@ -52,6 +53,7 @@ obj-$(CONFIG_PATA_IT821X)	+= pata_it821x.o
 obj-$(CONFIG_PATA_JMICRON)      += pata_jmicron.o
 obj-$(CONFIG_PATA_MACIO)        += pata_macio.o
 obj-$(CONFIG_PATA_MARVELL)      += pata_marvell.o
+obj-$(CONFIG_PATA_MPC52xx)      += pata_mpc52xx.o
 obj-$(CONFIG_PATA_NETCELL)      += pata_netcell.o
 obj-$(CONFIG_PATA_NINJA32)      += pata_ninja32.o
 obj-$(CONFIG_PATA_NS87415)      += pata_ns87415.o
@@ -99,7 +101,7 @@ 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-eh.o
+libata-y        := libata-core.o libata-scsi.o libata-eh.o libata-transport.o
 libata-$(CONFIG_ATA_SFF)        += libata-sff.o
 libata-$(CONFIG_SATA_PMP)       += libata-pmp.o
 libata-$(CONFIG_ATA_ACPI)       += libata-acpi.o
diff --git a/drivers/ata/acard-ahci.c b/drivers/ata/acard-ahci.c
new file mode 100644
index 000000000000..ae22be4157b5
--- /dev/null
+++ b/drivers/ata/acard-ahci.c
@@ -0,0 +1,528 @@
+
+/*
+ *  acard-ahci.c - ACard AHCI SATA support
+ *
+ *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
+ *                  Please ALWAYS copy linux-ide@vger.kernel.org
+ *                  on emails.
+ *
+ *  Copyright 2010 Red Hat, Inc.
+ *
+ *
+ *  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, 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; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ * libata documentation is available via 'make {ps|pdf}docs',
+ * as Documentation/DocBook/libata.*
+ *
+ * AHCI hardware documentation:
+ * http://www.intel.com/technology/serialata/pdf/rev1_0.pdf
+ * http://www.intel.com/technology/serialata/pdf/rev1_1.pdf
+ *
+ */
+
+#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/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/device.h>
+#include <linux/dmi.h>
+#include <linux/gfp.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_cmnd.h>
+#include <linux/libata.h>
+#include "ahci.h"
+
+#define DRV_NAME        "acard-ahci"
+#define DRV_VERSION     "1.0"
+
+/*
+  Received FIS structure limited to 80h.
+*/
+
+#define ACARD_AHCI_RX_FIS_SZ 128
+
+enum {
+        AHCI_PCI_BAR            = 5,
+};
+
+enum board_ids {
+        board_acard_ahci,
+};
+
+struct acard_sg {
+        __le32                  addr;
+        __le32                  addr_hi;
+        __le32                  reserved;
+        __le32                  size;    /* bit 31 (EOT) max==0x10000 (64k) */
+};
+
+static void acard_ahci_qc_prep(struct ata_queued_cmd *qc);
+static bool acard_ahci_qc_fill_rtf(struct ata_queued_cmd *qc);
+static int acard_ahci_port_start(struct ata_port *ap);
+static int acard_ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
+
+#ifdef CONFIG_PM
+static int acard_ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
+static int acard_ahci_pci_device_resume(struct pci_dev *pdev);
+#endif
+
+static struct scsi_host_template acard_ahci_sht = {
+        AHCI_SHT("acard-ahci"),
+};
+
+static struct ata_port_operations acard_ops = {
+        .inherits               = &ahci_ops,
+        .qc_prep                = acard_ahci_qc_prep,
+        .qc_fill_rtf            = acard_ahci_qc_fill_rtf,
+        .port_start             = acard_ahci_port_start,
+};
+
+#define AHCI_HFLAGS(flags)      .private_data   = (void *)(flags)
+
+static const struct ata_port_info acard_ahci_port_info[] = {
+        [board_acard_ahci] =
+        {
+                AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ),
+                .flags          = AHCI_FLAG_COMMON,
+                .pio_mask       = ATA_PIO4,
+                .udma_mask      = ATA_UDMA6,
+                .port_ops       = &acard_ops,
+        },
+};
+
+static const struct pci_device_id acard_ahci_pci_tbl[] = {
+        /* ACard */
+        { PCI_VDEVICE(ARTOP, 0x000d), board_acard_ahci }, /* ATP8620 */
+
+        { }    /* terminate list */
+};
+
+static struct pci_driver acard_ahci_pci_driver = {
+        .name                   = DRV_NAME,
+        .id_table               = acard_ahci_pci_tbl,
+        .probe                  = acard_ahci_init_one,
+        .remove                 = ata_pci_remove_one,
+#ifdef CONFIG_PM
+        .suspend                = acard_ahci_pci_device_suspend,
+        .resume                 = acard_ahci_pci_device_resume,
+#endif
+};
+
+#ifdef CONFIG_PM
+static int acard_ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
+{
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        struct ahci_host_priv *hpriv = host->private_data;
+        void __iomem *mmio = hpriv->mmio;
+        u32 ctl;
+
+        if (mesg.event & PM_EVENT_SUSPEND &&
+            hpriv->flags & AHCI_HFLAG_NO_SUSPEND) {
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "BIOS update required for suspend/resume\n");
+                return -EIO;
+        }
+
+        if (mesg.event & PM_EVENT_SLEEP) {
+                /* AHCI spec rev1.1 section 8.3.3:
+                 * Software must disable interrupts prior to requesting a
+                 * transition of the HBA to D3 state.
+                 */
+                ctl = readl(mmio + HOST_CTL);
+                ctl &= ~HOST_IRQ_EN;
+                writel(ctl, mmio + HOST_CTL);
+                readl(mmio + HOST_CTL); /* flush */
+        }
+
+        return ata_pci_device_suspend(pdev, mesg);
+}
+
+static int acard_ahci_pci_device_resume(struct pci_dev *pdev)
+{
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        int rc;
+
+        rc = ata_pci_device_do_resume(pdev);
+        if (rc)
+                return rc;
+
+        if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
+                rc = ahci_reset_controller(host);
+                if (rc)
+                        return rc;
+
+                ahci_init_controller(host);
+        }
+
+        ata_host_resume(host);
+
+        return 0;
+}
+#endif
+
+static int acard_ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
+{
+        int rc;
+
+        if (using_dac &&
+            !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
+                rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
+                if (rc) {
+                        rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+                        if (rc) {
+                                dev_printk(KERN_ERR, &pdev->dev,
+                                           "64-bit DMA enable failed\n");
+                                return rc;
+                        }
+                }
+        } else {
+                rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+                if (rc) {
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "32-bit DMA enable failed\n");
+                        return rc;
+                }
+                rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+                if (rc) {
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "32-bit consistent DMA enable failed\n");
+                        return rc;
+                }
+        }
+        return 0;
+}
+
+static void acard_ahci_pci_print_info(struct ata_host *host)
+{
+        struct pci_dev *pdev = to_pci_dev(host->dev);
+        u16 cc;
+        const char *scc_s;
+
+        pci_read_config_word(pdev, 0x0a, &cc);
+        if (cc == PCI_CLASS_STORAGE_IDE)
+                scc_s = "IDE";
+        else if (cc == PCI_CLASS_STORAGE_SATA)
+                scc_s = "SATA";
+        else if (cc == PCI_CLASS_STORAGE_RAID)
+                scc_s = "RAID";
+        else
+                scc_s = "unknown";
+
+        ahci_print_info(host, scc_s);
+}
+
+static unsigned int acard_ahci_fill_sg(struct ata_queued_cmd *qc, void *cmd_tbl)
+{
+        struct scatterlist *sg;
+        struct acard_sg *acard_sg = cmd_tbl + AHCI_CMD_TBL_HDR_SZ;
+        unsigned int si, last_si = 0;
+
+        VPRINTK("ENTER\n");
+
+        /*
+         * Next, the S/G list.
+         */
+        for_each_sg(qc->sg, sg, qc->n_elem, si) {
+                dma_addr_t addr = sg_dma_address(sg);
+                u32 sg_len = sg_dma_len(sg);
+
+                /*
+                 * ACard note:
+                 * We must set an end-of-table (EOT) bit,
+                 * and the segment cannot exceed 64k (0x10000)
+                 */
+                acard_sg[si].addr = cpu_to_le32(addr & 0xffffffff);
+                acard_sg[si].addr_hi = cpu_to_le32((addr >> 16) >> 16);
+                acard_sg[si].size = cpu_to_le32(sg_len);
+                last_si = si;
+        }
+
+        acard_sg[last_si].size |= cpu_to_le32(1 << 31); /* set EOT */
+
+        return si;
+}
+
+static void acard_ahci_qc_prep(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct ahci_port_priv *pp = ap->private_data;
+        int is_atapi = ata_is_atapi(qc->tf.protocol);
+        void *cmd_tbl;
+        u32 opts;
+        const u32 cmd_fis_len = 5; /* five dwords */
+        unsigned int n_elem;
+
+        /*
+         * Fill in command table information.  First, the header,
+         * a SATA Register - Host to Device command FIS.
+         */
+        cmd_tbl = pp->cmd_tbl + qc->tag * AHCI_CMD_TBL_SZ;
+
+        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);
+        }
+
+        n_elem = 0;
+        if (qc->flags & ATA_QCFLAG_DMAMAP)
+                n_elem = acard_ahci_fill_sg(qc, cmd_tbl);
+
+        /*
+         * Fill in command slot information.
+         *
+         * ACard note: prd table length not filled in
+         */
+        opts = cmd_fis_len | (qc->dev->link->pmp << 12);
+        if (qc->tf.flags & ATA_TFLAG_WRITE)
+                opts |= AHCI_CMD_WRITE;
+        if (is_atapi)
+                opts |= AHCI_CMD_ATAPI | AHCI_CMD_PREFETCH;
+
+        ahci_fill_cmd_slot(pp, qc->tag, opts);
+}
+
+static bool acard_ahci_qc_fill_rtf(struct ata_queued_cmd *qc)
+{
+        struct ahci_port_priv *pp = qc->ap->private_data;
+        u8 *rx_fis = pp->rx_fis;
+
+        if (pp->fbs_enabled)
+                rx_fis += qc->dev->link->pmp * ACARD_AHCI_RX_FIS_SZ;
+
+        /*
+         * After a successful execution of an ATA PIO data-in command,
+         * the device doesn't send D2H Reg FIS to update the TF and
+         * the host should take TF and E_Status from the preceding PIO
+         * Setup FIS.
+         */
+        if (qc->tf.protocol == ATA_PROT_PIO && qc->dma_dir == DMA_FROM_DEVICE &&
+            !(qc->flags & ATA_QCFLAG_FAILED)) {
+                ata_tf_from_fis(rx_fis + RX_FIS_PIO_SETUP, &qc->result_tf);
+                qc->result_tf.command = (rx_fis + RX_FIS_PIO_SETUP)[15];
+        } else
+                ata_tf_from_fis(rx_fis + RX_FIS_D2H_REG, &qc->result_tf);
+
+        return true;
+}
+
+static int acard_ahci_port_start(struct ata_port *ap)
+{
+        struct ahci_host_priv *hpriv = ap->host->private_data;
+        struct device *dev = ap->host->dev;
+        struct ahci_port_priv *pp;
+        void *mem;
+        dma_addr_t mem_dma;
+        size_t dma_sz, rx_fis_sz;
+
+        pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
+        if (!pp)
+                return -ENOMEM;
+
+        /* check FBS capability */
+        if ((hpriv->cap & HOST_CAP_FBS) && sata_pmp_supported(ap)) {
+                void __iomem *port_mmio = ahci_port_base(ap);
+                u32 cmd = readl(port_mmio + PORT_CMD);
+                if (cmd & PORT_CMD_FBSCP)
+                        pp->fbs_supported = true;
+                else if (hpriv->flags & AHCI_HFLAG_YES_FBS) {
+                        dev_printk(KERN_INFO, dev,
+                                   "port %d can do FBS, forcing FBSCP\n",
+                                   ap->port_no);
+                        pp->fbs_supported = true;
+                } else
+                        dev_printk(KERN_WARNING, dev,
+                                   "port %d is not capable of FBS\n",
+                                   ap->port_no);
+        }
+
+        if (pp->fbs_supported) {
+                dma_sz = AHCI_PORT_PRIV_FBS_DMA_SZ;
+                rx_fis_sz = ACARD_AHCI_RX_FIS_SZ * 16;
+        } else {
+                dma_sz = AHCI_PORT_PRIV_DMA_SZ;
+                rx_fis_sz = ACARD_AHCI_RX_FIS_SZ;
+        }
+
+        mem = dmam_alloc_coherent(dev, dma_sz, &mem_dma, GFP_KERNEL);
+        if (!mem)
+                return -ENOMEM;
+        memset(mem, 0, dma_sz);
+
+        /*
+         * First item in chunk of DMA memory: 32-slot command table,
+         * 32 bytes each in size
+         */
+        pp->cmd_slot = mem;
+        pp->cmd_slot_dma = mem_dma;
+
+        mem += AHCI_CMD_SLOT_SZ;
+        mem_dma += AHCI_CMD_SLOT_SZ;
+
+        /*
+         * Second item: Received-FIS area
+         */
+        pp->rx_fis = mem;
+        pp->rx_fis_dma = mem_dma;
+
+        mem += rx_fis_sz;
+        mem_dma += rx_fis_sz;
+
+        /*
+         * Third item: data area for storing a single command
+         * and its scatter-gather table
+         */
+        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 */
+        return ahci_port_resume(ap);
+}
+
+static int acard_ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        static int printed_version;
+        unsigned int board_id = ent->driver_data;
+        struct ata_port_info pi = acard_ahci_port_info[board_id];
+        const struct ata_port_info *ppi[] = { &pi, NULL };
+        struct device *dev = &pdev->dev;
+        struct ahci_host_priv *hpriv;
+        struct ata_host *host;
+        int n_ports, i, rc;
+
+        VPRINTK("ENTER\n");
+
+        WARN_ON((int)ATA_MAX_QUEUE > AHCI_MAX_CMDS);
+
+        if (!printed_version++)
+                dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
+
+        /* acquire resources */
+        rc = pcim_enable_device(pdev);
+        if (rc)
+                return rc;
+
+        /* AHCI controllers often implement SFF compatible interface.
+         * Grab all PCI BARs just in case.
+         */
+        rc = pcim_iomap_regions_request_all(pdev, 1 << AHCI_PCI_BAR, DRV_NAME);
+        if (rc == -EBUSY)
+                pcim_pin_device(pdev);
+        if (rc)
+                return rc;
+
+        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);
+
+        hpriv->mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR];
+
+        /* save initial config */
+        ahci_save_initial_config(&pdev->dev, hpriv, 0, 0);
+
+        /* prepare host */
+        if (hpriv->cap & HOST_CAP_NCQ)
+                pi.flags |= ATA_FLAG_NCQ;
+
+        if (hpriv->cap & HOST_CAP_PMP)
+                pi.flags |= ATA_FLAG_PMP;
+
+        ahci_set_em_messages(hpriv, &pi);
+
+        /* CAP.NP sometimes indicate the index of the last enabled
+         * port, at other times, that of the last possible port, so
+         * determining the maximum port number requires looking at
+         * both CAP.NP and port_map.
+         */
+        n_ports = max(ahci_nr_ports(hpriv->cap), fls(hpriv->port_map));
+
+        host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
+        if (!host)
+                return -ENOMEM;
+        host->private_data = hpriv;
+
+        if (!(hpriv->cap & HOST_CAP_SSS) || ahci_ignore_sss)
+                host->flags |= ATA_HOST_PARALLEL_SCAN;
+        else
+                printk(KERN_INFO "ahci: SSS flag set, parallel bus scan disabled\n");
+
+        for (i = 0; i < host->n_ports; i++) {
+                struct ata_port *ap = host->ports[i];
+
+                ata_port_pbar_desc(ap, AHCI_PCI_BAR, -1, "abar");
+                ata_port_pbar_desc(ap, AHCI_PCI_BAR,
+                                   0x100 + ap->port_no * 0x80, "port");
+
+                /* set initial link pm policy */
+                /*
+                ap->pm_policy = NOT_AVAILABLE;
+                */
+                /* disabled/not-implemented port */
+                if (!(hpriv->port_map & (1 << i)))
+                        ap->ops = &ata_dummy_port_ops;
+        }
+
+        /* initialize adapter */
+        rc = acard_ahci_configure_dma_masks(pdev, hpriv->cap & HOST_CAP_64);
+        if (rc)
+                return rc;
+
+        rc = ahci_reset_controller(host);
+        if (rc)
+                return rc;
+
+        ahci_init_controller(host);
+        acard_ahci_pci_print_info(host);
+
+        pci_set_master(pdev);
+        return ata_host_activate(host, pdev->irq, ahci_interrupt, IRQF_SHARED,
+                                 &acard_ahci_sht);
+}
+
+static int __init acard_ahci_init(void)
+{
+        return pci_register_driver(&acard_ahci_pci_driver);
+}
+
+static void __exit acard_ahci_exit(void)
+{
+        pci_unregister_driver(&acard_ahci_pci_driver);
+}
+
+MODULE_AUTHOR("Jeff Garzik");
+MODULE_DESCRIPTION("ACard AHCI SATA low-level driver");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, acard_ahci_pci_tbl);
+MODULE_VERSION(DRV_VERSION);
+
+module_init(acard_ahci_init);
+module_exit(acard_ahci_exit);
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 99d0e5a51148..71afe0371311 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -150,7 +150,7 @@ static const struct ata_port_info ahci_port_info[] = {
         {
                 AHCI_HFLAGS     (AHCI_HFLAG_NO_FPDMA_AA | AHCI_HFLAG_NO_PMP |
                                  AHCI_HFLAG_YES_NCQ),
-                .flags          = AHCI_FLAG_COMMON,
+                .flags          = AHCI_FLAG_COMMON | ATA_FLAG_NO_DIPM,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
@@ -175,8 +175,7 @@ static const struct ata_port_info ahci_port_info[] = {
         {
                 AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_MSI |
                                  AHCI_HFLAG_MV_PATA | AHCI_HFLAG_NO_PMP),
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
@@ -260,6 +259,14 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, 0x1d02), board_ahci }, /* PBG AHCI */
         { PCI_VDEVICE(INTEL, 0x1d04), board_ahci }, /* PBG RAID */
         { PCI_VDEVICE(INTEL, 0x1d06), board_ahci }, /* PBG RAID */
+        { PCI_VDEVICE(INTEL, 0x2826), board_ahci }, /* PBG RAID */
+        { PCI_VDEVICE(INTEL, 0x2323), board_ahci }, /* DH89xxCC AHCI */
+        { PCI_VDEVICE(INTEL, 0x1e02), board_ahci }, /* Panther Point AHCI */
+        { PCI_VDEVICE(INTEL, 0x1e03), board_ahci }, /* Panther Point AHCI */
+        { PCI_VDEVICE(INTEL, 0x1e04), board_ahci }, /* Panther Point RAID */
+        { PCI_VDEVICE(INTEL, 0x1e05), board_ahci }, /* Panther Point RAID */
+        { PCI_VDEVICE(INTEL, 0x1e06), board_ahci }, /* Panther Point RAID */
+        { PCI_VDEVICE(INTEL, 0x1e07), board_ahci }, /* Panther Point RAID */
 
         /* 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,
@@ -379,7 +386,13 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(MARVELL, 0x6145), board_ahci_mv },        /* 6145 */
         { PCI_VDEVICE(MARVELL, 0x6121), board_ahci_mv },        /* 6121 */
         { PCI_DEVICE(0x1b4b, 0x9123),
+          .class = PCI_CLASS_STORAGE_SATA_AHCI,
+          .class_mask = 0xffffff,
           .driver_data = board_ahci_yes_fbs },                  /* 88se9128 */
+        { PCI_DEVICE(0x1b4b, 0x9125),
+          .driver_data = board_ahci_yes_fbs },                  /* 88se9125 */
+        { PCI_DEVICE(0x1b4b, 0x91a3),
+          .driver_data = board_ahci_yes_fbs },
 
         /* Promise */
         { PCI_VDEVICE(PROMISE, 0x3f20), board_ahci },   /* PDC42819 */
@@ -919,7 +932,7 @@ static bool ahci_broken_suspend(struct pci_dev *pdev)
                 /*
                  * Acer eMachines G725 has the same problem.  BIOS
                  * V1.03 is known to be broken.  V3.04 is known to
-                 * work.  Inbetween, there are V1.06, V2.06 and V3.03
+                 * work.  Between, there are V1.06, V2.06 and V3.03
                  * that we don't have much idea about.  For now,
                  * blacklist anything older than V3.04.
                  *
@@ -1208,9 +1221,6 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 ata_port_pbar_desc(ap, AHCI_PCI_BAR,
                                    0x100 + ap->port_no * 0x80, "port");
 
-                /* set initial link pm policy */
-                ap->pm_policy = NOT_AVAILABLE;
-
                 /* set enclosure management message type */
                 if (ap->flags & ATA_FLAG_EM)
                         ap->em_message_type = hpriv->em_msg_type;
diff --git a/drivers/ata/ahci.h b/drivers/ata/ahci.h
index e5fdeebf9ef0..12c5282e7fca 100644
--- a/drivers/ata/ahci.h
+++ b/drivers/ata/ahci.h
@@ -72,6 +72,7 @@ enum {
         AHCI_CMD_RESET          = (1 << 8),
         AHCI_CMD_CLR_BUSY       = (1 << 10),
 
+        RX_FIS_PIO_SETUP        = 0x20, /* offset of PIO Setup FIS data */
         RX_FIS_D2H_REG          = 0x40, /* offset of D2H Register FIS data */
         RX_FIS_SDB              = 0x58, /* offset of SDB FIS data */
         RX_FIS_UNK              = 0x60, /* offset of Unknown FIS data */
@@ -201,7 +202,6 @@ enum {
         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 */
-        AHCI_HFLAG_NO_HOTPLUG           = (1 << 7), /* ignore PxSERR.DIAG.N */
         AHCI_HFLAG_SECT255              = (1 << 8), /* max 255 sectors */
         AHCI_HFLAG_YES_NCQ              = (1 << 9), /* force NCQ cap on */
         AHCI_HFLAG_NO_SUSPEND           = (1 << 10), /* don't suspend */
@@ -213,10 +213,8 @@ enum {
 
         /* ap->flags bits */
 
-        AHCI_FLAG_COMMON                = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                          ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
-                                          ATA_FLAG_ACPI_SATA | ATA_FLAG_AN |
-                                          ATA_FLAG_IPM,
+        AHCI_FLAG_COMMON                = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
+                                          ATA_FLAG_ACPI_SATA | ATA_FLAG_AN,
 
         ICH_MAP                         = 0x90, /* ICH MAP register */
 
@@ -227,10 +225,14 @@ enum {
         /* em_ctl bits */
         EM_CTL_RST              = (1 << 9), /* Reset */
         EM_CTL_TM               = (1 << 8), /* Transmit Message */
-        EM_CTL_MR               = (1 << 0), /* Message Recieved */
+        EM_CTL_MR               = (1 << 0), /* Message Received */
         EM_CTL_ALHD             = (1 << 26), /* Activity LED */
         EM_CTL_XMT              = (1 << 25), /* Transmit Only */
         EM_CTL_SMB              = (1 << 24), /* Single Message Buffer */
+        EM_CTL_SGPIO            = (1 << 19), /* SGPIO messages supported */
+        EM_CTL_SES              = (1 << 18), /* SES-2 messages supported */
+        EM_CTL_SAFTE            = (1 << 17), /* SAF-TE messages supported */
+        EM_CTL_LED              = (1 << 16), /* LED messages supported */
 
         /* em message type */
         EM_MSG_TYPE_LED         = (1 << 0), /* LED */
@@ -283,7 +285,7 @@ struct ahci_port_priv {
 };
 
 struct ahci_host_priv {
-        void __iomem *          mmio;           /* bus-independant mem map */
+        void __iomem *          mmio;           /* bus-independent mem map */
         unsigned int            flags;          /* AHCI_HFLAG_* */
         u32                     cap;            /* cap to use */
         u32                     cap2;           /* cap2 to use */
@@ -311,6 +313,8 @@ extern struct device_attribute *ahci_sdev_attrs[];
 
 extern struct ata_port_operations ahci_ops;
 
+void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
+                        u32 opts);
 void ahci_save_initial_config(struct device *dev,
                               struct ahci_host_priv *hpriv,
                               unsigned int force_port_map,
@@ -326,6 +330,7 @@ int ahci_stop_engine(struct ata_port *ap);
 void ahci_start_engine(struct ata_port *ap);
 int ahci_check_ready(struct ata_link *link);
 int ahci_kick_engine(struct ata_port *ap);
+int ahci_port_resume(struct ata_port *ap);
 void ahci_set_em_messages(struct ahci_host_priv *hpriv,
                           struct ata_port_info *pi);
 int ahci_reset_em(struct ata_host *host);
diff --git a/drivers/ata/ahci_platform.c b/drivers/ata/ahci_platform.c
index 84b643270e7a..6fef1fa75c54 100644
--- a/drivers/ata/ahci_platform.c
+++ b/drivers/ata/ahci_platform.c
@@ -129,9 +129,6 @@ static int __init ahci_probe(struct platform_device *pdev)
                 ata_port_desc(ap, "mmio %pR", mem);
                 ata_port_desc(ap, "port 0x%x", 0x100 + ap->port_no * 0x80);
 
-                /* set initial link pm policy */
-                ap->pm_policy = NOT_AVAILABLE;
-
                 /* set enclosure management message type */
                 if (ap->flags & ATA_FLAG_EM)
                         ap->em_message_type = hpriv->em_msg_type;
diff --git a/drivers/ata/ata_generic.c b/drivers/ata/ata_generic.c
index cc5f7726bde7..721d38bfa339 100644
--- a/drivers/ata/ata_generic.c
+++ b/drivers/ata/ata_generic.c
@@ -35,6 +35,7 @@
 enum {
         ATA_GEN_CLASS_MATCH             = (1 << 0),
         ATA_GEN_FORCE_DMA               = (1 << 1),
+        ATA_GEN_INTEL_IDER              = (1 << 2),
 };
 
 /**
@@ -109,6 +110,49 @@ static struct ata_port_operations generic_port_ops = {
 static int all_generic_ide;             /* Set to claim all devices */
 
 /**
+ *      is_intel_ider           -       identify intel IDE-R devices
+ *      @dev: PCI device
+ *
+ *      Distinguish Intel IDE-R controller devices from other Intel IDE
+ *      devices. IDE-R devices have no timing registers and are in
+ *      most respects virtual. They should be driven by the ata_generic
+ *      driver.
+ *
+ *      IDE-R devices have PCI offset 0xF8.L as zero, later Intel ATA has
+ *      it non zero. All Intel ATA has 0x40 writable (timing), but it is
+ *      not writable on IDE-R devices (this is guaranteed).
+ */
+
+static int is_intel_ider(struct pci_dev *dev)
+{
+        /* For Intel IDE the value at 0xF8 is only zero on IDE-R
+           interfaces */
+        u32 r;
+        u16 t;
+
+        /* Check the manufacturing ID, it will be zero for IDE-R */
+        pci_read_config_dword(dev, 0xF8, &r);
+        /* Not IDE-R: punt so that ata_(old)piix gets it */
+        if (r != 0)
+                return 0;
+        /* 0xF8 will also be zero on some early Intel IDE devices
+           but they will have a sane timing register */
+        pci_read_config_word(dev, 0x40, &t);
+        if (t != 0)
+                return 0;
+        /* Finally check if the timing register is writable so that
+           we eliminate any early devices hot-docked in a docking
+           station */
+        pci_write_config_word(dev, 0x40, 1);
+        pci_read_config_word(dev, 0x40, &t);
+        if (t) {
+                pci_write_config_word(dev, 0x40, 0);
+                return 0;
+        }
+        return 1;
+}
+
+/**
  *      ata_generic_init                -       attach generic IDE
  *      @dev: PCI device found
  *      @id: match entry
@@ -134,6 +178,10 @@ static int ata_generic_init_one(struct pci_dev *dev, const struct pci_device_id
         if ((id->driver_data & ATA_GEN_CLASS_MATCH) && all_generic_ide == 0)
                 return -ENODEV;
 
+        if (id->driver_data & ATA_GEN_INTEL_IDER)
+                if (!is_intel_ider(dev))
+                        return -ENODEV;
+
         /* Devices that need care */
         if (dev->vendor == PCI_VENDOR_ID_UMC &&
             dev->device == PCI_DEVICE_ID_UMC_UM8886A &&
@@ -186,7 +234,11 @@ static struct pci_device_id ata_generic[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA,PCI_DEVICE_ID_TOSHIBA_PICCOLO_2),  },
         { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA,PCI_DEVICE_ID_TOSHIBA_PICCOLO_3),  },
         { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA,PCI_DEVICE_ID_TOSHIBA_PICCOLO_5),  },
-#endif  
+#endif
+        /* Intel, IDE class device */
+        { PCI_VENDOR_ID_INTEL, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
+          PCI_CLASS_STORAGE_IDE << 8, 0xFFFFFF00UL,
+          .driver_data = ATA_GEN_INTEL_IDER },
         /* Must come last. If you add entries adjust this table appropriately */
         { PCI_DEVICE_CLASS(PCI_CLASS_STORAGE_IDE << 8, 0xFFFFFF00UL),
           .driver_data = ATA_GEN_CLASS_MATCH },
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index d712675d0a96..6f6e7718b05c 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -38,16 +38,16 @@
  *  Hardware documentation available at http://developer.intel.com/
  *
  * Documentation
- *      Publically available from Intel web site. Errata documentation
- * is also publically available. As an aide to anyone hacking on this
+ *      Publicly available from Intel web site. Errata documentation
+ * is also publicly available. As an aide to anyone hacking on this
  * driver the list of errata that are relevant is below, going back to
  * PIIX4. Older device documentation is now a bit tricky to find.
  *
  * The chipsets all follow very much the same design. The original Triton
- * series chipsets do _not_ support independant device timings, but this
+ * series chipsets do _not_ support independent device timings, but this
  * is fixed in Triton II. With the odd mobile exception the chips then
  * change little except in gaining more modes until SATA arrives. This
- * driver supports only the chips with independant timing (that is those
+ * driver supports only the chips with independent timing (that is those
  * with SITRE and the 0x44 timing register). See pata_oldpiix and pata_mpiix
  * for the early chip drivers.
  *
@@ -122,7 +122,7 @@ enum {
         P2                      = 2,  /* port 2 */
         P3                      = 3,  /* port 3 */
         IDE                     = -1, /* IDE */
-        NA                      = -2, /* not avaliable */
+        NA                      = -2, /* not available */
         RV                      = -3, /* reserved */
 
         PIIX_AHCI_DEVICE        = 6,
@@ -158,7 +158,6 @@ struct piix_map_db {
 struct piix_host_priv {
         const int *map;
         u32 saved_iocfg;
-        spinlock_t sidpr_lock;  /* FIXME: remove once locking in EH is fixed */
         void __iomem *sidpr;
 };
 
@@ -175,6 +174,8 @@ static int piix_sidpr_scr_read(struct ata_link *link,
                                unsigned int reg, u32 *val);
 static int piix_sidpr_scr_write(struct ata_link *link,
                                 unsigned int reg, u32 val);
+static int piix_sidpr_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                              unsigned hints);
 static bool piix_irq_check(struct ata_port *ap);
 #ifdef CONFIG_PM
 static int piix_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
@@ -209,6 +210,8 @@ static const struct pci_device_id piix_pci_tbl[] = {
         { 0x8086, 0x248A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* Intel ICH3 (E7500/1) UDMA 100 */
         { 0x8086, 0x248B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
+        /* Intel ICH4-L */
+        { 0x8086, 0x24C1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
         /* Intel ICH4 (i845GV, i845E, i852, i855) UDMA 100 */
         { 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 },
@@ -227,7 +230,7 @@ static const struct pci_device_id piix_pci_tbl[] = {
         { 0x8086, 0x2850, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
 
         /* SATA ports */
-        
+
         /* 82801EB (ICH5) */
         { 0x8086, 0x24d1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_sata },
         /* 82801EB (ICH5) */
@@ -306,6 +309,14 @@ static const struct pci_device_id piix_pci_tbl[] = {
         { 0x8086, 0x1d00, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata },
         /* SATA Controller IDE (PBG) */
         { 0x8086, 0x1d08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata },
+        /* SATA Controller IDE (Panther Point) */
+        { 0x8086, 0x1e00, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata },
+        /* SATA Controller IDE (Panther Point) */
+        { 0x8086, 0x1e01, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_sata },
+        /* SATA Controller IDE (Panther Point) */
+        { 0x8086, 0x1e08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata },
+        /* SATA Controller IDE (Panther Point) */
+        { 0x8086, 0x1e09, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich8_2port_sata },
         { }     /* terminate list */
 };
 
@@ -348,11 +359,22 @@ static struct ata_port_operations ich_pata_ops = {
         .set_dmamode            = ich_set_dmamode,
 };
 
+static struct device_attribute *piix_sidpr_shost_attrs[] = {
+        &dev_attr_link_power_management_policy,
+        NULL
+};
+
+static struct scsi_host_template piix_sidpr_sht = {
+        ATA_BMDMA_SHT(DRV_NAME),
+        .shost_attrs            = piix_sidpr_shost_attrs,
+};
+
 static struct ata_port_operations piix_sidpr_sata_ops = {
         .inherits               = &piix_sata_ops,
         .hardreset              = sata_std_hardreset,
         .scr_read               = piix_sidpr_scr_read,
         .scr_write              = piix_sidpr_scr_write,
+        .set_lpm                = piix_sidpr_set_lpm,
 };
 
 static const struct piix_map_db ich5_map_db = {
@@ -956,15 +978,12 @@ static int piix_sidpr_scr_read(struct ata_link *link,
                                unsigned int reg, u32 *val)
 {
         struct piix_host_priv *hpriv = link->ap->host->private_data;
-        unsigned long flags;
 
         if (reg >= ARRAY_SIZE(piix_sidx_map))
                 return -EINVAL;
 
-        spin_lock_irqsave(&hpriv->sidpr_lock, flags);
         piix_sidpr_sel(link, reg);
         *val = ioread32(hpriv->sidpr + PIIX_SIDPR_DATA);
-        spin_unlock_irqrestore(&hpriv->sidpr_lock, flags);
         return 0;
 }
 
@@ -972,18 +991,21 @@ static int piix_sidpr_scr_write(struct ata_link *link,
                                 unsigned int reg, u32 val)
 {
         struct piix_host_priv *hpriv = link->ap->host->private_data;
-        unsigned long flags;
 
         if (reg >= ARRAY_SIZE(piix_sidx_map))
                 return -EINVAL;
 
-        spin_lock_irqsave(&hpriv->sidpr_lock, flags);
         piix_sidpr_sel(link, reg);
         iowrite32(val, hpriv->sidpr + PIIX_SIDPR_DATA);
-        spin_unlock_irqrestore(&hpriv->sidpr_lock, flags);
         return 0;
 }
 
+static int piix_sidpr_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                              unsigned hints)
+{
+        return sata_link_scr_lpm(link, policy, false);
+}
+
 static bool piix_irq_check(struct ata_port *ap)
 {
         if (unlikely(!ap->ioaddr.bmdma_addr))
@@ -1543,6 +1565,7 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
         struct device *dev = &pdev->dev;
         struct ata_port_info port_info[2];
         const struct ata_port_info *ppi[] = { &port_info[0], &port_info[1] };
+        struct scsi_host_template *sht = &piix_sht;
         unsigned long port_flags;
         struct ata_host *host;
         struct piix_host_priv *hpriv;
@@ -1577,7 +1600,6 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
         hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
         if (!hpriv)
                 return -ENOMEM;
-        spin_lock_init(&hpriv->sidpr_lock);
 
         /* Save IOCFG, this will be used for cable detection, quirk
          * detection and restoration on detach.  This is necessary
@@ -1612,6 +1634,8 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
                 rc = piix_init_sidpr(host);
                 if (rc)
                         return rc;
+                if (host->ports[0]->ops == &piix_sidpr_sata_ops)
+                        sht = &piix_sidpr_sht;
         }
 
         /* apply IOCFG bit18 quirk */
@@ -1638,7 +1662,7 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
         host->flags |= ATA_HOST_PARALLEL_SCAN;
 
         pci_set_master(pdev);
-        return ata_pci_sff_activate_host(host, ata_bmdma_interrupt, &piix_sht);
+        return ata_pci_sff_activate_host(host, ata_bmdma_interrupt, sht);
 }
 
 static void piix_remove_one(struct pci_dev *pdev)
diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c
index 8eea309ea212..41223c7f0206 100644
--- a/drivers/ata/libahci.c
+++ b/drivers/ata/libahci.c
@@ -56,9 +56,8 @@ MODULE_PARM_DESC(skip_host_reset, "skip global host reset (0=don't skip, 1=skip)
 module_param_named(ignore_sss, ahci_ignore_sss, int, 0444);
 MODULE_PARM_DESC(ignore_sss, "Ignore staggered spinup flag (0=don't ignore, 1=ignore)");
 
-static int ahci_enable_alpm(struct ata_port *ap,
-                enum link_pm policy);
-static void ahci_disable_alpm(struct ata_port *ap);
+static int ahci_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                        unsigned hints);
 static ssize_t ahci_led_show(struct ata_port *ap, char *buf);
 static ssize_t ahci_led_store(struct ata_port *ap, const char *buf,
                               size_t size);
@@ -88,10 +87,7 @@ static int ahci_hardreset(struct ata_link *link, unsigned int *class,
 static void ahci_postreset(struct ata_link *link, unsigned int *class);
 static void ahci_error_handler(struct ata_port *ap);
 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc);
-static int ahci_port_resume(struct ata_port *ap);
 static void ahci_dev_config(struct ata_device *dev);
-static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
-                               u32 opts);
 #ifdef CONFIG_PM
 static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg);
 #endif
@@ -113,6 +109,8 @@ static ssize_t ahci_read_em_buffer(struct device *dev,
 static ssize_t ahci_store_em_buffer(struct device *dev,
                                     struct device_attribute *attr,
                                     const char *buf, size_t size);
+static ssize_t ahci_show_em_supported(struct device *dev,
+                                      struct device_attribute *attr, char *buf);
 
 static DEVICE_ATTR(ahci_host_caps, S_IRUGO, ahci_show_host_caps, NULL);
 static DEVICE_ATTR(ahci_host_cap2, S_IRUGO, ahci_show_host_cap2, NULL);
@@ -120,6 +118,7 @@ static DEVICE_ATTR(ahci_host_version, S_IRUGO, ahci_show_host_version, NULL);
 static DEVICE_ATTR(ahci_port_cmd, S_IRUGO, ahci_show_port_cmd, NULL);
 static DEVICE_ATTR(em_buffer, S_IWUSR | S_IRUGO,
                    ahci_read_em_buffer, ahci_store_em_buffer);
+static DEVICE_ATTR(em_message_supported, S_IRUGO, ahci_show_em_supported, NULL);
 
 struct device_attribute *ahci_shost_attrs[] = {
         &dev_attr_link_power_management_policy,
@@ -130,6 +129,7 @@ struct device_attribute *ahci_shost_attrs[] = {
         &dev_attr_ahci_host_version,
         &dev_attr_ahci_port_cmd,
         &dev_attr_em_buffer,
+        &dev_attr_em_message_supported,
         NULL
 };
 EXPORT_SYMBOL_GPL(ahci_shost_attrs);
@@ -164,8 +164,7 @@ struct ata_port_operations ahci_ops = {
         .pmp_attach             = ahci_pmp_attach,
         .pmp_detach             = ahci_pmp_detach,
 
-        .enable_pm              = ahci_enable_alpm,
-        .disable_pm             = ahci_disable_alpm,
+        .set_lpm                = ahci_set_lpm,
         .em_show                = ahci_led_show,
         .em_store               = ahci_led_store,
         .sw_activity_show       = ahci_activity_show,
@@ -348,6 +347,24 @@ static ssize_t ahci_store_em_buffer(struct device *dev,
         return size;
 }
 
+static ssize_t ahci_show_em_supported(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct ata_port *ap = ata_shost_to_port(shost);
+        struct ahci_host_priv *hpriv = ap->host->private_data;
+        void __iomem *mmio = hpriv->mmio;
+        u32 em_ctl;
+
+        em_ctl = readl(mmio + HOST_EM_CTL);
+
+        return sprintf(buf, "%s%s%s%s\n",
+                       em_ctl & EM_CTL_LED ? "led " : "",
+                       em_ctl & EM_CTL_SAFTE ? "saf-te " : "",
+                       em_ctl & EM_CTL_SES ? "ses-2 " : "",
+                       em_ctl & EM_CTL_SGPIO ? "sgpio " : "");
+}
+
 /**
  *      ahci_save_initial_config - Save and fixup initial config values
  *      @dev: target AHCI device
@@ -435,7 +452,7 @@ void ahci_save_initial_config(struct device *dev,
         }
 
         if (mask_port_map) {
-                dev_printk(KERN_ERR, dev, "masking port_map 0x%x -> 0x%x\n",
+                dev_printk(KERN_WARNING, dev, "masking port_map 0x%x -> 0x%x\n",
                            port_map,
                            port_map & mask_port_map);
                 port_map &= mask_port_map;
@@ -569,7 +586,7 @@ int ahci_stop_engine(struct ata_port *ap)
         writel(tmp, port_mmio + PORT_CMD);
 
         /* wait for engine to stop. This could be as long as 500 msec */
-        tmp = ata_wait_register(port_mmio + PORT_CMD,
+        tmp = ata_wait_register(ap, port_mmio + PORT_CMD,
                                 PORT_CMD_LIST_ON, PORT_CMD_LIST_ON, 1, 500);
         if (tmp & PORT_CMD_LIST_ON)
                 return -EIO;
@@ -616,7 +633,7 @@ static int ahci_stop_fis_rx(struct ata_port *ap)
         writel(tmp, port_mmio + PORT_CMD);
 
         /* wait for completion, spec says 500ms, give it 1000 */
-        tmp = ata_wait_register(port_mmio + PORT_CMD, PORT_CMD_FIS_ON,
+        tmp = ata_wait_register(ap, port_mmio + PORT_CMD, PORT_CMD_FIS_ON,
                                 PORT_CMD_FIS_ON, 10, 1000);
         if (tmp & PORT_CMD_FIS_ON)
                 return -EBUSY;
@@ -642,127 +659,56 @@ static void ahci_power_up(struct ata_port *ap)
         writel(cmd | PORT_CMD_ICC_ACTIVE, port_mmio + PORT_CMD);
 }
 
-static void ahci_disable_alpm(struct ata_port *ap)
+static int ahci_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                        unsigned int hints)
 {
+        struct ata_port *ap = link->ap;
         struct ahci_host_priv *hpriv = ap->host->private_data;
-        void __iomem *port_mmio = ahci_port_base(ap);
-        u32 cmd;
         struct ahci_port_priv *pp = ap->private_data;
-
-        /* IPM bits should be disabled by libata-core */
-        /* get the existing command bits */
-        cmd = readl(port_mmio + PORT_CMD);
-
-        /* disable ALPM and ASP */
-        cmd &= ~PORT_CMD_ASP;
-        cmd &= ~PORT_CMD_ALPE;
-
-        /* force the interface back to active */
-        cmd |= PORT_CMD_ICC_ACTIVE;
-
-        /* write out new cmd value */
-        writel(cmd, port_mmio + PORT_CMD);
-        cmd = readl(port_mmio + PORT_CMD);
-
-        /* wait 10ms to be sure we've come out of any low power state */
-        msleep(10);
-
-        /* clear out any PhyRdy stuff from interrupt status */
-        writel(PORT_IRQ_PHYRDY, port_mmio + PORT_IRQ_STAT);
-
-        /* go ahead and clean out PhyRdy Change from Serror too */
-        ahci_scr_write(&ap->link, SCR_ERROR, ((1 << 16) | (1 << 18)));
-
-        /*
-         * Clear flag to indicate that we should ignore all PhyRdy
-         * state changes
-         */
-        hpriv->flags &= ~AHCI_HFLAG_NO_HOTPLUG;
-
-        /*
-         * Enable interrupts on Phy Ready.
-         */
-        pp->intr_mask |= PORT_IRQ_PHYRDY;
-        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
-
-        /*
-         * don't change the link pm policy - we can be called
-         * just to turn of link pm temporarily
-         */
-}
-
-static int ahci_enable_alpm(struct ata_port *ap,
-        enum link_pm policy)
-{
-        struct ahci_host_priv *hpriv = ap->host->private_data;
         void __iomem *port_mmio = ahci_port_base(ap);
-        u32 cmd;
-        struct ahci_port_priv *pp = ap->private_data;
-        u32 asp;
 
-        /* Make sure the host is capable of link power management */
-        if (!(hpriv->cap & HOST_CAP_ALPM))
-                return -EINVAL;
-
-        switch (policy) {
-        case MAX_PERFORMANCE:
-        case NOT_AVAILABLE:
+        if (policy != ATA_LPM_MAX_POWER) {
                 /*
-                 * if we came here with NOT_AVAILABLE,
-                 * it just means this is the first time we
-                 * have tried to enable - default to max performance,
-                 * and let the user go to lower power modes on request.
+                 * Disable interrupts on Phy Ready. This keeps us from
+                 * getting woken up due to spurious phy ready
+                 * interrupts.
                  */
-                ahci_disable_alpm(ap);
-                return 0;
-        case MIN_POWER:
-                /* configure HBA to enter SLUMBER */
-                asp = PORT_CMD_ASP;
-                break;
-        case MEDIUM_POWER:
-                /* configure HBA to enter PARTIAL */
-                asp = 0;
-                break;
-        default:
-                return -EINVAL;
+                pp->intr_mask &= ~PORT_IRQ_PHYRDY;
+                writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
+
+                sata_link_scr_lpm(link, policy, false);
         }
 
-        /*
-         * Disable interrupts on Phy Ready. This keeps us from
-         * getting woken up due to spurious phy ready interrupts
-         * TBD - Hot plug should be done via polling now, is
-         * that even supported?
-         */
-        pp->intr_mask &= ~PORT_IRQ_PHYRDY;
-        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
+        if (hpriv->cap & HOST_CAP_ALPM) {
+                u32 cmd = readl(port_mmio + PORT_CMD);
 
-        /*
-         * Set a flag to indicate that we should ignore all PhyRdy
-         * state changes since these can happen now whenever we
-         * change link state
-         */
-        hpriv->flags |= AHCI_HFLAG_NO_HOTPLUG;
+                if (policy == ATA_LPM_MAX_POWER || !(hints & ATA_LPM_HIPM)) {
+                        cmd &= ~(PORT_CMD_ASP | PORT_CMD_ALPE);
+                        cmd |= PORT_CMD_ICC_ACTIVE;
 
-        /* get the existing command bits */
-        cmd = readl(port_mmio + PORT_CMD);
+                        writel(cmd, port_mmio + PORT_CMD);
+                        readl(port_mmio + PORT_CMD);
 
-        /*
-         * Set ASP based on Policy
-         */
-        cmd |= asp;
+                        /* wait 10ms to be sure we've come out of LPM state */
+                        ata_msleep(ap, 10);
+                } else {
+                        cmd |= PORT_CMD_ALPE;
+                        if (policy == ATA_LPM_MIN_POWER)
+                                cmd |= PORT_CMD_ASP;
 
-        /*
-         * Setting this bit will instruct the HBA to aggressively
-         * enter a lower power link state when it's appropriate and
-         * based on the value set above for ASP
-         */
-        cmd |= PORT_CMD_ALPE;
+                        /* write out new cmd value */
+                        writel(cmd, port_mmio + PORT_CMD);
+                }
+        }
 
-        /* write out new cmd value */
-        writel(cmd, port_mmio + PORT_CMD);
-        cmd = readl(port_mmio + PORT_CMD);
+        if (policy == ATA_LPM_MAX_POWER) {
+                sata_link_scr_lpm(link, policy, false);
+
+                /* turn PHYRDY IRQ back on */
+                pp->intr_mask |= PORT_IRQ_PHYRDY;
+                writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
+        }
 
-        /* IPM bits should be set by libata-core */
         return 0;
 }
 
@@ -813,7 +759,7 @@ static void ahci_start_port(struct ata_port *ap)
                                                                emp->led_state,
                                                                4);
                                 if (rc == -EBUSY)
-                                        msleep(1);
+                                        ata_msleep(ap, 1);
                                 else
                                         break;
                         }
@@ -872,7 +818,7 @@ int ahci_reset_controller(struct ata_host *host)
                  * reset must complete within 1 second, or
                  * the hardware should be considered fried.
                  */
-                tmp = ata_wait_register(mmio + HOST_CTL, HOST_RESET,
+                tmp = ata_wait_register(NULL, mmio + HOST_CTL, HOST_RESET,
                                         HOST_RESET, 10, 1000);
 
                 if (tmp & HOST_RESET) {
@@ -1206,8 +1152,8 @@ static unsigned int ahci_dev_classify(struct ata_port *ap)
         return ata_dev_classify(&tf);
 }
 
-static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
-                               u32 opts)
+void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
+                        u32 opts)
 {
         dma_addr_t cmd_tbl_dma;
 
@@ -1218,6 +1164,7 @@ static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
         pp->cmd_slot[tag].tbl_addr = cpu_to_le32(cmd_tbl_dma & 0xffffffff);
         pp->cmd_slot[tag].tbl_addr_hi = cpu_to_le32((cmd_tbl_dma >> 16) >> 16);
 }
+EXPORT_SYMBOL_GPL(ahci_fill_cmd_slot);
 
 int ahci_kick_engine(struct ata_port *ap)
 {
@@ -1252,7 +1199,7 @@ int ahci_kick_engine(struct ata_port *ap)
         writel(tmp, port_mmio + PORT_CMD);
 
         rc = 0;
-        tmp = ata_wait_register(port_mmio + PORT_CMD,
+        tmp = ata_wait_register(ap, port_mmio + PORT_CMD,
                                 PORT_CMD_CLO, PORT_CMD_CLO, 1, 500);
         if (tmp & PORT_CMD_CLO)
                 rc = -EIO;
@@ -1282,8 +1229,8 @@ static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp,
         writel(1, port_mmio + PORT_CMD_ISSUE);
 
         if (timeout_msec) {
-                tmp = ata_wait_register(port_mmio + PORT_CMD_ISSUE, 0x1, 0x1,
-                                        1, timeout_msec);
+                tmp = ata_wait_register(ap, port_mmio + PORT_CMD_ISSUE,
+                                        0x1, 0x1, 1, timeout_msec);
                 if (tmp & 0x1) {
                         ahci_kick_engine(ap);
                         return -EBUSY;
@@ -1330,7 +1277,7 @@ int ahci_do_softreset(struct ata_link *link, unsigned int *class,
         }
 
         /* spec says at least 5us, but be generous and sleep for 1ms */
-        msleep(1);
+        ata_msleep(ap, 1);
 
         /* issue the second D2H Register FIS */
         tf.ctl &= ~ATA_SRST;
@@ -1660,15 +1607,10 @@ static void ahci_port_intr(struct ata_port *ap)
         if (unlikely(resetting))
                 status &= ~PORT_IRQ_BAD_PMP;
 
-        /* If we are getting PhyRdy, this is
-         * just a power state change, we should
-         * clear out this, plus the PhyRdy/Comm
-         * Wake bits from Serror
-         */
-        if ((hpriv->flags & AHCI_HFLAG_NO_HOTPLUG) &&
-                (status & PORT_IRQ_PHYRDY)) {
+        /* if LPM is enabled, PHYRDY doesn't mean anything */
+        if (ap->link.lpm_policy > ATA_LPM_MAX_POWER) {
                 status &= ~PORT_IRQ_PHYRDY;
-                ahci_scr_write(&ap->link, SCR_ERROR, ((1 << 16) | (1 << 18)));
+                ahci_scr_write(&ap->link, SCR_ERROR, SERR_PHYRDY_CHG);
         }
 
         if (unlikely(status & PORT_IRQ_ERROR)) {
@@ -1830,12 +1772,24 @@ static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc)
 static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc)
 {
         struct ahci_port_priv *pp = qc->ap->private_data;
-        u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
+        u8 *rx_fis = pp->rx_fis;
 
         if (pp->fbs_enabled)
-                d2h_fis += qc->dev->link->pmp * AHCI_RX_FIS_SZ;
+                rx_fis += qc->dev->link->pmp * AHCI_RX_FIS_SZ;
+
+        /*
+         * After a successful execution of an ATA PIO data-in command,
+         * the device doesn't send D2H Reg FIS to update the TF and
+         * the host should take TF and E_Status from the preceding PIO
+         * Setup FIS.
+         */
+        if (qc->tf.protocol == ATA_PROT_PIO && qc->dma_dir == DMA_FROM_DEVICE &&
+            !(qc->flags & ATA_QCFLAG_FAILED)) {
+                ata_tf_from_fis(rx_fis + RX_FIS_PIO_SETUP, &qc->result_tf);
+                qc->result_tf.command = (rx_fis + RX_FIS_PIO_SETUP)[15];
+        } else
+                ata_tf_from_fis(rx_fis + RX_FIS_D2H_REG, &qc->result_tf);
 
-        ata_tf_from_fis(d2h_fis, &qc->result_tf);
         return true;
 }
 
@@ -1965,7 +1919,17 @@ static void ahci_pmp_attach(struct ata_port *ap)
         ahci_enable_fbs(ap);
 
         pp->intr_mask |= PORT_IRQ_BAD_PMP;
-        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
+
+        /*
+         * We must not change the port interrupt mask register if the
+         * port is marked frozen, the value in pp->intr_mask will be
+         * restored later when the port is thawed.
+         *
+         * Note that during initialization, the port is marked as
+         * frozen since the irq handler is not yet registered.
+         */
+        if (!(ap->pflags & ATA_PFLAG_FROZEN))
+                writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
 }
 
 static void ahci_pmp_detach(struct ata_port *ap)
@@ -1981,10 +1945,13 @@ static void ahci_pmp_detach(struct ata_port *ap)
         writel(cmd, port_mmio + PORT_CMD);
 
         pp->intr_mask &= ~PORT_IRQ_BAD_PMP;
-        writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
+
+        /* see comment above in ahci_pmp_attach() */
+        if (!(ap->pflags & ATA_PFLAG_FROZEN))
+                writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
 }
 
-static int ahci_port_resume(struct ata_port *ap)
+int ahci_port_resume(struct ata_port *ap)
 {
         ahci_power_up(ap);
         ahci_start_port(ap);
@@ -1996,6 +1963,7 @@ static int ahci_port_resume(struct ata_port *ap)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(ahci_port_resume);
 
 #ifdef CONFIG_PM
 static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg)
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index 8b5ea399a4f4..a791b8ce6294 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -660,8 +660,7 @@ static int ata_acpi_filter_tf(struct ata_device *dev,
  * @dev: target ATA device
  * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
  *
- * Outputs ATA taskfile to standard ATA host controller using MMIO
- * or PIO as indicated by the ATA_FLAG_MMIO flag.
+ * Outputs ATA taskfile to standard ATA host controller.
  * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
  * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
  * hob_lbal, hob_lbam, and hob_lbah.
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 932eaee50245..000d03ae6653 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -68,7 +68,7 @@
 #include <linux/ratelimit.h>
 
 #include "libata.h"
-
+#include "libata-transport.h"
 
 /* debounce timing parameters in msecs { interval, duration, timeout } */
 const unsigned long sata_deb_timing_normal[]            = {   5,  100, 2000 };
@@ -91,8 +91,6 @@ const struct ata_port_operations sata_port_ops = {
 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_feature(struct ata_device *dev,
-                                        u8 enable, u8 feature);
 static void ata_dev_xfermask(struct ata_device *dev);
 static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
 
@@ -1017,7 +1015,7 @@ const char *ata_mode_string(unsigned long xfer_mask)
         return "<n/a>";
 }
 
-static const char *sata_spd_string(unsigned int spd)
+const char *sata_spd_string(unsigned int spd)
 {
         static const char * const spd_str[] = {
                 "1.5 Gbps",
@@ -1030,182 +1028,6 @@ static const char *sata_spd_string(unsigned int spd)
         return spd_str[spd - 1];
 }
 
-static int ata_dev_set_dipm(struct ata_device *dev, enum link_pm policy)
-{
-        struct ata_link *link = dev->link;
-        struct ata_port *ap = link->ap;
-        u32 scontrol;
-        unsigned int err_mask;
-        int rc;
-
-        /*
-         * disallow DIPM for drivers which haven't set
-         * ATA_FLAG_IPM.  This is because when DIPM is enabled,
-         * phy ready will be set in the interrupt status on
-         * state changes, which will cause some drivers to
-         * think there are errors - additionally drivers will
-         * need to disable hot plug.
-         */
-        if (!(ap->flags & ATA_FLAG_IPM) || !ata_dev_enabled(dev)) {
-                ap->pm_policy = NOT_AVAILABLE;
-                return -EINVAL;
-        }
-
-        /*
-         * For DIPM, we will only enable it for the
-         * min_power setting.
-         *
-         * Why?  Because Disks are too stupid to know that
-         * If the host rejects a request to go to SLUMBER
-         * they should retry at PARTIAL, and instead it
-         * just would give up.  So, for medium_power to
-         * work at all, we need to only allow HIPM.
-         */
-        rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
-        if (rc)
-                return rc;
-
-        switch (policy) {
-        case MIN_POWER:
-                /* no restrictions on IPM transitions */
-                scontrol &= ~(0x3 << 8);
-                rc = sata_scr_write(link, SCR_CONTROL, scontrol);
-                if (rc)
-                        return rc;
-
-                /* enable DIPM */
-                if (dev->flags & ATA_DFLAG_DIPM)
-                        err_mask = ata_dev_set_feature(dev,
-                                        SETFEATURES_SATA_ENABLE, SATA_DIPM);
-                break;
-        case MEDIUM_POWER:
-                /* allow IPM to PARTIAL */
-                scontrol &= ~(0x1 << 8);
-                scontrol |= (0x2 << 8);
-                rc = sata_scr_write(link, SCR_CONTROL, scontrol);
-                if (rc)
-                        return rc;
-
-                /*
-                 * we don't have to disable DIPM since IPM flags
-                 * disallow transitions to SLUMBER, which effectively
-                 * disable DIPM if it does not support PARTIAL
-                 */
-                break;
-        case NOT_AVAILABLE:
-        case MAX_PERFORMANCE:
-                /* disable all IPM transitions */
-                scontrol |= (0x3 << 8);
-                rc = sata_scr_write(link, SCR_CONTROL, scontrol);
-                if (rc)
-                        return rc;
-
-                /*
-                 * we don't have to disable DIPM since IPM flags
-                 * disallow all transitions which effectively
-                 * disable DIPM anyway.
-                 */
-                break;
-        }
-
-        /* FIXME: handle SET FEATURES failure */
-        (void) err_mask;
-
-        return 0;
-}
-
-/**
- *      ata_dev_enable_pm - enable SATA interface power management
- *      @dev:  device to enable power management
- *      @policy: the link power management policy
- *
- *      Enable SATA Interface power management.  This will enable
- *      Device Interface Power Management (DIPM) for min_power
- *      policy, and then call driver specific callbacks for
- *      enabling Host Initiated Power management.
- *
- *      Locking: Caller.
- *      Returns: -EINVAL if IPM is not supported, 0 otherwise.
- */
-void ata_dev_enable_pm(struct ata_device *dev, enum link_pm policy)
-{
-        int rc = 0;
-        struct ata_port *ap = dev->link->ap;
-
-        /* set HIPM first, then DIPM */
-        if (ap->ops->enable_pm)
-                rc = ap->ops->enable_pm(ap, policy);
-        if (rc)
-                goto enable_pm_out;
-        rc = ata_dev_set_dipm(dev, policy);
-
-enable_pm_out:
-        if (rc)
-                ap->pm_policy = MAX_PERFORMANCE;
-        else
-                ap->pm_policy = policy;
-        return /* rc */;        /* hopefully we can use 'rc' eventually */
-}
-
-#ifdef CONFIG_PM
-/**
- *      ata_dev_disable_pm - disable SATA interface power management
- *      @dev: device to disable power management
- *
- *      Disable SATA Interface power management.  This will disable
- *      Device Interface Power Management (DIPM) without changing
- *      policy,  call driver specific callbacks for disabling Host
- *      Initiated Power management.
- *
- *      Locking: Caller.
- *      Returns: void
- */
-static void ata_dev_disable_pm(struct ata_device *dev)
-{
-        struct ata_port *ap = dev->link->ap;
-
-        ata_dev_set_dipm(dev, MAX_PERFORMANCE);
-        if (ap->ops->disable_pm)
-                ap->ops->disable_pm(ap);
-}
-#endif  /* CONFIG_PM */
-
-void ata_lpm_schedule(struct ata_port *ap, enum link_pm policy)
-{
-        ap->pm_policy = policy;
-        ap->link.eh_info.action |= ATA_EH_LPM;
-        ap->link.eh_info.flags |= ATA_EHI_NO_AUTOPSY;
-        ata_port_schedule_eh(ap);
-}
-
-#ifdef CONFIG_PM
-static void ata_lpm_enable(struct ata_host *host)
-{
-        struct ata_link *link;
-        struct ata_port *ap;
-        struct ata_device *dev;
-        int i;
-
-        for (i = 0; i < host->n_ports; i++) {
-                ap = host->ports[i];
-                ata_for_each_link(link, ap, EDGE) {
-                        ata_for_each_dev(dev, link, ALL)
-                                ata_dev_disable_pm(dev);
-                }
-        }
-}
-
-static void ata_lpm_disable(struct ata_host *host)
-{
-        int i;
-
-        for (i = 0; i < host->n_ports; i++) {
-                struct ata_port *ap = host->ports[i];
-                ata_lpm_schedule(ap, ap->pm_policy);
-        }
-}
-#endif  /* CONFIG_PM */
-
 /**
  *      ata_dev_classify - determine device type based on ATA-spec signature
  *      @tf: ATA taskfile register set for device to be identified
@@ -1806,8 +1628,14 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
                 }
         }
 
+        if (ap->ops->error_handler)
+                ata_eh_release(ap);
+
         rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
 
+        if (ap->ops->error_handler)
+                ata_eh_acquire(ap);
+
         ata_sff_flush_pio_task(ap);
 
         if (!rc) {
@@ -2412,7 +2240,7 @@ int ata_dev_configure(struct ata_device *dev)
                         if (id[ATA_ID_CFA_KEY_MGMT] & 1)
                                 ata_dev_printk(dev, KERN_WARNING,
                                                "supports DRM functions and may "
-                                               "not be fully accessable.\n");
+                                               "not be fully accessible.\n");
                         snprintf(revbuf, 7, "CFA");
                 } else {
                         snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
@@ -2420,7 +2248,7 @@ int ata_dev_configure(struct ata_device *dev)
                         if (ata_id_has_tpm(id))
                                 ata_dev_printk(dev, KERN_WARNING,
                                                "supports DRM functions and may "
-                                               "not be fully accessable.\n");
+                                               "not be fully accessible.\n");
                 }
 
                 dev->n_sectors = ata_id_n_sectors(id);
@@ -2564,13 +2392,6 @@ int ata_dev_configure(struct ata_device *dev)
         if (dev->flags & ATA_DFLAG_LBA48)
                 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
 
-        if (!(dev->horkage & ATA_HORKAGE_IPM)) {
-                if (ata_id_has_hipm(dev->id))
-                        dev->flags |= ATA_DFLAG_HIPM;
-                if (ata_id_has_dipm(dev->id))
-                        dev->flags |= ATA_DFLAG_DIPM;
-        }
-
         /* Limit PATA drive on SATA cable bridge transfers to udma5,
            200 sectors */
         if (ata_dev_knobble(dev)) {
@@ -2591,13 +2412,6 @@ int ata_dev_configure(struct ata_device *dev)
                 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
                                          dev->max_sectors);
 
-        if (ata_dev_blacklisted(dev) & ATA_HORKAGE_IPM) {
-                dev->horkage |= ATA_HORKAGE_IPM;
-
-                /* reset link pm_policy for this port to no pm */
-                ap->pm_policy = MAX_PERFORMANCE;
-        }
-
         if (ap->ops->dev_config)
                 ap->ops->dev_config(dev);
 
@@ -3596,7 +3410,7 @@ int ata_wait_ready(struct ata_link *link, unsigned long deadline,
                         warned = 1;
                 }
 
-                msleep(50);
+                ata_msleep(link->ap, 50);
         }
 }
 
@@ -3617,7 +3431,7 @@ int ata_wait_ready(struct ata_link *link, unsigned long deadline,
 int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
                                 int (*check_ready)(struct ata_link *link))
 {
-        msleep(ATA_WAIT_AFTER_RESET);
+        ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
 
         return ata_wait_ready(link, deadline, check_ready);
 }
@@ -3628,7 +3442,7 @@ int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
  *      @params: timing parameters { interval, duratinon, timeout } in msec
  *      @deadline: deadline jiffies for the operation
  *
-*       Make sure SStatus of @link 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
@@ -3665,7 +3479,7 @@ int sata_link_debounce(struct ata_link *link, const unsigned long *params,
         last_jiffies = jiffies;
 
         while (1) {
-                msleep(interval);
+                ata_msleep(link->ap, interval);
                 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
                         return rc;
                 cur &= 0xf;
@@ -3730,7 +3544,7 @@ int sata_link_resume(struct ata_link *link, const unsigned long *params,
                  * immediately after resuming.  Delay 200ms before
                  * debouncing.
                  */
-                msleep(200);
+                ata_msleep(link->ap, 200);
 
                 /* is SControl restored correctly? */
                 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
@@ -3760,6 +3574,78 @@ int sata_link_resume(struct ata_link *link, const unsigned long *params,
 }
 
 /**
+ *      sata_link_scr_lpm - manipulate SControl IPM and SPM fields
+ *      @link: ATA link to manipulate SControl for
+ *      @policy: LPM policy to configure
+ *      @spm_wakeup: initiate LPM transition to active state
+ *
+ *      Manipulate the IPM field of the SControl register of @link
+ *      according to @policy.  If @policy is ATA_LPM_MAX_POWER and
+ *      @spm_wakeup is %true, the SPM field is manipulated to wake up
+ *      the link.  This function also clears PHYRDY_CHG before
+ *      returning.
+ *
+ *      LOCKING:
+ *      EH context.
+ *
+ *      RETURNS:
+ *      0 on succes, -errno otherwise.
+ */
+int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                      bool spm_wakeup)
+{
+        struct ata_eh_context *ehc = &link->eh_context;
+        bool woken_up = false;
+        u32 scontrol;
+        int rc;
+
+        rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
+        if (rc)
+                return rc;
+
+        switch (policy) {
+        case ATA_LPM_MAX_POWER:
+                /* disable all LPM transitions */
+                scontrol |= (0x3 << 8);
+                /* initiate transition to active state */
+                if (spm_wakeup) {
+                        scontrol |= (0x4 << 12);
+                        woken_up = true;
+                }
+                break;
+        case ATA_LPM_MED_POWER:
+                /* allow LPM to PARTIAL */
+                scontrol &= ~(0x1 << 8);
+                scontrol |= (0x2 << 8);
+                break;
+        case ATA_LPM_MIN_POWER:
+                if (ata_link_nr_enabled(link) > 0)
+                        /* no restrictions on LPM transitions */
+                        scontrol &= ~(0x3 << 8);
+                else {
+                        /* empty port, power off */
+                        scontrol &= ~0xf;
+                        scontrol |= (0x1 << 2);
+                }
+                break;
+        default:
+                WARN_ON(1);
+        }
+
+        rc = sata_scr_write(link, SCR_CONTROL, scontrol);
+        if (rc)
+                return rc;
+
+        /* give the link time to transit out of LPM state */
+        if (woken_up)
+                msleep(10);
+
+        /* clear PHYRDY_CHG from SError */
+        ehc->i.serror &= ~SERR_PHYRDY_CHG;
+        return sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
+}
+
+/**
  *      ata_std_prereset - prepare for reset
  *      @link: ATA link to be reset
  *      @deadline: deadline jiffies for the operation
@@ -3868,7 +3754,7 @@ int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
         /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
          * 10.4.2 says at least 1 ms.
          */
-        msleep(1);
+        ata_msleep(link->ap, 1);
 
         /* bring link back */
         rc = sata_link_resume(link, timing, deadline);
@@ -4257,7 +4143,9 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
          * Devices which choke on SETXFER.  Applies only if both the
          * device and controller are SATA.
          */
-        { "PIONEER DVD-RW  DVRTD08",    "1.00", ATA_HORKAGE_NOSETXFER },
+        { "PIONEER DVD-RW  DVRTD08",    NULL,   ATA_HORKAGE_NOSETXFER },
+        { "PIONEER DVD-RW  DVR-212D",   NULL,   ATA_HORKAGE_NOSETXFER },
+        { "PIONEER DVD-RW  DVR-216D",   NULL,   ATA_HORKAGE_NOSETXFER },
 
         /* End Marker */
         { }
@@ -4329,7 +4217,7 @@ static int glob_match (const char *text, const char *pattern)
                 return 0;  /* End of both strings: match */
         return 1;  /* No match */
 }
- 
+
 static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
 {
         unsigned char model_num[ATA_ID_PROD_LEN + 1];
@@ -4551,6 +4439,7 @@ static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
         DPRINTK("EXIT, err_mask=%x\n", err_mask);
         return err_mask;
 }
+
 /**
  *      ata_dev_set_feature - Issue SET FEATURES - SATA FEATURES
  *      @dev: Device to which command will be sent
@@ -4566,8 +4455,7 @@ static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
  *      RETURNS:
  *      0 on success, AC_ERR_* mask otherwise.
  */
-static unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable,
-                                        u8 feature)
+unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable, u8 feature)
 {
         struct ata_taskfile tf;
         unsigned int err_mask;
@@ -4927,9 +4815,6 @@ static void ata_verify_xfer(struct ata_queued_cmd *qc)
 {
         struct ata_device *dev = qc->dev;
 
-        if (ata_tag_internal(qc->tag))
-                return;
-
         if (ata_is_nodata(qc->tf.protocol))
                 return;
 
@@ -4943,8 +4828,13 @@ static void ata_verify_xfer(struct ata_queued_cmd *qc)
  *      ata_qc_complete - Complete an active ATA command
  *      @qc: Command to complete
  *
- *      Indicate to the mid and upper layers that an ATA
- *      command has completed, with either an ok or not-ok status.
+ *      Indicate to the mid and upper layers that an ATA command has
+ *      completed, with either an ok or not-ok status.
+ *
+ *      Refrain from calling this function multiple times when
+ *      successfully completing multiple NCQ commands.
+ *      ata_qc_complete_multiple() should be used instead, which will
+ *      properly update IRQ expect state.
  *
  *      LOCKING:
  *      spin_lock_irqsave(host lock)
@@ -4973,14 +4863,23 @@ void ata_qc_complete(struct ata_queued_cmd *qc)
                 if (unlikely(qc->err_mask))
                         qc->flags |= ATA_QCFLAG_FAILED;
 
-                if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
-                        /* always fill result TF for failed qc */
+                /*
+                 * Finish internal commands without any further processing
+                 * and always with the result TF filled.
+                 */
+                if (unlikely(ata_tag_internal(qc->tag))) {
                         fill_result_tf(qc);
+                        __ata_qc_complete(qc);
+                        return;
+                }
 
-                        if (!ata_tag_internal(qc->tag))
-                                ata_qc_schedule_eh(qc);
-                        else
-                                __ata_qc_complete(qc);
+                /*
+                 * Non-internal qc has failed.  Fill the result TF and
+                 * summon EH.
+                 */
+                if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
+                        fill_result_tf(qc);
+                        ata_qc_schedule_eh(qc);
                         return;
                 }
 
@@ -5037,6 +4936,10 @@ void ata_qc_complete(struct ata_queued_cmd *qc)
  *      requests normally.  ap->qc_active and @qc_active is compared
  *      and commands are completed accordingly.
  *
+ *      Always use this function when completing multiple NCQ commands
+ *      from IRQ handlers instead of calling ata_qc_complete()
+ *      multiple times to keep IRQ expect status properly in sync.
+ *
  *      LOCKING:
  *      spin_lock_irqsave(host lock)
  *
@@ -5422,12 +5325,6 @@ int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
         int rc;
 
         /*
-         * disable link pm on all ports before requesting
-         * any pm activity
-         */
-        ata_lpm_enable(host);
-
-        /*
          * On some hardware, device fails to respond after spun down
          * for suspend.  As the device won't be used before being
          * resumed, we don't need to touch the device.  Ask EH to skip
@@ -5450,7 +5347,7 @@ int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
  *
  *      Resume @host.  Actual operation is performed by EH.  This
  *      function requests EH to perform PM operations and returns.
- *      Note that all resume operations are performed parallely.
+ *      Note that all resume operations are performed parallelly.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep).
@@ -5460,9 +5357,6 @@ void ata_host_resume(struct ata_host *host)
         ata_host_request_pm(host, PMSG_ON, ATA_EH_RESET,
                             ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0);
         host->dev->power.power_state = PMSG_ON;
-
-        /* reenable link pm */
-        ata_lpm_disable(host);
 }
 #endif
 
@@ -5517,7 +5411,8 @@ 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]));
+        memset((void *)link + ATA_LINK_CLEAR_BEGIN, 0,
+               ATA_LINK_CLEAR_END - ATA_LINK_CLEAR_BEGIN);
 
         link->ap = ap;
         link->pmp = pmp;
@@ -5592,7 +5487,7 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
         if (!ap)
                 return NULL;
 
-        ap->pflags |= ATA_PFLAG_INITIALIZING;
+        ap->pflags |= ATA_PFLAG_INITIALIZING | ATA_PFLAG_FROZEN;
         ap->lock = &host->lock;
         ap->print_id = -1;
         ap->host = host;
@@ -5695,6 +5590,7 @@ struct ata_host *ata_host_alloc(struct device *dev, int max_ports)
         dev_set_drvdata(dev, host);
 
         spin_lock_init(&host->lock);
+        mutex_init(&host->eh_mutex);
         host->dev = dev;
         host->n_ports = max_ports;
 
@@ -5992,26 +5888,15 @@ void ata_host_init(struct ata_host *host, struct device *dev,
                    unsigned long flags, struct ata_port_operations *ops)
 {
         spin_lock_init(&host->lock);
+        mutex_init(&host->eh_mutex);
         host->dev = dev;
         host->flags = flags;
         host->ops = ops;
 }
 
-
-static void async_port_probe(void *data, async_cookie_t cookie)
+int ata_port_probe(struct ata_port *ap)
 {
-        int rc;
-        struct ata_port *ap = data;
-
-        /*
-         * If we're not allowed to scan this host in parallel,
-         * we need to wait until all previous scans have completed
-         * before going further.
-         * Jeff Garzik says this is only within a controller, so we
-         * don't need to wait for port 0, only for later ports.
-         */
-        if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0)
-                async_synchronize_cookie(cookie);
+        int rc = 0;
 
         /* probe */
         if (ap->ops->error_handler) {
@@ -6022,7 +5907,7 @@ static void async_port_probe(void *data, async_cookie_t cookie)
                 spin_lock_irqsave(ap->lock, flags);
 
                 ehi->probe_mask |= ATA_ALL_DEVICES;
-                ehi->action |= ATA_EH_RESET | ATA_EH_LPM;
+                ehi->action |= ATA_EH_RESET;
                 ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
 
                 ap->pflags &= ~ATA_PFLAG_INITIALIZING;
@@ -6037,23 +5922,33 @@ static void async_port_probe(void *data, async_cookie_t cookie)
                 DPRINTK("ata%u: bus probe begin\n", ap->print_id);
                 rc = ata_bus_probe(ap);
                 DPRINTK("ata%u: bus probe end\n", ap->print_id);
-
-                if (rc) {
-                        /* FIXME: do something useful here?
-                         * Current libata behavior will
-                         * tear down everything when
-                         * the module is removed
-                         * or the h/w is unplugged.
-                         */
-                }
         }
+        return rc;
+}
+
+
+static void async_port_probe(void *data, async_cookie_t cookie)
+{
+        struct ata_port *ap = data;
+
+        /*
+         * If we're not allowed to scan this host in parallel,
+         * we need to wait until all previous scans have completed
+         * before going further.
+         * Jeff Garzik says this is only within a controller, so we
+         * don't need to wait for port 0, only for later ports.
+         */
+        if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0)
+                async_synchronize_cookie(cookie);
+
+        (void)ata_port_probe(ap);
 
         /* in order to keep device order, we need to synchronize at this point */
         async_synchronize_cookie(cookie);
 
         ata_scsi_scan_host(ap, 1);
-
 }
+
 /**
  *      ata_host_register - register initialized ATA host
  *      @host: ATA host to register
@@ -6093,9 +5988,18 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
         for (i = 0; i < host->n_ports; i++)
                 host->ports[i]->print_id = ata_print_id++;
 
+
+        /* Create associated sysfs transport objects  */
+        for (i = 0; i < host->n_ports; i++) {
+                rc = ata_tport_add(host->dev,host->ports[i]);
+                if (rc) {
+                        goto err_tadd;
+                }
+        }
+
         rc = ata_scsi_add_hosts(host, sht);
         if (rc)
-                return rc;
+                goto err_tadd;
 
         /* associate with ACPI nodes */
         ata_acpi_associate(host);
@@ -6136,6 +6040,13 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
         }
 
         return 0;
+
+ err_tadd:
+        while (--i >= 0) {
+                ata_tport_delete(host->ports[i]);
+        }
+        return rc;
+
 }
 
 /**
@@ -6223,9 +6134,16 @@ static void ata_port_detach(struct ata_port *ap)
         /* it better be dead now */
         WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED));
 
-        cancel_rearming_delayed_work(&ap->hotplug_task);
+        cancel_delayed_work_sync(&ap->hotplug_task);
 
  skip_eh:
+        if (ap->pmp_link) {
+                int i;
+                for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
+                        ata_tlink_delete(&ap->pmp_link[i]);
+        }
+        ata_tport_delete(ap);
+
         /* remove the associated SCSI host */
         scsi_remove_host(ap->scsi_host);
 }
@@ -6542,7 +6460,7 @@ static void __init ata_parse_force_param(void)
 
 static int __init ata_init(void)
 {
-        int rc = -ENOMEM;
+        int rc;
 
         ata_parse_force_param();
 
@@ -6552,12 +6470,25 @@ static int __init ata_init(void)
                 return rc;
         }
 
+        libata_transport_init();
+        ata_scsi_transport_template = ata_attach_transport();
+        if (!ata_scsi_transport_template) {
+                ata_sff_exit();
+                rc = -ENOMEM;
+                goto err_out;
+        }
+
         printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
         return 0;
+
+err_out:
+        return rc;
 }
 
 static void __exit ata_exit(void)
 {
+        ata_release_transport(ata_scsi_transport_template);
+        libata_transport_exit();
         ata_sff_exit();
         kfree(ata_force_tbl);
 }
@@ -6573,7 +6504,35 @@ int ata_ratelimit(void)
 }
 
 /**
+ *      ata_msleep - ATA EH owner aware msleep
+ *      @ap: ATA port to attribute the sleep to
+ *      @msecs: duration to sleep in milliseconds
+ *
+ *      Sleeps @msecs.  If the current task is owner of @ap's EH, the
+ *      ownership is released before going to sleep and reacquired
+ *      after the sleep is complete.  IOW, other ports sharing the
+ *      @ap->host will be allowed to own the EH while this task is
+ *      sleeping.
+ *
+ *      LOCKING:
+ *      Might sleep.
+ */
+void ata_msleep(struct ata_port *ap, unsigned int msecs)
+{
+        bool owns_eh = ap && ap->host->eh_owner == current;
+
+        if (owns_eh)
+                ata_eh_release(ap);
+
+        msleep(msecs);
+
+        if (owns_eh)
+                ata_eh_acquire(ap);
+}
+
+/**
  *      ata_wait_register - wait until register value changes
+ *      @ap: ATA port to wait register for, can be NULL
  *      @reg: IO-mapped register
  *      @mask: Mask to apply to read register value
  *      @val: Wait condition
@@ -6595,7 +6554,7 @@ int ata_ratelimit(void)
  *      RETURNS:
  *      The final register value.
  */
-u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
+u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask, u32 val,
                       unsigned long interval, unsigned long timeout)
 {
         unsigned long deadline;
@@ -6610,7 +6569,7 @@ u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
         deadline = ata_deadline(jiffies, timeout);
 
         while ((tmp & mask) == val && time_before(jiffies, deadline)) {
-                msleep(interval);
+                ata_msleep(ap, interval);
                 tmp = ioread32(reg);
         }
 
@@ -6686,6 +6645,7 @@ EXPORT_SYMBOL_GPL(sata_set_spd);
 EXPORT_SYMBOL_GPL(ata_wait_after_reset);
 EXPORT_SYMBOL_GPL(sata_link_debounce);
 EXPORT_SYMBOL_GPL(sata_link_resume);
+EXPORT_SYMBOL_GPL(sata_link_scr_lpm);
 EXPORT_SYMBOL_GPL(ata_std_prereset);
 EXPORT_SYMBOL_GPL(sata_link_hardreset);
 EXPORT_SYMBOL_GPL(sata_std_hardreset);
@@ -6693,6 +6653,7 @@ EXPORT_SYMBOL_GPL(ata_std_postreset);
 EXPORT_SYMBOL_GPL(ata_dev_classify);
 EXPORT_SYMBOL_GPL(ata_dev_pair);
 EXPORT_SYMBOL_GPL(ata_ratelimit);
+EXPORT_SYMBOL_GPL(ata_msleep);
 EXPORT_SYMBOL_GPL(ata_wait_register);
 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index e48302eae55f..7f099d6e4e0b 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -57,6 +57,7 @@ enum {
         /* error flags */
         ATA_EFLAG_IS_IO                 = (1 << 0),
         ATA_EFLAG_DUBIOUS_XFER          = (1 << 1),
+        ATA_EFLAG_OLD_ER                = (1 << 31),
 
         /* error categories */
         ATA_ECAT_NONE                   = 0,
@@ -396,14 +397,9 @@ static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
         return NULL;
 }
 
-static void ata_ering_clear(struct ata_ering *ering)
-{
-        memset(ering, 0, sizeof(*ering));
-}
-
-static int ata_ering_map(struct ata_ering *ering,
-                         int (*map_fn)(struct ata_ering_entry *, void *),
-                         void *arg)
+int ata_ering_map(struct ata_ering *ering,
+                  int (*map_fn)(struct ata_ering_entry *, void *),
+                  void *arg)
 {
         int idx, rc = 0;
         struct ata_ering_entry *ent;
@@ -422,6 +418,17 @@ static int ata_ering_map(struct ata_ering *ering,
         return rc;
 }
 
+int ata_ering_clear_cb(struct ata_ering_entry *ent, void *void_arg)
+{
+        ent->eflags |= ATA_EFLAG_OLD_ER;
+        return 0;
+}
+
+static void ata_ering_clear(struct ata_ering *ering)
+{
+        ata_ering_map(ering, ata_ering_clear_cb, NULL);
+}
+
 static unsigned int ata_eh_dev_action(struct ata_device *dev)
 {
         struct ata_eh_context *ehc = &dev->link->eh_context;
@@ -456,6 +463,41 @@ static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
 }
 
 /**
+ *      ata_eh_acquire - acquire EH ownership
+ *      @ap: ATA port to acquire EH ownership for
+ *
+ *      Acquire EH ownership for @ap.  This is the basic exclusion
+ *      mechanism for ports sharing a host.  Only one port hanging off
+ *      the same host can claim the ownership of EH.
+ *
+ *      LOCKING:
+ *      EH context.
+ */
+void ata_eh_acquire(struct ata_port *ap)
+{
+        mutex_lock(&ap->host->eh_mutex);
+        WARN_ON_ONCE(ap->host->eh_owner);
+        ap->host->eh_owner = current;
+}
+
+/**
+ *      ata_eh_release - release EH ownership
+ *      @ap: ATA port to release EH ownership for
+ *
+ *      Release EH ownership for @ap if the caller.  The caller must
+ *      have acquired EH ownership using ata_eh_acquire() previously.
+ *
+ *      LOCKING:
+ *      EH context.
+ */
+void ata_eh_release(struct ata_port *ap)
+{
+        WARN_ON_ONCE(ap->host->eh_owner != current);
+        ap->host->eh_owner = NULL;
+        mutex_unlock(&ap->host->eh_mutex);
+}
+
+/**
  *      ata_scsi_timed_out - SCSI layer time out callback
  *      @cmd: timed out SCSI command
  *
@@ -545,11 +587,43 @@ static void ata_eh_unload(struct ata_port *ap)
 void ata_scsi_error(struct Scsi_Host *host)
 {
         struct ata_port *ap = ata_shost_to_port(host);
-        int i;
         unsigned long flags;
+        LIST_HEAD(eh_work_q);
 
         DPRINTK("ENTER\n");
 
+        spin_lock_irqsave(host->host_lock, flags);
+        list_splice_init(&host->eh_cmd_q, &eh_work_q);
+        spin_unlock_irqrestore(host->host_lock, flags);
+
+        ata_scsi_cmd_error_handler(host, ap, &eh_work_q);
+
+        /* If we timed raced normal completion and there is nothing to
+           recover nr_timedout == 0 why exactly are we doing error recovery ? */
+        ata_scsi_port_error_handler(host, ap);
+
+        /* finish or retry handled scmd's and clean up */
+        WARN_ON(host->host_failed || !list_empty(&eh_work_q));
+
+        DPRINTK("EXIT\n");
+}
+
+/**
+ * ata_scsi_cmd_error_handler - error callback for a list of commands
+ * @host:       scsi host containing the port
+ * @ap:         ATA port within the host
+ * @eh_work_q:  list of commands to process
+ *
+ * process the given list of commands and return those finished to the
+ * ap->eh_done_q.  This function is the first part of the libata error
+ * handler which processes a given list of failed commands.
+ */
+void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap,
+                                struct list_head *eh_work_q)
+{
+        int i;
+        unsigned long flags;
+
         /* make sure sff pio task is not running */
         ata_sff_flush_pio_task(ap);
 
@@ -572,20 +646,20 @@ void ata_scsi_error(struct Scsi_Host *host)
                 int nr_timedout = 0;
 
                 spin_lock_irqsave(ap->lock, flags);
-                
+
                 /* This must occur under the ap->lock as we don't want
                    a polled recovery to race the real interrupt handler
-                   
+
                    The lost_interrupt handler checks for any completed but
                    non-notified command and completes much like an IRQ handler.
-                   
+
                    We then fall into the error recovery code which will treat
                    this as if normal completion won the race */
 
                 if (ap->ops->lost_interrupt)
                         ap->ops->lost_interrupt(ap);
-                        
-                list_for_each_entry_safe(scmd, tmp, &host->eh_cmd_q, eh_entry) {
+
+                list_for_each_entry_safe(scmd, tmp, eh_work_q, eh_entry) {
                         struct ata_queued_cmd *qc;
 
                         for (i = 0; i < ATA_MAX_QUEUE; i++) {
@@ -628,15 +702,29 @@ void ata_scsi_error(struct Scsi_Host *host)
                 ap->eh_tries = ATA_EH_MAX_TRIES;
         } else
                 spin_unlock_wait(ap->lock);
-                
-        /* If we timed raced normal completion and there is nothing to
-           recover nr_timedout == 0 why exactly are we doing error recovery ? */
 
- repeat:
+}
+EXPORT_SYMBOL(ata_scsi_cmd_error_handler);
+
+/**
+ * ata_scsi_port_error_handler - recover the port after the commands
+ * @host:       SCSI host containing the port
+ * @ap:         the ATA port
+ *
+ * Handle the recovery of the port @ap after all the commands
+ * have been recovered.
+ */
+void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap)
+{
+        unsigned long flags;
+
         /* invoke error handler */
         if (ap->ops->error_handler) {
                 struct ata_link *link;
 
+                /* acquire EH ownership */
+                ata_eh_acquire(ap);
+ repeat:
                 /* kill fast drain timer */
                 del_timer_sync(&ap->fastdrain_timer);
 
@@ -683,7 +771,7 @@ void ata_scsi_error(struct Scsi_Host *host)
                 /* process port suspend request */
                 ata_eh_handle_port_suspend(ap);
 
-                /* Exception might have happend after ->error_handler
+                /* Exception might have happened after ->error_handler
                  * recovered the port but before this point.  Repeat
                  * EH in such case.
                  */
@@ -711,14 +799,12 @@ void ata_scsi_error(struct Scsi_Host *host)
                 host->host_eh_scheduled = 0;
 
                 spin_unlock_irqrestore(ap->lock, flags);
+                ata_eh_release(ap);
         } else {
                 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
                 ap->ops->eng_timeout(ap);
         }
 
-        /* finish or retry handled scmd's and clean up */
-        WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q));
-
         scsi_eh_flush_done_q(&ap->eh_done_q);
 
         /* clean up */
@@ -739,9 +825,8 @@ void ata_scsi_error(struct Scsi_Host *host)
         wake_up_all(&ap->eh_wait_q);
 
         spin_unlock_irqrestore(ap->lock, flags);
-
-        DPRINTK("EXIT\n");
 }
+EXPORT_SYMBOL_GPL(ata_scsi_port_error_handler);
 
 /**
  *      ata_port_wait_eh - Wait for the currently pending EH to complete
@@ -772,7 +857,7 @@ void ata_port_wait_eh(struct ata_port *ap)
 
         /* make sure SCSI EH is complete */
         if (scsi_host_in_recovery(ap->scsi_host)) {
-                msleep(10);
+                ata_msleep(ap, 10);
                 goto retry;
         }
 }
@@ -1573,9 +1658,9 @@ static void ata_eh_analyze_serror(struct ata_link *link)
          * 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))
+        if (link->lpm_policy > ATA_LPM_MAX_POWER)
+                hotplug_mask = 0;       /* hotplug doesn't work w/ LPM */
+        else 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;
@@ -1657,7 +1742,7 @@ void ata_eh_analyze_ncq_error(struct ata_link *link)
  *
  *      Analyze taskfile of @qc and further determine cause of
  *      failure.  This function also requests ATAPI sense data if
- *      avaliable.
+ *      available.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep).
@@ -1755,7 +1840,7 @@ static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
         struct speed_down_verdict_arg *arg = void_arg;
         int cat;
 
-        if (ent->timestamp < arg->since)
+        if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < arg->since))
                 return -1;
 
         cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
@@ -1808,7 +1893,7 @@ static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
  *         occurred during last 5 mins, NCQ_OFF.
  *
  *      3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
- *         ocurred during last 5 mins, FALLBACK_TO_PIO
+ *         occurred during last 5 mins, FALLBACK_TO_PIO
  *
  *      4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
  *         during last 10 mins, NCQ_OFF.
@@ -2492,7 +2577,7 @@ int ata_eh_reset(struct ata_link *link, int classify,
         if (link->flags & ATA_LFLAG_NO_SRST)
                 softreset = NULL;
 
-        /* make sure each reset attemp is at least COOL_DOWN apart */
+        /* make sure each reset attempt is at least COOL_DOWN apart */
         if (ehc->i.flags & ATA_EHI_DID_RESET) {
                 now = jiffies;
                 WARN_ON(time_after(ehc->last_reset, now));
@@ -2651,7 +2736,7 @@ int ata_eh_reset(struct ata_link *link, int classify,
                         if (!reset) {
                                 ata_link_printk(link, KERN_ERR,
                                                 "follow-up softreset required "
-                                                "but no softreset avaliable\n");
+                                                "but no softreset available\n");
                                 failed_link = link;
                                 rc = -EINVAL;
                                 goto fail;
@@ -2717,10 +2802,11 @@ int ata_eh_reset(struct ata_link *link, int classify,
         }
 
         /*
-         * Some controllers can't be frozen very well and may set
-         * spuruious error conditions during reset.  Clear accumulated
-         * error information.  As reset is the final recovery action,
-         * nothing is lost by doing this.
+         * Some controllers can't be frozen very well and may set spurious
+         * error conditions during reset.  Clear accumulated error
+         * information and re-thaw the port if frozen.  As reset is the
+         * final recovery action and we cross check link onlineness against
+         * device classification later, no hotplug event is lost by this.
          */
         spin_lock_irqsave(link->ap->lock, flags);
         memset(&link->eh_info, 0, sizeof(link->eh_info));
@@ -2729,6 +2815,9 @@ int ata_eh_reset(struct ata_link *link, int classify,
         ap->pflags &= ~ATA_PFLAG_EH_PENDING;
         spin_unlock_irqrestore(link->ap->lock, flags);
 
+        if (ap->pflags & ATA_PFLAG_FROZEN)
+                ata_eh_thaw_port(ap);
+
         /*
          * Make sure onlineness and classification result correspond.
          * Hotplug could have happened during reset and some
@@ -2777,8 +2866,9 @@ int ata_eh_reset(struct ata_link *link, int classify,
         ata_eh_done(link, NULL, ATA_EH_RESET);
         if (slave)
                 ata_eh_done(slave, NULL, ATA_EH_RESET);
-        ehc->last_reset = jiffies;      /* update to completion time */
+        ehc->last_reset = jiffies;              /* update to completion time */
         ehc->i.action |= ATA_EH_REVALIDATE;
+        link->lpm_policy = ATA_LPM_UNKNOWN;     /* reset LPM state */
 
         rc = 0;
  out:
@@ -2810,8 +2900,10 @@ int ata_eh_reset(struct ata_link *link, int classify,
                         "reset failed (errno=%d), retrying in %u secs\n",
                         rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
 
+                ata_eh_release(ap);
                 while (delta)
                         delta = schedule_timeout_uninterruptible(delta);
+                ata_eh_acquire(ap);
         }
 
         if (try == max_tries - 1) {
@@ -3204,7 +3296,138 @@ static int ata_eh_maybe_retry_flush(struct ata_device *dev)
         return rc;
 }
 
-static int ata_link_nr_enabled(struct ata_link *link)
+/**
+ *      ata_eh_set_lpm - configure SATA interface power management
+ *      @link: link to configure power management
+ *      @policy: the link power management policy
+ *      @r_failed_dev: out parameter for failed device
+ *
+ *      Enable SATA Interface power management.  This will enable
+ *      Device Interface Power Management (DIPM) for min_power
+ *      policy, and then call driver specific callbacks for
+ *      enabling Host Initiated Power management.
+ *
+ *      LOCKING:
+ *      EH context.
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+static int ata_eh_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                          struct ata_device **r_failed_dev)
+{
+        struct ata_port *ap = ata_is_host_link(link) ? link->ap : NULL;
+        struct ata_eh_context *ehc = &link->eh_context;
+        struct ata_device *dev, *link_dev = NULL, *lpm_dev = NULL;
+        enum ata_lpm_policy old_policy = link->lpm_policy;
+        bool no_dipm = link->ap->flags & ATA_FLAG_NO_DIPM;
+        unsigned int hints = ATA_LPM_EMPTY | ATA_LPM_HIPM;
+        unsigned int err_mask;
+        int rc;
+
+        /* if the link or host doesn't do LPM, noop */
+        if ((link->flags & ATA_LFLAG_NO_LPM) || (ap && !ap->ops->set_lpm))
+                return 0;
+
+        /*
+         * DIPM is enabled only for MIN_POWER as some devices
+         * misbehave when the host NACKs transition to SLUMBER.  Order
+         * device and link configurations such that the host always
+         * allows DIPM requests.
+         */
+        ata_for_each_dev(dev, link, ENABLED) {
+                bool hipm = ata_id_has_hipm(dev->id);
+                bool dipm = ata_id_has_dipm(dev->id) && !no_dipm;
+
+                /* find the first enabled and LPM enabled devices */
+                if (!link_dev)
+                        link_dev = dev;
+
+                if (!lpm_dev && (hipm || dipm))
+                        lpm_dev = dev;
+
+                hints &= ~ATA_LPM_EMPTY;
+                if (!hipm)
+                        hints &= ~ATA_LPM_HIPM;
+
+                /* disable DIPM before changing link config */
+                if (policy != ATA_LPM_MIN_POWER && dipm) {
+                        err_mask = ata_dev_set_feature(dev,
+                                        SETFEATURES_SATA_DISABLE, SATA_DIPM);
+                        if (err_mask && err_mask != AC_ERR_DEV) {
+                                ata_dev_printk(dev, KERN_WARNING,
+                                        "failed to disable DIPM, Emask 0x%x\n",
+                                        err_mask);
+                                rc = -EIO;
+                                goto fail;
+                        }
+                }
+        }
+
+        if (ap) {
+                rc = ap->ops->set_lpm(link, policy, hints);
+                if (!rc && ap->slave_link)
+                        rc = ap->ops->set_lpm(ap->slave_link, policy, hints);
+        } else
+                rc = sata_pmp_set_lpm(link, policy, hints);
+
+        /*
+         * Attribute link config failure to the first (LPM) enabled
+         * device on the link.
+         */
+        if (rc) {
+                if (rc == -EOPNOTSUPP) {
+                        link->flags |= ATA_LFLAG_NO_LPM;
+                        return 0;
+                }
+                dev = lpm_dev ? lpm_dev : link_dev;
+                goto fail;
+        }
+
+        /*
+         * Low level driver acked the transition.  Issue DIPM command
+         * with the new policy set.
+         */
+        link->lpm_policy = policy;
+        if (ap && ap->slave_link)
+                ap->slave_link->lpm_policy = policy;
+
+        /* host config updated, enable DIPM if transitioning to MIN_POWER */
+        ata_for_each_dev(dev, link, ENABLED) {
+                if (policy == ATA_LPM_MIN_POWER && !no_dipm &&
+                    ata_id_has_dipm(dev->id)) {
+                        err_mask = ata_dev_set_feature(dev,
+                                        SETFEATURES_SATA_ENABLE, SATA_DIPM);
+                        if (err_mask && err_mask != AC_ERR_DEV) {
+                                ata_dev_printk(dev, KERN_WARNING,
+                                        "failed to enable DIPM, Emask 0x%x\n",
+                                        err_mask);
+                                rc = -EIO;
+                                goto fail;
+                        }
+                }
+        }
+
+        return 0;
+
+fail:
+        /* restore the old policy */
+        link->lpm_policy = old_policy;
+        if (ap && ap->slave_link)
+                ap->slave_link->lpm_policy = old_policy;
+
+        /* if no device or only one more chance is left, disable LPM */
+        if (!dev || ehc->tries[dev->devno] <= 2) {
+                ata_link_printk(link, KERN_WARNING,
+                                "disabling LPM on the link\n");
+                link->flags |= ATA_LFLAG_NO_LPM;
+        }
+        if (r_failed_dev)
+                *r_failed_dev = dev;
+        return rc;
+}
+
+int ata_link_nr_enabled(struct ata_link *link)
 {
         struct ata_device *dev;
         int cnt = 0;
@@ -3288,6 +3511,16 @@ static int ata_eh_schedule_probe(struct ata_device *dev)
         ehc->saved_xfer_mode[dev->devno] = 0;
         ehc->saved_ncq_enabled &= ~(1 << dev->devno);
 
+        /* the link maybe in a deep sleep, wake it up */
+        if (link->lpm_policy > ATA_LPM_MAX_POWER) {
+                if (ata_is_host_link(link))
+                        link->ap->ops->set_lpm(link, ATA_LPM_MAX_POWER,
+                                               ATA_LPM_EMPTY);
+                else
+                        sata_pmp_set_lpm(link, ATA_LPM_MAX_POWER,
+                                         ATA_LPM_EMPTY);
+        }
+
         /* Record and count probe trials on the ering.  The specific
          * error mask used is irrelevant.  Because a successful device
          * detection clears the ering, this count accumulates only if
@@ -3389,8 +3622,7 @@ int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
 {
         struct ata_link *link;
         struct ata_device *dev;
-        int nr_failed_devs;
-        int rc;
+        int rc, nr_fails;
         unsigned long flags, deadline;
 
         DPRINTK("ENTER\n");
@@ -3431,7 +3663,6 @@ int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
 
  retry:
         rc = 0;
-        nr_failed_devs = 0;
 
         /* if UNLOADING, finish immediately */
         if (ap->pflags & ATA_PFLAG_UNLOADING)
@@ -3501,8 +3732,10 @@ int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
                 if (time_before_eq(deadline, now))
                         break;
 
+                ata_eh_release(ap);
                 deadline = wait_for_completion_timeout(&ap->park_req_pending,
                                                        deadline - now);
+                ata_eh_acquire(ap);
         } while (deadline);
         ata_for_each_link(link, ap, EDGE) {
                 ata_for_each_dev(dev, link, ALL) {
@@ -3516,13 +3749,17 @@ int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
         }
 
         /* the rest */
-        ata_for_each_link(link, ap, EDGE) {
+        nr_fails = 0;
+        ata_for_each_link(link, ap, PMP_FIRST) {
                 struct ata_eh_context *ehc = &link->eh_context;
 
+                if (sata_pmp_attached(ap) && ata_is_host_link(link))
+                        goto config_lpm;
+
                 /* revalidate existing devices and attach new ones */
                 rc = ata_eh_revalidate_and_attach(link, &dev);
                 if (rc)
-                        goto dev_fail;
+                        goto rest_fail;
 
                 /* if PMP got attached, return, pmp EH will take care of it */
                 if (link->device->class == ATA_DEV_PMP) {
@@ -3534,7 +3771,7 @@ int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
                 if (ehc->i.flags & ATA_EHI_SETMODE) {
                         rc = ata_set_mode(link, &dev);
                         if (rc)
-                                goto dev_fail;
+                                goto rest_fail;
                         ehc->i.flags &= ~ATA_EHI_SETMODE;
                 }
 
@@ -3547,7 +3784,7 @@ int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
                                         continue;
                                 rc = atapi_eh_clear_ua(dev);
                                 if (rc)
-                                        goto dev_fail;
+                                        goto rest_fail;
                         }
                 }
 
@@ -3557,21 +3794,25 @@ int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
                                 continue;
                         rc = ata_eh_maybe_retry_flush(dev);
                         if (rc)
-                                goto dev_fail;
+                                goto rest_fail;
                 }
 
+        config_lpm:
                 /* configure link power saving */
-                if (ehc->i.action & ATA_EH_LPM)
-                        ata_for_each_dev(dev, link, ALL)
-                                ata_dev_enable_pm(dev, ap->pm_policy);
+                if (link->lpm_policy != ap->target_lpm_policy) {
+                        rc = ata_eh_set_lpm(link, ap->target_lpm_policy, &dev);
+                        if (rc)
+                                goto rest_fail;
+                }
 
                 /* this link is okay now */
                 ehc->i.flags = 0;
                 continue;
 
-dev_fail:
-                nr_failed_devs++;
-                ata_eh_handle_dev_fail(dev, rc);
+        rest_fail:
+                nr_fails++;
+                if (dev)
+                        ata_eh_handle_dev_fail(dev, rc);
 
                 if (ap->pflags & ATA_PFLAG_FROZEN) {
                         /* PMP reset requires working host port.
@@ -3583,7 +3824,7 @@ dev_fail:
                 }
         }
 
-        if (nr_failed_devs)
+        if (nr_fails)
                 goto retry;
 
  out:
diff --git a/drivers/ata/libata-pmp.c b/drivers/ata/libata-pmp.c
index 224faabd7b7e..f06b7ea590d3 100644
--- a/drivers/ata/libata-pmp.c
+++ b/drivers/ata/libata-pmp.c
@@ -11,6 +11,7 @@
 #include <linux/libata.h>
 #include <linux/slab.h>
 #include "libata.h"
+#include "libata-transport.h"
 
 const struct ata_port_operations sata_pmp_port_ops = {
         .inherits               = &sata_port_ops,
@@ -185,6 +186,27 @@ int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
 }
 
 /**
+ *      sata_pmp_set_lpm - configure LPM for a PMP link
+ *      @link: PMP link to configure LPM for
+ *      @policy: target LPM policy
+ *      @hints: LPM hints
+ *
+ *      Configure LPM for @link.  This function will contain any PMP
+ *      specific workarounds if necessary.
+ *
+ *      LOCKING:
+ *      EH context.
+ *
+ *      RETURNS:
+ *      0 on success, -errno on failure.
+ */
+int sata_pmp_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                     unsigned hints)
+{
+        return sata_link_scr_lpm(link, policy, true);
+}
+
+/**
  *      sata_pmp_read_gscr - read GSCR block of SATA PMP
  *      @dev: PMP device
  *      @gscr: buffer to read GSCR block into
@@ -312,10 +334,10 @@ static int sata_pmp_configure(struct ata_device *dev, int print_info)
         return rc;
 }
 
-static int sata_pmp_init_links(struct ata_port *ap, int nr_ports)
+static int sata_pmp_init_links (struct ata_port *ap, int nr_ports)
 {
         struct ata_link *pmp_link = ap->pmp_link;
-        int i;
+        int i, err;
 
         if (!pmp_link) {
                 pmp_link = kzalloc(sizeof(pmp_link[0]) * SATA_PMP_MAX_PORTS,
@@ -327,6 +349,13 @@ static int sata_pmp_init_links(struct ata_port *ap, int nr_ports)
                         ata_link_init(ap, &pmp_link[i], i);
 
                 ap->pmp_link = pmp_link;
+
+                for (i = 0; i < SATA_PMP_MAX_PORTS; i++) {
+                        err = ata_tlink_add(&pmp_link[i]);
+                        if (err) {
+                                goto err_tlink;
+                        }
+                }
         }
 
         for (i = 0; i < nr_ports; i++) {
@@ -339,6 +368,12 @@ static int sata_pmp_init_links(struct ata_port *ap, int nr_ports)
         }
 
         return 0;
+  err_tlink:
+        while (--i >= 0)
+                ata_tlink_delete(&pmp_link[i]);
+        kfree(pmp_link);
+        ap->pmp_link = NULL;
+        return err;
 }
 
 static void sata_pmp_quirks(struct ata_port *ap)
@@ -351,6 +386,9 @@ static void sata_pmp_quirks(struct ata_port *ap)
         if (vendor == 0x1095 && devid == 0x3726) {
                 /* sil3726 quirks */
                 ata_for_each_link(link, ap, EDGE) {
+                        /* link reports offline after LPM */
+                        link->flags |= ATA_LFLAG_NO_LPM;
+
                         /* Class code report is unreliable and SRST
                          * times out under certain configurations.
                          */
@@ -366,6 +404,9 @@ static void sata_pmp_quirks(struct ata_port *ap)
         } else if (vendor == 0x1095 && devid == 0x4723) {
                 /* sil4723 quirks */
                 ata_for_each_link(link, ap, EDGE) {
+                        /* link reports offline after LPM */
+                        link->flags |= ATA_LFLAG_NO_LPM;
+
                         /* class code report is unreliable */
                         if (link->pmp < 2)
                                 link->flags |= ATA_LFLAG_ASSUME_ATA;
@@ -378,6 +419,9 @@ static void sata_pmp_quirks(struct ata_port *ap)
         } else if (vendor == 0x1095 && devid == 0x4726) {
                 /* sil4726 quirks */
                 ata_for_each_link(link, ap, EDGE) {
+                        /* link reports offline after LPM */
+                        link->flags |= ATA_LFLAG_NO_LPM;
+
                         /* Class code report is unreliable and SRST
                          * times out under certain configurations.
                          * Config device can be at port 0 or 5 and
@@ -405,6 +449,16 @@ static void sata_pmp_quirks(struct ata_port *ap)
                  * otherwise.  Don't try hard to recover it.
                  */
                 ap->pmp_link[ap->nr_pmp_links - 1].flags |= ATA_LFLAG_NO_RETRY;
+        } else if (vendor == 0x197b && devid == 0x2352) {
+                /* chip found in Thermaltake BlackX Duet, jmicron JMB350? */
+                ata_for_each_link(link, ap, EDGE) {
+                        /* SRST breaks detection and disks get misclassified
+                         * LPM disabled to avoid potential problems
+                         */
+                        link->flags |= ATA_LFLAG_NO_LPM |
+                                       ATA_LFLAG_NO_SRST |
+                                       ATA_LFLAG_ASSUME_ATA;
+                }
         }
 }
 
@@ -938,15 +992,25 @@ static int sata_pmp_eh_recover(struct ata_port *ap)
         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);
 
+        /*
+         * If LPM is active on any fan-out port, hotplug wouldn't
+         * work.  Return w/ PHY event notification disabled.
+         */
+        ata_for_each_link(link, ap, EDGE)
+                if (link->lpm_policy > ATA_LPM_MAX_POWER)
+                        return 0;
+
+        /*
+         * Connection status might have changed while resetting other
+         * links, enable notification and check SATA_PMP_GSCR_ERROR
+         * before returning.
+         */
+
         /* enable notification */
         if (pmp_dev->flags & ATA_DFLAG_AN) {
                 gscr[SATA_PMP_GSCR_FEAT_EN] |= SATA_PMP_FEAT_NOTIFY;
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index a89172c100f5..927f968e99d9 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -51,8 +51,8 @@
 #include <asm/unaligned.h>
 
 #include "libata.h"
+#include "libata-transport.h"
 
-#define SECTOR_SIZE             512
 #define ATA_SCSI_RBUF_SIZE      4096
 
 static DEFINE_SPINLOCK(ata_scsi_rbuf_lock);
@@ -64,9 +64,6 @@ static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
                                         const struct scsi_device *scsidev);
 static struct ata_device *ata_scsi_find_dev(struct ata_port *ap,
                                             const struct scsi_device *scsidev);
-static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
-                              unsigned int id, unsigned int lun);
-
 
 #define RW_RECOVERY_MPAGE 0x1
 #define RW_RECOVERY_MPAGE_LEN 12
@@ -106,83 +103,55 @@ static const u8 def_control_mpage[CONTROL_MPAGE_LEN] = {
         0, 30   /* extended self test time, see 05-359r1 */
 };
 
-/*
- * libata transport template.  libata doesn't do real transport stuff.
- * It just needs the eh_timed_out hook.
- */
-static struct scsi_transport_template ata_scsi_transport_template = {
-        .eh_strategy_handler    = ata_scsi_error,
-        .eh_timed_out           = ata_scsi_timed_out,
-        .user_scan              = ata_scsi_user_scan,
+static const char *ata_lpm_policy_names[] = {
+        [ATA_LPM_UNKNOWN]       = "max_performance",
+        [ATA_LPM_MAX_POWER]     = "max_performance",
+        [ATA_LPM_MED_POWER]     = "medium_power",
+        [ATA_LPM_MIN_POWER]     = "min_power",
 };
 
-
-static const struct {
-        enum link_pm    value;
-        const char      *name;
-} link_pm_policy[] = {
-        { NOT_AVAILABLE, "max_performance" },
-        { MIN_POWER, "min_power" },
-        { MAX_PERFORMANCE, "max_performance" },
-        { MEDIUM_POWER, "medium_power" },
-};
-
-static const char *ata_scsi_lpm_get(enum link_pm policy)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(link_pm_policy); i++)
-                if (link_pm_policy[i].value == policy)
-                        return link_pm_policy[i].name;
-
-        return NULL;
-}
-
-static ssize_t ata_scsi_lpm_put(struct device *dev,
-                                struct device_attribute *attr,
-                                const char *buf, size_t count)
+static ssize_t ata_scsi_lpm_store(struct device *dev,
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
 {
         struct Scsi_Host *shost = class_to_shost(dev);
         struct ata_port *ap = ata_shost_to_port(shost);
-        enum link_pm policy = 0;
-        int i;
+        enum ata_lpm_policy policy;
+        unsigned long flags;
 
-        /*
-         * we are skipping array location 0 on purpose - this
-         * is because a value of NOT_AVAILABLE is displayed
-         * to the user as max_performance, but when the user
-         * writes "max_performance", they actually want the
-         * value to match MAX_PERFORMANCE.
-         */
-        for (i = 1; i < ARRAY_SIZE(link_pm_policy); i++) {
-                const int len = strlen(link_pm_policy[i].name);
-                if (strncmp(link_pm_policy[i].name, buf, len) == 0) {
-                        policy = link_pm_policy[i].value;
+        /* UNKNOWN is internal state, iterate from MAX_POWER */
+        for (policy = ATA_LPM_MAX_POWER;
+             policy < ARRAY_SIZE(ata_lpm_policy_names); policy++) {
+                const char *name = ata_lpm_policy_names[policy];
+
+                if (strncmp(name, buf, strlen(name)) == 0)
                         break;
-                }
         }
-        if (!policy)
+        if (policy == ARRAY_SIZE(ata_lpm_policy_names))
                 return -EINVAL;
 
-        ata_lpm_schedule(ap, policy);
+        spin_lock_irqsave(ap->lock, flags);
+        ap->target_lpm_policy = policy;
+        ata_port_schedule_eh(ap);
+        spin_unlock_irqrestore(ap->lock, flags);
+
         return count;
 }
 
-static ssize_t
-ata_scsi_lpm_show(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t ata_scsi_lpm_show(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
 {
         struct Scsi_Host *shost = class_to_shost(dev);
         struct ata_port *ap = ata_shost_to_port(shost);
-        const char *policy =
-                ata_scsi_lpm_get(ap->pm_policy);
 
-        if (!policy)
+        if (ap->target_lpm_policy >= ARRAY_SIZE(ata_lpm_policy_names))
                 return -EINVAL;
 
-        return snprintf(buf, 23, "%s\n", policy);
+        return snprintf(buf, PAGE_SIZE, "%s\n",
+                        ata_lpm_policy_names[ap->target_lpm_policy]);
 }
 DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
-                ata_scsi_lpm_show, ata_scsi_lpm_put);
+            ata_scsi_lpm_show, ata_scsi_lpm_store);
 EXPORT_SYMBOL_GPL(dev_attr_link_power_management_policy);
 
 static ssize_t ata_scsi_park_show(struct device *device,
@@ -377,12 +346,11 @@ struct device_attribute *ata_common_sdev_attrs[] = {
 };
 EXPORT_SYMBOL_GPL(ata_common_sdev_attrs);
 
-static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
-                                   void (*done)(struct scsi_cmnd *))
+static void ata_scsi_invalid_field(struct scsi_cmnd *cmd)
 {
         ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x24, 0x0);
         /* "Invalid field in cbd" */
-        done(cmd);
+        cmd->scsi_done(cmd);
 }
 
 /**
@@ -516,7 +484,7 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
         memset(scsi_cmd, 0, sizeof(scsi_cmd));
 
         if (args[3]) {
-                argsize = SECTOR_SIZE * args[3];
+                argsize = ATA_SECT_SIZE * args[3];
                 argbuf = kmalloc(argsize, GFP_KERNEL);
                 if (argbuf == NULL) {
                         rc = -ENOMEM;
@@ -750,7 +718,6 @@ EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
  *      ata_scsi_qc_new - acquire new ata_queued_cmd reference
  *      @dev: ATA device to which the new command is attached
  *      @cmd: SCSI command that originated this ATA command
- *      @done: SCSI command completion function
  *
  *      Obtain a reference to an unused ata_queued_cmd structure,
  *      which is the basic libata structure representing a single
@@ -767,21 +734,20 @@ EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
  *      Command allocated, or %NULL if none available.
  */
 static struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
-                                              struct scsi_cmnd *cmd,
-                                              void (*done)(struct scsi_cmnd *))
+                                              struct scsi_cmnd *cmd)
 {
         struct ata_queued_cmd *qc;
 
         qc = ata_qc_new_init(dev);
         if (qc) {
                 qc->scsicmd = cmd;
-                qc->scsidone = done;
+                qc->scsidone = cmd->scsi_done;
 
                 qc->sg = scsi_sglist(cmd);
                 qc->n_elem = scsi_sg_count(cmd);
         } else {
                 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
-                done(cmd);
+                cmd->scsi_done(cmd);
         }
 
         return qc;
@@ -1033,7 +999,7 @@ static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
  *      @qc: Command that we are erroring out
  *
  *      Generate sense block for a failed ATA command @qc.  Descriptor
- *      format is used to accomodate LBA48 block address.
+ *      format is used to accommodate LBA48 block address.
  *
  *      LOCKING:
  *      None.
@@ -1123,21 +1089,21 @@ static int atapi_drain_needed(struct request *rq)
 static int ata_scsi_dev_config(struct scsi_device *sdev,
                                struct ata_device *dev)
 {
+        struct request_queue *q = sdev->request_queue;
+
         if (!ata_id_has_unload(dev->id))
                 dev->flags |= ATA_DFLAG_NO_UNLOAD;
 
         /* configure max sectors */
-        blk_queue_max_hw_sectors(sdev->request_queue, dev->max_sectors);
+        blk_queue_max_hw_sectors(q, dev->max_sectors);
 
         if (dev->class == ATA_DEV_ATAPI) {
-                struct request_queue *q = sdev->request_queue;
                 void *buf;
 
-                /* set the min alignment and padding */
-                blk_queue_update_dma_alignment(sdev->request_queue,
-                                               ATA_DMA_PAD_SZ - 1);
-                blk_queue_update_dma_pad(sdev->request_queue,
-                                         ATA_DMA_PAD_SZ - 1);
+                sdev->sector_size = ATA_SECT_SIZE;
+
+                /* set DMA padding */
+                blk_queue_update_dma_pad(q, ATA_DMA_PAD_SZ - 1);
 
                 /* configure draining */
                 buf = kmalloc(ATAPI_MAX_DRAIN, q->bounce_gfp | GFP_KERNEL);
@@ -1149,12 +1115,24 @@ static int ata_scsi_dev_config(struct scsi_device *sdev,
 
                 blk_queue_dma_drain(q, atapi_drain_needed, buf, ATAPI_MAX_DRAIN);
         } else {
-                /* ATA devices must be sector aligned */
-                blk_queue_update_dma_alignment(sdev->request_queue,
-                                               ATA_SECT_SIZE - 1);
+                sdev->sector_size = ata_id_logical_sector_size(dev->id);
                 sdev->manage_start_stop = 1;
         }
 
+        /*
+         * ata_pio_sectors() expects buffer for each sector to not cross
+         * page boundary.  Enforce it by requiring buffers to be sector
+         * aligned, which works iff sector_size is not larger than
+         * PAGE_SIZE.  ATAPI devices also need the alignment as
+         * IDENTIFY_PACKET is executed as ATA_PROT_PIO.
+         */
+        if (sdev->sector_size > PAGE_SIZE)
+                ata_dev_printk(dev, KERN_WARNING,
+                        "sector_size=%u > PAGE_SIZE, PIO may malfunction\n",
+                        sdev->sector_size);
+
+        blk_queue_update_dma_alignment(q, sdev->sector_size - 1);
+
         if (dev->flags & ATA_DFLAG_AN)
                 set_bit(SDEV_EVT_MEDIA_CHANGE, sdev->supported_events);
 
@@ -1166,6 +1144,9 @@ static int ata_scsi_dev_config(struct scsi_device *sdev,
                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
         }
 
+        blk_queue_flush_queueable(q, false);
+
+        dev->sdev = sdev;
         return 0;
 }
 
@@ -1696,7 +1677,7 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
                 goto nothing_to_do;
 
         qc->flags |= ATA_QCFLAG_IO;
-        qc->nbytes = n_block * ATA_SECT_SIZE;
+        qc->nbytes = n_block * scmd->device->sector_size;
 
         rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags,
                              qc->tag);
@@ -1764,7 +1745,6 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
  *      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
- *      @done: SCSI command completion function
  *      @xlat_func: Actor which translates @cmd to an ATA taskfile
  *
  *      Our ->queuecommand() function has decided that the SCSI
@@ -1788,7 +1768,6 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
  *      needs to be deferred.
  */
 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;
@@ -1797,7 +1776,7 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
 
         VPRINTK("ENTER\n");
 
-        qc = ata_scsi_qc_new(dev, cmd, done);
+        qc = ata_scsi_qc_new(dev, cmd);
         if (!qc)
                 goto err_mem;
 
@@ -1833,14 +1812,14 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
 
 early_finish:
         ata_qc_free(qc);
-        qc->scsidone(cmd);
+        cmd->scsi_done(cmd);
         DPRINTK("EXIT - early finish (good or error)\n");
         return 0;
 
 err_did:
         ata_qc_free(qc);
         cmd->result = (DID_ERROR << 16);
-        qc->scsidone(cmd);
+        cmd->scsi_done(cmd);
 err_mem:
         DPRINTK("EXIT - internal\n");
         return 0;
@@ -2001,6 +1980,7 @@ static unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf)
                 0x89,   /* page 0x89, ata info page */
                 0xb0,   /* page 0xb0, block limits page */
                 0xb1,   /* page 0xb1, block device characteristics page */
+                0xb2,   /* page 0xb2, thin provisioning page */
         };
 
         rbuf[3] = sizeof(pages);        /* number of supported VPD pages */
@@ -2077,6 +2057,17 @@ static unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf)
                       ATA_ID_SERNO_LEN);
         num += ATA_ID_SERNO_LEN;
 
+        if (ata_id_has_wwn(args->id)) {
+                /* SAT defined lu world wide name */
+                /* piv=0, assoc=lu, code_set=binary, designator=NAA */
+                rbuf[num + 0] = 1;
+                rbuf[num + 1] = 3;
+                rbuf[num + 3] = ATA_ID_WWN_LEN;
+                num += 4;
+                ata_id_string(args->id, (unsigned char *) rbuf + num,
+                              ATA_ID_WWN, ATA_ID_WWN_LEN);
+                num += ATA_ID_WWN_LEN;
+        }
         rbuf[3] = num - 4;    /* page len (assume less than 256 bytes) */
         return 0;
 }
@@ -2123,7 +2114,7 @@ static unsigned int ata_scsiop_inq_89(struct ata_scsi_args *args, u8 *rbuf)
 
 static unsigned int ata_scsiop_inq_b0(struct ata_scsi_args *args, u8 *rbuf)
 {
-        u32 min_io_sectors;
+        u16 min_io_sectors;
 
         rbuf[1] = 0xb0;
         rbuf[3] = 0x3c;         /* required VPD size with unmap support */
@@ -2135,10 +2126,7 @@ static unsigned int ata_scsiop_inq_b0(struct ata_scsi_args *args, u8 *rbuf)
          * logical than physical sector size we need to figure out what the
          * latter is.
          */
-        if (ata_id_has_large_logical_sectors(args->id))
-                min_io_sectors = ata_id_logical_per_physical_sectors(args->id);
-        else
-                min_io_sectors = 1;
+        min_io_sectors = 1 << ata_id_log2_per_physical_sector(args->id);
         put_unaligned_be16(min_io_sectors, &rbuf[6]);
 
         /*
@@ -2151,7 +2139,7 @@ static unsigned int ata_scsiop_inq_b0(struct ata_scsi_args *args, u8 *rbuf)
          * with the unmap bit set.
          */
         if (ata_id_has_trim(args->id)) {
-                put_unaligned_be32(65535 * 512 / 8, &rbuf[20]);
+                put_unaligned_be64(65535 * 512 / 8, &rbuf[36]);
                 put_unaligned_be32(1, &rbuf[28]);
         }
 
@@ -2172,6 +2160,16 @@ static unsigned int ata_scsiop_inq_b1(struct ata_scsi_args *args, u8 *rbuf)
         return 0;
 }
 
+static unsigned int ata_scsiop_inq_b2(struct ata_scsi_args *args, u8 *rbuf)
+{
+        /* SCSI Thin Provisioning VPD page: SBC-3 rev 22 or later */
+        rbuf[1] = 0xb2;
+        rbuf[3] = 0x4;
+        rbuf[5] = 1 << 6;       /* TPWS */
+
+        return 0;
+}
+
 /**
  *      ata_scsiop_noop - Command handler that simply returns success.
  *      @args: device IDENTIFY data / SCSI command of interest.
@@ -2397,21 +2395,13 @@ static unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf)
 {
         struct ata_device *dev = args->dev;
         u64 last_lba = dev->n_sectors - 1; /* LBA of the last block */
-        u8 log_per_phys = 0;
-        u16 lowest_aligned = 0;
-        u16 word_106 = dev->id[106];
-        u16 word_209 = dev->id[209];
-
-        if ((word_106 & 0xc000) == 0x4000) {
-                /* Number and offset of logical sectors per physical sector */
-                if (word_106 & (1 << 13))
-                        log_per_phys = word_106 & 0xf;
-                if ((word_209 & 0xc000) == 0x4000) {
-                        u16 first = dev->id[209] & 0x3fff;
-                        if (first > 0)
-                                lowest_aligned = (1 << log_per_phys) - first;
-                }
-        }
+        u32 sector_size; /* physical sector size in bytes */
+        u8 log2_per_phys;
+        u16 lowest_aligned;
+
+        sector_size = ata_id_logical_sector_size(dev->id);
+        log2_per_phys = ata_id_log2_per_physical_sector(dev->id);
+        lowest_aligned = ata_id_logical_sector_offset(dev->id, log2_per_phys);
 
         VPRINTK("ENTER\n");
 
@@ -2426,8 +2416,10 @@ static unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf)
                 rbuf[3] = last_lba;
 
                 /* sector size */
-                rbuf[6] = ATA_SECT_SIZE >> 8;
-                rbuf[7] = ATA_SECT_SIZE & 0xff;
+                rbuf[4] = sector_size >> (8 * 3);
+                rbuf[5] = sector_size >> (8 * 2);
+                rbuf[6] = sector_size >> (8 * 1);
+                rbuf[7] = sector_size;
         } else {
                 /* sector count, 64-bit */
                 rbuf[0] = last_lba >> (8 * 7);
@@ -2440,11 +2432,13 @@ static unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf)
                 rbuf[7] = last_lba;
 
                 /* sector size */
-                rbuf[10] = ATA_SECT_SIZE >> 8;
-                rbuf[11] = ATA_SECT_SIZE & 0xff;
+                rbuf[ 8] = sector_size >> (8 * 3);
+                rbuf[ 9] = sector_size >> (8 * 2);
+                rbuf[10] = sector_size >> (8 * 1);
+                rbuf[11] = sector_size;
 
                 rbuf[12] = 0;
-                rbuf[13] = log_per_phys;
+                rbuf[13] = log2_per_phys;
                 rbuf[14] = (lowest_aligned >> 8) & 0x3f;
                 rbuf[15] = lowest_aligned;
 
@@ -2577,8 +2571,11 @@ static void atapi_qc_complete(struct ata_queued_cmd *qc)
                  *
                  * If door lock fails, always clear sdev->locked to
                  * avoid this infinite loop.
+                 *
+                 * This may happen before SCSI scan is complete.  Make
+                 * sure qc->dev->sdev isn't NULL before dereferencing.
                  */
-                if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL)
+                if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL && qc->dev->sdev)
                         qc->dev->sdev->locked = 0;
 
                 qc->scsicmd->result = SAM_STAT_CHECK_CONDITION;
@@ -2888,9 +2885,8 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
         tf->device = dev->devno ?
                 tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
 
-        /* READ/WRITE LONG use a non-standard sect_size */
-        qc->sect_size = ATA_SECT_SIZE;
         switch (tf->command) {
+        /* READ/WRITE LONG use a non-standard sect_size */
         case ATA_CMD_READ_LONG:
         case ATA_CMD_READ_LONG_ONCE:
         case ATA_CMD_WRITE_LONG:
@@ -2898,6 +2894,45 @@ static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
                 if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
                         goto invalid_fld;
                 qc->sect_size = scsi_bufflen(scmd);
+                break;
+
+        /* commands using reported Logical Block size (e.g. 512 or 4K) */
+        case ATA_CMD_CFA_WRITE_NE:
+        case ATA_CMD_CFA_TRANS_SECT:
+        case ATA_CMD_CFA_WRITE_MULT_NE:
+        /* XXX: case ATA_CMD_CFA_WRITE_SECTORS_WITHOUT_ERASE: */
+        case ATA_CMD_READ:
+        case ATA_CMD_READ_EXT:
+        case ATA_CMD_READ_QUEUED:
+        /* XXX: case ATA_CMD_READ_QUEUED_EXT: */
+        case ATA_CMD_FPDMA_READ:
+        case ATA_CMD_READ_MULTI:
+        case ATA_CMD_READ_MULTI_EXT:
+        case ATA_CMD_PIO_READ:
+        case ATA_CMD_PIO_READ_EXT:
+        case ATA_CMD_READ_STREAM_DMA_EXT:
+        case ATA_CMD_READ_STREAM_EXT:
+        case ATA_CMD_VERIFY:
+        case ATA_CMD_VERIFY_EXT:
+        case ATA_CMD_WRITE:
+        case ATA_CMD_WRITE_EXT:
+        case ATA_CMD_WRITE_FUA_EXT:
+        case ATA_CMD_WRITE_QUEUED:
+        case ATA_CMD_WRITE_QUEUED_FUA_EXT:
+        case ATA_CMD_FPDMA_WRITE:
+        case ATA_CMD_WRITE_MULTI:
+        case ATA_CMD_WRITE_MULTI_EXT:
+        case ATA_CMD_WRITE_MULTI_FUA_EXT:
+        case ATA_CMD_PIO_WRITE:
+        case ATA_CMD_PIO_WRITE_EXT:
+        case ATA_CMD_WRITE_STREAM_DMA_EXT:
+        case ATA_CMD_WRITE_STREAM_EXT:
+                qc->sect_size = scmd->device->sector_size;
+                break;
+
+        /* Everything else uses 512 byte "sectors" */
+        default:
+                qc->sect_size = ATA_SECT_SIZE;
         }
 
         /*
@@ -3100,7 +3135,6 @@ static inline void ata_scsi_dump_cdb(struct ata_port *ap,
 }
 
 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];
@@ -3134,9 +3168,9 @@ static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
         }
 
         if (xlat_func)
-                rc = ata_scsi_translate(dev, scmd, done, xlat_func);
+                rc = ata_scsi_translate(dev, scmd, xlat_func);
         else
-                ata_scsi_simulate(dev, scmd, done);
+                ata_scsi_simulate(dev, scmd);
 
         return rc;
 
@@ -3144,14 +3178,14 @@ static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
         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);
+        scmd->scsi_done(scmd);
         return 0;
 }
 
 /**
  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
+ *      @shost: SCSI host of command to be sent
  *      @cmd: SCSI command to be sent
- *      @done: Completion function, called when command is complete
  *
  *      In some cases, this function translates SCSI commands into
  *      ATA taskfiles, and queues the taskfiles to be sent to
@@ -3161,37 +3195,36 @@ static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
  *      ATA and ATAPI devices appearing as SCSI devices.
  *
  *      LOCKING:
- *      Releases scsi-layer-held lock, and obtains host lock.
+ *      ATA host lock
  *
  *      RETURNS:
  *      Return value from __ata_scsi_queuecmd() if @cmd can be queued,
  *      0 otherwise.
  */
-int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
+int ata_scsi_queuecmd(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
 {
         struct ata_port *ap;
         struct ata_device *dev;
         struct scsi_device *scsidev = cmd->device;
-        struct Scsi_Host *shost = scsidev->host;
         int rc = 0;
+        unsigned long irq_flags;
 
         ap = ata_shost_to_port(shost);
 
-        spin_unlock(shost->host_lock);
-        spin_lock(ap->lock);
+        spin_lock_irqsave(ap->lock, irq_flags);
 
         ata_scsi_dump_cdb(ap, cmd);
 
         dev = ata_scsi_find_dev(ap, scsidev);
         if (likely(dev))
-                rc = __ata_scsi_queuecmd(cmd, done, dev);
+                rc = __ata_scsi_queuecmd(cmd, dev);
         else {
                 cmd->result = (DID_BAD_TARGET << 16);
-                done(cmd);
+                cmd->scsi_done(cmd);
         }
 
-        spin_unlock(ap->lock);
-        spin_lock(shost->host_lock);
+        spin_unlock_irqrestore(ap->lock, irq_flags);
+
         return rc;
 }
 
@@ -3199,7 +3232,6 @@ int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
  *      ata_scsi_simulate - simulate SCSI command on ATA device
  *      @dev: the target device
  *      @cmd: SCSI command being sent to device.
- *      @done: SCSI command completion function.
  *
  *      Interprets and directly executes a select list of SCSI commands
  *      that can be handled internally.
@@ -3208,8 +3240,7 @@ int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
  *      spin_lock_irqsave(host lock)
  */
 
-void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
-                      void (*done)(struct scsi_cmnd *))
+void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
 {
         struct ata_scsi_args args;
         const u8 *scsicmd = cmd->cmnd;
@@ -3218,17 +3249,17 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
         args.dev = dev;
         args.id = dev->id;
         args.cmd = cmd;
-        args.done = done;
+        args.done = cmd->scsi_done;
 
         switch(scsicmd[0]) {
         /* TODO: worth improving? */
         case FORMAT_UNIT:
-                ata_scsi_invalid_field(cmd, done);
+                ata_scsi_invalid_field(cmd);
                 break;
 
         case INQUIRY:
                 if (scsicmd[1] & 2)                /* is CmdDt set?  */
-                        ata_scsi_invalid_field(cmd, done);
+                        ata_scsi_invalid_field(cmd);
                 else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
                         ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
                 else switch (scsicmd[2]) {
@@ -3250,8 +3281,11 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
                 case 0xb1:
                         ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b1);
                         break;
+                case 0xb2:
+                        ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b2);
+                        break;
                 default:
-                        ata_scsi_invalid_field(cmd, done);
+                        ata_scsi_invalid_field(cmd);
                         break;
                 }
                 break;
@@ -3263,7 +3297,7 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
 
         case MODE_SELECT:       /* unconditionally return */
         case MODE_SELECT_10:    /* bad-field-in-cdb */
-                ata_scsi_invalid_field(cmd, done);
+                ata_scsi_invalid_field(cmd);
                 break;
 
         case READ_CAPACITY:
@@ -3274,7 +3308,7 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
                 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
                 else
-                        ata_scsi_invalid_field(cmd, done);
+                        ata_scsi_invalid_field(cmd);
                 break;
 
         case REPORT_LUNS:
@@ -3284,7 +3318,7 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
         case REQUEST_SENSE:
                 ata_scsi_set_sense(cmd, 0, 0, 0);
                 cmd->result = (DRIVER_SENSE << 24);
-                done(cmd);
+                cmd->scsi_done(cmd);
                 break;
 
         /* if we reach this, then writeback caching is disabled,
@@ -3306,14 +3340,14 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
                 if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
                         ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
                 else
-                        ata_scsi_invalid_field(cmd, done);
+                        ata_scsi_invalid_field(cmd);
                 break;
 
         /* all other commands */
         default:
                 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
                 /* "Invalid command operation code" */
-                done(cmd);
+                cmd->scsi_done(cmd);
                 break;
         }
 }
@@ -3334,7 +3368,7 @@ int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
                 *(struct ata_port **)&shost->hostdata[0] = ap;
                 ap->scsi_host = shost;
 
-                shost->transportt = &ata_scsi_transport_template;
+                shost->transportt = ata_scsi_transport_template;
                 shost->unique_id = ap->print_id;
                 shost->max_id = 16;
                 shost->max_lun = 1;
@@ -3393,6 +3427,8 @@ void ata_scsi_scan_host(struct ata_port *ap, int sync)
                         if (!IS_ERR(sdev)) {
                                 dev->sdev = sdev;
                                 scsi_device_put(sdev);
+                        } else {
+                                dev->sdev = NULL;
                         }
                 }
         }
@@ -3616,8 +3652,8 @@ void ata_scsi_hotplug(struct work_struct *work)
  *      RETURNS:
  *      Zero.
  */
-static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
-                              unsigned int id, unsigned int lun)
+int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
+                       unsigned int id, unsigned int lun)
 {
         struct ata_port *ap = ata_shost_to_port(shost);
         unsigned long flags;
@@ -3735,7 +3771,7 @@ struct ata_port *ata_sas_port_alloc(struct ata_host *host,
                 return NULL;
 
         ap->port_no = 0;
-        ap->lock = shost->host_lock;
+        ap->lock = &host->lock;
         ap->pio_mask = port_info->pio_mask;
         ap->mwdma_mask = port_info->mwdma_mask;
         ap->udma_mask = port_info->udma_mask;
@@ -3761,6 +3797,12 @@ EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
  */
 int ata_sas_port_start(struct ata_port *ap)
 {
+        /*
+         * the port is marked as frozen at allocation time, but if we don't
+         * have new eh, we won't thaw it
+         */
+        if (!ap->ops->error_handler)
+                ap->pflags &= ~ATA_PFLAG_FROZEN;
         return 0;
 }
 EXPORT_SYMBOL_GPL(ata_sas_port_start);
@@ -3797,7 +3839,7 @@ int ata_sas_port_init(struct ata_port *ap)
 
         if (!rc) {
                 ap->print_id = ata_print_id++;
-                rc = ata_bus_probe(ap);
+                rc = ata_port_probe(ap);
         }
 
         return rc;
@@ -3838,7 +3880,6 @@ EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
 /**
  *      ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
  *      @cmd: SCSI command to be sent
- *      @done: Completion function, called when command is complete
  *      @ap:    ATA port to which the command is being sent
  *
  *      RETURNS:
@@ -3846,18 +3887,17 @@ EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
  *      0 otherwise.
  */
 
-int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
-                     struct ata_port *ap)
+int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap)
 {
         int rc = 0;
 
         ata_scsi_dump_cdb(ap, cmd);
 
         if (likely(ata_dev_enabled(ap->link.device)))
-                rc = __ata_scsi_queuecmd(cmd, done, ap->link.device);
+                rc = __ata_scsi_queuecmd(cmd, ap->link.device);
         else {
                 cmd->result = (DID_BAD_TARGET << 16);
-                done(cmd);
+                cmd->scsi_done(cmd);
         }
         return rc;
 }
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index e30c537cce32..b1b926c55a72 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -222,7 +222,7 @@ int ata_sff_busy_sleep(struct ata_port *ap,
         timeout = ata_deadline(timer_start, tmout_pat);
         while (status != 0xff && (status & ATA_BUSY) &&
                time_before(jiffies, timeout)) {
-                msleep(50);
+                ata_msleep(ap, 50);
                 status = ata_sff_busy_wait(ap, ATA_BUSY, 3);
         }
 
@@ -234,7 +234,7 @@ int ata_sff_busy_sleep(struct ata_port *ap,
         timeout = ata_deadline(timer_start, tmout);
         while (status != 0xff && (status & ATA_BUSY) &&
                time_before(jiffies, timeout)) {
-                msleep(50);
+                ata_msleep(ap, 50);
                 status = ap->ops->sff_check_status(ap);
         }
 
@@ -360,7 +360,7 @@ static void ata_dev_select(struct ata_port *ap, unsigned int device,
 
         if (wait) {
                 if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI)
-                        msleep(150);
+                        ata_msleep(ap, 150);
                 ata_wait_idle(ap);
         }
 }
@@ -1302,6 +1302,18 @@ fsm_start:
 }
 EXPORT_SYMBOL_GPL(ata_sff_hsm_move);
 
+void ata_sff_queue_work(struct work_struct *work)
+{
+        queue_work(ata_sff_wq, work);
+}
+EXPORT_SYMBOL_GPL(ata_sff_queue_work);
+
+void ata_sff_queue_delayed_work(struct delayed_work *dwork, unsigned long delay)
+{
+        queue_delayed_work(ata_sff_wq, dwork, delay);
+}
+EXPORT_SYMBOL_GPL(ata_sff_queue_delayed_work);
+
 void ata_sff_queue_pio_task(struct ata_link *link, unsigned long delay)
 {
         struct ata_port *ap = link->ap;
@@ -1311,8 +1323,7 @@ void ata_sff_queue_pio_task(struct ata_link *link, unsigned long delay)
         ap->sff_pio_task_link = link;
 
         /* may fail if ata_sff_flush_pio_task() in progress */
-        queue_delayed_work(ata_sff_wq, &ap->sff_pio_task,
-                           msecs_to_jiffies(delay));
+        ata_sff_queue_delayed_work(&ap->sff_pio_task, msecs_to_jiffies(delay));
 }
 EXPORT_SYMBOL_GPL(ata_sff_queue_pio_task);
 
@@ -1320,7 +1331,7 @@ void ata_sff_flush_pio_task(struct ata_port *ap)
 {
         DPRINTK("ENTER\n");
 
-        cancel_rearming_delayed_work(&ap->sff_pio_task);
+        cancel_delayed_work_sync(&ap->sff_pio_task);
         ap->hsm_task_state = HSM_ST_IDLE;
 
         if (ata_msg_ctl(ap))
@@ -1336,7 +1347,7 @@ static void ata_sff_pio_task(struct work_struct *work)
         u8 status;
         int poll_next;
 
-        BUG_ON(ap->sff_pio_task_link == NULL); 
+        BUG_ON(ap->sff_pio_task_link == NULL);
         /* qc can be NULL if timeout occurred */
         qc = ata_qc_from_tag(ap, link->active_tag);
         if (!qc) {
@@ -1356,7 +1367,7 @@ fsm_start:
          */
         status = ata_sff_busy_wait(ap, ATA_BUSY, 5);
         if (status & ATA_BUSY) {
-                msleep(2);
+                ata_msleep(ap, 2);
                 status = ata_sff_busy_wait(ap, ATA_BUSY, 10);
                 if (status & ATA_BUSY) {
                         ata_sff_queue_pio_task(link, ATA_SHORT_PAUSE);
@@ -1532,11 +1543,10 @@ static unsigned int __ata_sff_port_intr(struct ata_port *ap,
                 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
                         return ata_sff_idle_irq(ap);
                 break;
-        case HSM_ST:
-        case HSM_ST_LAST:
-                break;
-        default:
+        case HSM_ST_IDLE:
                 return ata_sff_idle_irq(ap);
+        default:
+                break;
         }
 
         /* check main status, clearing INTRQ if needed */
@@ -1937,7 +1947,7 @@ int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,
         unsigned int dev1 = devmask & (1 << 1);
         int rc, ret = 0;
 
-        msleep(ATA_WAIT_AFTER_RESET);
+        ata_msleep(ap, ATA_WAIT_AFTER_RESET);
 
         /* always check readiness of the master device */
         rc = ata_sff_wait_ready(link, deadline);
@@ -1966,7 +1976,7 @@ int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,
                         lbal = ioread8(ioaddr->lbal_addr);
                         if ((nsect == 1) && (lbal == 1))
                                 break;
-                        msleep(50);     /* give drive a breather */
+                        ata_msleep(ap, 50);     /* give drive a breather */
                 }
 
                 rc = ata_sff_wait_ready(link, deadline);
@@ -2437,13 +2447,18 @@ int ata_pci_sff_activate_host(struct ata_host *host,
                 return -ENOMEM;
 
         if (!legacy_mode && pdev->irq) {
+                int i;
+
                 rc = devm_request_irq(dev, pdev->irq, irq_handler,
                                       IRQF_SHARED, drv_name, host);
                 if (rc)
                         goto out;
 
-                ata_port_desc(host->ports[0], "irq %d", pdev->irq);
-                ata_port_desc(host->ports[1], "irq %d", pdev->irq);
+                for (i = 0; i < 2; i++) {
+                        if (ata_port_is_dummy(host->ports[i]))
+                                continue;
+                        ata_port_desc(host->ports[i], "irq %d", pdev->irq);
+                }
         } else if (legacy_mode) {
                 if (!ata_port_is_dummy(host->ports[0])) {
                         rc = devm_request_irq(dev, ATA_PRIMARY_IRQ(pdev),
@@ -2829,7 +2844,7 @@ unsigned int ata_bmdma_port_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
                 bmdma_stopped = true;
 
                 if (unlikely(host_stat & ATA_DMA_ERR)) {
-                        /* error when transfering data to/from memory */
+                        /* error when transferring data to/from memory */
                         qc->err_mask |= AC_ERR_HOST_BUS;
                         ap->hsm_task_state = HSM_ST_ERR;
                 }
@@ -3022,7 +3037,7 @@ void ata_bmdma_start(struct ata_queued_cmd *qc)
          * Or maybe I'm just being paranoid.
          *
          * FIXME: The posting of this write means I/O starts are
-         * unneccessarily delayed for MMIO
+         * unnecessarily delayed for MMIO
          */
 }
 EXPORT_SYMBOL_GPL(ata_bmdma_start);
@@ -3335,14 +3350,14 @@ void ata_sff_port_init(struct ata_port *ap)
 
 int __init ata_sff_init(void)
 {
-        ata_sff_wq = alloc_workqueue("ata_sff", WQ_RESCUER, WQ_MAX_ACTIVE);
+        ata_sff_wq = alloc_workqueue("ata_sff", WQ_MEM_RECLAIM, WQ_MAX_ACTIVE);
         if (!ata_sff_wq)
                 return -ENOMEM;
 
         return 0;
 }
 
-void __exit ata_sff_exit(void)
+void ata_sff_exit(void)
 {
         destroy_workqueue(ata_sff_wq);
 }
diff --git a/drivers/ata/libata-transport.c b/drivers/ata/libata-transport.c
new file mode 100644
index 000000000000..ce9dc6207f37
--- /dev/null
+++ b/drivers/ata/libata-transport.c
@@ -0,0 +1,774 @@
+/*
+ *  Copyright 2008 ioogle, Inc.  All rights reserved.
+ *      Released under GPL v2.
+ *
+ * Libata transport class.
+ *
+ * The ATA transport class contains common code to deal with ATA HBAs,
+ * an approximated representation of ATA topologies in the driver model,
+ * and various sysfs attributes to expose these topologies and management
+ * interfaces to user-space.
+ *
+ * There are 3 objects defined in in this class:
+ * - ata_port
+ * - ata_link
+ * - ata_device
+ * Each port has a link object. Each link can have up to two devices for PATA
+ * and generally one for SATA.
+ * If there is SATA port multiplier [PMP], 15 additional ata_link object are
+ * created.
+ *
+ * These objects are created when the ata host is initialized and when a PMP is
+ * found. They are removed only when the HBA is removed, cleaned before the
+ * error handler runs.
+ */
+
+
+#include <linux/kernel.h>
+#include <linux/blkdev.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <scsi/scsi_transport.h>
+#include <linux/libata.h>
+#include <linux/hdreg.h>
+#include <linux/uaccess.h>
+
+#include "libata.h"
+#include "libata-transport.h"
+
+#define ATA_PORT_ATTRS          2
+#define ATA_LINK_ATTRS          3
+#define ATA_DEV_ATTRS           9
+
+struct scsi_transport_template;
+struct scsi_transport_template *ata_scsi_transport_template;
+
+struct ata_internal {
+        struct scsi_transport_template t;
+
+        struct device_attribute private_port_attrs[ATA_PORT_ATTRS];
+        struct device_attribute private_link_attrs[ATA_LINK_ATTRS];
+        struct device_attribute private_dev_attrs[ATA_DEV_ATTRS];
+
+        struct transport_container link_attr_cont;
+        struct transport_container dev_attr_cont;
+
+        /*
+         * The array of null terminated pointers to attributes
+         * needed by scsi_sysfs.c
+         */
+        struct device_attribute *link_attrs[ATA_LINK_ATTRS + 1];
+        struct device_attribute *port_attrs[ATA_PORT_ATTRS + 1];
+        struct device_attribute *dev_attrs[ATA_DEV_ATTRS + 1];
+};
+#define to_ata_internal(tmpl)   container_of(tmpl, struct ata_internal, t)
+
+
+#define tdev_to_device(d)                                       \
+        container_of((d), struct ata_device, tdev)
+#define transport_class_to_dev(dev)                             \
+        tdev_to_device((dev)->parent)
+
+#define tdev_to_link(d)                                         \
+        container_of((d), struct ata_link, tdev)
+#define transport_class_to_link(dev)                            \
+        tdev_to_link((dev)->parent)
+
+#define tdev_to_port(d)                                         \
+        container_of((d), struct ata_port, tdev)
+#define transport_class_to_port(dev)                            \
+        tdev_to_port((dev)->parent)
+
+
+/* Device objects are always created whit link objects */
+static int ata_tdev_add(struct ata_device *dev);
+static void ata_tdev_delete(struct ata_device *dev);
+
+
+/*
+ * Hack to allow attributes of the same name in different objects.
+ */
+#define ATA_DEVICE_ATTR(_prefix,_name,_mode,_show,_store) \
+        struct device_attribute device_attr_##_prefix##_##_name = \
+        __ATTR(_name,_mode,_show,_store)
+
+#define ata_bitfield_name_match(title, table)                   \
+static ssize_t                                                  \
+get_ata_##title##_names(u32 table_key, char *buf)               \
+{                                                               \
+        char *prefix = "";                                      \
+        ssize_t len = 0;                                        \
+        int i;                                                  \
+                                                                \
+        for (i = 0; i < ARRAY_SIZE(table); i++) {               \
+                if (table[i].value & table_key) {               \
+                        len += sprintf(buf + len, "%s%s",       \
+                                prefix, table[i].name);         \
+                        prefix = ", ";                          \
+                }                                               \
+        }                                                       \
+        len += sprintf(buf + len, "\n");                        \
+        return len;                                             \
+}
+
+#define ata_bitfield_name_search(title, table)                  \
+static ssize_t                                                  \
+get_ata_##title##_names(u32 table_key, char *buf)               \
+{                                                               \
+        ssize_t len = 0;                                        \
+        int i;                                                  \
+                                                                \
+        for (i = 0; i < ARRAY_SIZE(table); i++) {               \
+                if (table[i].value == table_key) {              \
+                        len += sprintf(buf + len, "%s",         \
+                                table[i].name);                 \
+                        break;                                  \
+                }                                               \
+        }                                                       \
+        len += sprintf(buf + len, "\n");                        \
+        return len;                                             \
+}
+
+static struct {
+        u32             value;
+        char            *name;
+} ata_class_names[] = {
+        { ATA_DEV_UNKNOWN,              "unknown" },
+        { ATA_DEV_ATA,                  "ata" },
+        { ATA_DEV_ATA_UNSUP,            "ata" },
+        { ATA_DEV_ATAPI,                "atapi" },
+        { ATA_DEV_ATAPI_UNSUP,          "atapi" },
+        { ATA_DEV_PMP,                  "pmp" },
+        { ATA_DEV_PMP_UNSUP,            "pmp" },
+        { ATA_DEV_SEMB,                 "semb" },
+        { ATA_DEV_SEMB_UNSUP,           "semb" },
+        { ATA_DEV_NONE,                 "none" }
+};
+ata_bitfield_name_search(class, ata_class_names)
+
+
+static struct {
+        u32             value;
+        char            *name;
+} ata_err_names[] = {
+        { AC_ERR_DEV,                   "DeviceError" },
+        { AC_ERR_HSM,                   "HostStateMachineError" },
+        { AC_ERR_TIMEOUT,               "Timeout" },
+        { AC_ERR_MEDIA,                 "MediaError" },
+        { AC_ERR_ATA_BUS,               "BusError" },
+        { AC_ERR_HOST_BUS,              "HostBusError" },
+        { AC_ERR_SYSTEM,                "SystemError" },
+        { AC_ERR_INVALID,               "InvalidArg" },
+        { AC_ERR_OTHER,                 "Unknown" },
+        { AC_ERR_NODEV_HINT,            "NoDeviceHint" },
+        { AC_ERR_NCQ,                   "NCQError" }
+};
+ata_bitfield_name_match(err, ata_err_names)
+
+static struct {
+        u32             value;
+        char            *name;
+} ata_xfer_names[] = {
+        { XFER_UDMA_7,                  "XFER_UDMA_7" },
+        { XFER_UDMA_6,                  "XFER_UDMA_6" },
+        { XFER_UDMA_5,                  "XFER_UDMA_5" },
+        { XFER_UDMA_4,                  "XFER_UDMA_4" },
+        { XFER_UDMA_3,                  "XFER_UDMA_3" },
+        { XFER_UDMA_2,                  "XFER_UDMA_2" },
+        { XFER_UDMA_1,                  "XFER_UDMA_1" },
+        { XFER_UDMA_0,                  "XFER_UDMA_0" },
+        { XFER_MW_DMA_4,                "XFER_MW_DMA_4" },
+        { XFER_MW_DMA_3,                "XFER_MW_DMA_3" },
+        { XFER_MW_DMA_2,                "XFER_MW_DMA_2" },
+        { XFER_MW_DMA_1,                "XFER_MW_DMA_1" },
+        { XFER_MW_DMA_0,                "XFER_MW_DMA_0" },
+        { XFER_SW_DMA_2,                "XFER_SW_DMA_2" },
+        { XFER_SW_DMA_1,                "XFER_SW_DMA_1" },
+        { XFER_SW_DMA_0,                "XFER_SW_DMA_0" },
+        { XFER_PIO_6,                   "XFER_PIO_6" },
+        { XFER_PIO_5,                   "XFER_PIO_5" },
+        { XFER_PIO_4,                   "XFER_PIO_4" },
+        { XFER_PIO_3,                   "XFER_PIO_3" },
+        { XFER_PIO_2,                   "XFER_PIO_2" },
+        { XFER_PIO_1,                   "XFER_PIO_1" },
+        { XFER_PIO_0,                   "XFER_PIO_0" },
+        { XFER_PIO_SLOW,                "XFER_PIO_SLOW" }
+};
+ata_bitfield_name_match(xfer,ata_xfer_names)
+
+/*
+ * ATA Port attributes
+ */
+#define ata_port_show_simple(field, name, format_string, cast)          \
+static ssize_t                                                          \
+show_ata_port_##name(struct device *dev,                                \
+                     struct device_attribute *attr, char *buf)          \
+{                                                                       \
+        struct ata_port *ap = transport_class_to_port(dev);             \
+                                                                        \
+        return snprintf(buf, 20, format_string, cast ap->field);        \
+}
+
+#define ata_port_simple_attr(field, name, format_string, type)          \
+        ata_port_show_simple(field, name, format_string, (type))        \
+static DEVICE_ATTR(name, S_IRUGO, show_ata_port_##name, NULL)
+
+ata_port_simple_attr(nr_pmp_links, nr_pmp_links, "%d\n", int);
+ata_port_simple_attr(stats.idle_irq, idle_irq, "%ld\n", unsigned long);
+
+static DECLARE_TRANSPORT_CLASS(ata_port_class,
+                               "ata_port", NULL, NULL, NULL);
+
+static void ata_tport_release(struct device *dev)
+{
+        put_device(dev->parent);
+}
+
+/**
+ * ata_is_port --  check if a struct device represents a ATA port
+ * @dev:        device to check
+ *
+ * Returns:
+ *      %1 if the device represents a ATA Port, %0 else
+ */
+int ata_is_port(const struct device *dev)
+{
+        return dev->release == ata_tport_release;
+}
+
+static int ata_tport_match(struct attribute_container *cont,
+                           struct device *dev)
+{
+        if (!ata_is_port(dev))
+                return 0;
+        return &ata_scsi_transport_template->host_attrs.ac == cont;
+}
+
+/**
+ * ata_tport_delete  --  remove ATA PORT
+ * @port:       ATA PORT to remove
+ *
+ * Removes the specified ATA PORT.  Remove the associated link as well.
+ */
+void ata_tport_delete(struct ata_port *ap)
+{
+        struct device *dev = &ap->tdev;
+
+        ata_tlink_delete(&ap->link);
+
+        transport_remove_device(dev);
+        device_del(dev);
+        transport_destroy_device(dev);
+        put_device(dev);
+}
+
+/** ata_tport_add - initialize a transport ATA port structure
+ *
+ * @parent:     parent device
+ * @ap:         existing ata_port structure
+ *
+ * Initialize a ATA port structure for sysfs.  It will be added to the device
+ * tree below the device specified by @parent which could be a PCI device.
+ *
+ * Returns %0 on success
+ */
+int ata_tport_add(struct device *parent,
+                  struct ata_port *ap)
+{
+        int error;
+        struct device *dev = &ap->tdev;
+
+        device_initialize(dev);
+
+        dev->parent = get_device(parent);
+        dev->release = ata_tport_release;
+        dev_set_name(dev, "ata%d", ap->print_id);
+        transport_setup_device(dev);
+        error = device_add(dev);
+        if (error) {
+                goto tport_err;
+        }
+
+        transport_add_device(dev);
+        transport_configure_device(dev);
+
+        error = ata_tlink_add(&ap->link);
+        if (error) {
+                goto tport_link_err;
+        }
+        return 0;
+
+ tport_link_err:
+        transport_remove_device(dev);
+        device_del(dev);
+
+ tport_err:
+        transport_destroy_device(dev);
+        put_device(dev);
+        return error;
+}
+
+
+/*
+ * ATA link attributes
+ */
+
+
+#define ata_link_show_linkspeed(field)                                  \
+static ssize_t                                                          \
+show_ata_link_##field(struct device *dev,                               \
+                      struct device_attribute *attr, char *buf)         \
+{                                                                       \
+        struct ata_link *link = transport_class_to_link(dev);           \
+                                                                        \
+        return sprintf(buf,"%s\n", sata_spd_string(fls(link->field)));  \
+}
+
+#define ata_link_linkspeed_attr(field)                                  \
+        ata_link_show_linkspeed(field)                                  \
+static DEVICE_ATTR(field, S_IRUGO, show_ata_link_##field, NULL)
+
+ata_link_linkspeed_attr(hw_sata_spd_limit);
+ata_link_linkspeed_attr(sata_spd_limit);
+ata_link_linkspeed_attr(sata_spd);
+
+
+static DECLARE_TRANSPORT_CLASS(ata_link_class,
+                "ata_link", NULL, NULL, NULL);
+
+static void ata_tlink_release(struct device *dev)
+{
+        put_device(dev->parent);
+}
+
+/**
+ * ata_is_link --  check if a struct device represents a ATA link
+ * @dev:        device to check
+ *
+ * Returns:
+ *      %1 if the device represents a ATA link, %0 else
+ */
+int ata_is_link(const struct device *dev)
+{
+        return dev->release == ata_tlink_release;
+}
+
+static int ata_tlink_match(struct attribute_container *cont,
+                           struct device *dev)
+{
+        struct ata_internal* i = to_ata_internal(ata_scsi_transport_template);
+        if (!ata_is_link(dev))
+                return 0;
+        return &i->link_attr_cont.ac == cont;
+}
+
+/**
+ * ata_tlink_delete  --  remove ATA LINK
+ * @port:       ATA LINK to remove
+ *
+ * Removes the specified ATA LINK.  remove associated ATA device(s) as well.
+ */
+void ata_tlink_delete(struct ata_link *link)
+{
+        struct device *dev = &link->tdev;
+        struct ata_device *ata_dev;
+
+        ata_for_each_dev(ata_dev, link, ALL) {
+                ata_tdev_delete(ata_dev);
+        }
+
+        transport_remove_device(dev);
+        device_del(dev);
+        transport_destroy_device(dev);
+        put_device(dev);
+}
+
+/**
+ * ata_tlink_add  --  initialize a transport ATA link structure
+ * @link:       allocated ata_link structure.
+ *
+ * Initialize an ATA LINK structure for sysfs.  It will be added in the
+ * device tree below the ATA PORT it belongs to.
+ *
+ * Returns %0 on success
+ */
+int ata_tlink_add(struct ata_link *link)
+{
+        struct device *dev = &link->tdev;
+        struct ata_port *ap = link->ap;
+        struct ata_device *ata_dev;
+        int error;
+
+        device_initialize(dev);
+        dev->parent = get_device(&ap->tdev);
+        dev->release = ata_tlink_release;
+        if (ata_is_host_link(link))
+                dev_set_name(dev, "link%d", ap->print_id);
+        else
+                dev_set_name(dev, "link%d.%d", ap->print_id, link->pmp);
+
+        transport_setup_device(dev);
+
+        error = device_add(dev);
+        if (error) {
+                goto tlink_err;
+        }
+
+        transport_add_device(dev);
+        transport_configure_device(dev);
+
+        ata_for_each_dev(ata_dev, link, ALL) {
+                error = ata_tdev_add(ata_dev);
+                if (error) {
+                        goto tlink_dev_err;
+                }
+        }
+        return 0;
+  tlink_dev_err:
+        while (--ata_dev >= link->device) {
+                ata_tdev_delete(ata_dev);
+        }
+        transport_remove_device(dev);
+        device_del(dev);
+  tlink_err:
+        transport_destroy_device(dev);
+        put_device(dev);
+        return error;
+}
+
+/*
+ * ATA device attributes
+ */
+
+#define ata_dev_show_class(title, field)                                \
+static ssize_t                                                          \
+show_ata_dev_##field(struct device *dev,                                \
+                     struct device_attribute *attr, char *buf)          \
+{                                                                       \
+        struct ata_device *ata_dev = transport_class_to_dev(dev);       \
+                                                                        \
+        return get_ata_##title##_names(ata_dev->field, buf);            \
+}
+
+#define ata_dev_attr(title, field)                                      \
+        ata_dev_show_class(title, field)                                \
+static DEVICE_ATTR(field, S_IRUGO, show_ata_dev_##field, NULL)
+
+ata_dev_attr(class, class);
+ata_dev_attr(xfer, pio_mode);
+ata_dev_attr(xfer, dma_mode);
+ata_dev_attr(xfer, xfer_mode);
+
+
+#define ata_dev_show_simple(field, format_string, cast)         \
+static ssize_t                                                          \
+show_ata_dev_##field(struct device *dev,                                \
+                     struct device_attribute *attr, char *buf)          \
+{                                                                       \
+        struct ata_device *ata_dev = transport_class_to_dev(dev);       \
+                                                                        \
+        return snprintf(buf, 20, format_string, cast ata_dev->field);   \
+}
+
+#define ata_dev_simple_attr(field, format_string, type) \
+        ata_dev_show_simple(field, format_string, (type))       \
+static DEVICE_ATTR(field, S_IRUGO,                      \
+                   show_ata_dev_##field, NULL)
+
+ata_dev_simple_attr(spdn_cnt, "%d\n", int);
+
+struct ata_show_ering_arg {
+        char* buf;
+        int written;
+};
+
+static int ata_show_ering(struct ata_ering_entry *ent, void *void_arg)
+{
+        struct ata_show_ering_arg* arg = void_arg;
+        struct timespec time;
+
+        jiffies_to_timespec(ent->timestamp,&time);
+        arg->written += sprintf(arg->buf + arg->written,
+                               "[%5lu.%06lu]",
+                               time.tv_sec, time.tv_nsec);
+        arg->written += get_ata_err_names(ent->err_mask,
+                                          arg->buf + arg->written);
+        return 0;
+}
+
+static ssize_t
+show_ata_dev_ering(struct device *dev,
+                   struct device_attribute *attr, char *buf)
+{
+        struct ata_device *ata_dev = transport_class_to_dev(dev);
+        struct ata_show_ering_arg arg = { buf, 0 };
+
+        ata_ering_map(&ata_dev->ering, ata_show_ering, &arg);
+        return arg.written;
+}
+
+
+static DEVICE_ATTR(ering, S_IRUGO, show_ata_dev_ering, NULL);
+
+static ssize_t
+show_ata_dev_id(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct ata_device *ata_dev = transport_class_to_dev(dev);
+        int written = 0, i = 0;
+
+        if (ata_dev->class == ATA_DEV_PMP)
+                return 0;
+        for(i=0;i<ATA_ID_WORDS;i++)  {
+                written += snprintf(buf+written, 20, "%04x%c",
+                                    ata_dev->id[i],
+                                    ((i+1) & 7) ? ' ' : '\n');
+        }
+        return written;
+}
+
+static DEVICE_ATTR(id, S_IRUGO, show_ata_dev_id, NULL);
+
+static ssize_t
+show_ata_dev_gscr(struct device *dev,
+                  struct device_attribute *attr, char *buf)
+{
+        struct ata_device *ata_dev = transport_class_to_dev(dev);
+        int written = 0, i = 0;
+
+        if (ata_dev->class != ATA_DEV_PMP)
+                return 0;
+        for(i=0;i<SATA_PMP_GSCR_DWORDS;i++)  {
+                written += snprintf(buf+written, 20, "%08x%c",
+                                    ata_dev->gscr[i],
+                                    ((i+1) & 3) ? ' ' : '\n');
+        }
+        if (SATA_PMP_GSCR_DWORDS & 3)
+                buf[written-1] = '\n';
+        return written;
+}
+
+static DEVICE_ATTR(gscr, S_IRUGO, show_ata_dev_gscr, NULL);
+
+static DECLARE_TRANSPORT_CLASS(ata_dev_class,
+                               "ata_device", NULL, NULL, NULL);
+
+static void ata_tdev_release(struct device *dev)
+{
+        put_device(dev->parent);
+}
+
+/**
+ * ata_is_ata_dev  --  check if a struct device represents a ATA device
+ * @dev:        device to check
+ *
+ * Returns:
+ *      %1 if the device represents a ATA device, %0 else
+ */
+int ata_is_ata_dev(const struct device *dev)
+{
+        return dev->release == ata_tdev_release;
+}
+
+static int ata_tdev_match(struct attribute_container *cont,
+                          struct device *dev)
+{
+        struct ata_internal* i = to_ata_internal(ata_scsi_transport_template);
+        if (!ata_is_ata_dev(dev))
+                return 0;
+        return &i->dev_attr_cont.ac == cont;
+}
+
+/**
+ * ata_tdev_free  --  free a ATA LINK
+ * @dev:        ATA PHY to free
+ *
+ * Frees the specified ATA PHY.
+ *
+ * Note:
+ *   This function must only be called on a PHY that has not
+ *   successfully been added using ata_tdev_add().
+ */
+static void ata_tdev_free(struct ata_device *dev)
+{
+        transport_destroy_device(&dev->tdev);
+        put_device(&dev->tdev);
+}
+
+/**
+ * ata_tdev_delete  --  remove ATA device
+ * @port:       ATA PORT to remove
+ *
+ * Removes the specified ATA device.
+ */
+static void ata_tdev_delete(struct ata_device *ata_dev)
+{
+        struct device *dev = &ata_dev->tdev;
+
+        transport_remove_device(dev);
+        device_del(dev);
+        ata_tdev_free(ata_dev);
+}
+
+
+/**
+ * ata_tdev_add  --  initialize a transport ATA device structure.
+ * @ata_dev:    ata_dev structure.
+ *
+ * Initialize an ATA device structure for sysfs.  It will be added in the
+ * device tree below the ATA LINK device it belongs to.
+ *
+ * Returns %0 on success
+ */
+static int ata_tdev_add(struct ata_device *ata_dev)
+{
+        struct device *dev = &ata_dev->tdev;
+        struct ata_link *link = ata_dev->link;
+        struct ata_port *ap = link->ap;
+        int error;
+
+        device_initialize(dev);
+        dev->parent = get_device(&link->tdev);
+        dev->release = ata_tdev_release;
+        if (ata_is_host_link(link))
+                dev_set_name(dev, "dev%d.%d", ap->print_id,ata_dev->devno);
+        else
+                dev_set_name(dev, "dev%d.%d.0", ap->print_id, link->pmp);
+
+        transport_setup_device(dev);
+        error = device_add(dev);
+        if (error) {
+                ata_tdev_free(ata_dev);
+                return error;
+        }
+
+        transport_add_device(dev);
+        transport_configure_device(dev);
+        return 0;
+}
+
+
+/*
+ * Setup / Teardown code
+ */
+
+#define SETUP_TEMPLATE(attrb, field, perm, test)                        \
+        i->private_##attrb[count] = dev_attr_##field;                   \
+        i->private_##attrb[count].attr.mode = perm;                     \
+        i->attrb[count] = &i->private_##attrb[count];                   \
+        if (test)                                                       \
+                count++
+
+#define SETUP_LINK_ATTRIBUTE(field)                                     \
+        SETUP_TEMPLATE(link_attrs, field, S_IRUGO, 1)
+
+#define SETUP_PORT_ATTRIBUTE(field)                                     \
+        SETUP_TEMPLATE(port_attrs, field, S_IRUGO, 1)
+
+#define SETUP_DEV_ATTRIBUTE(field)                                      \
+        SETUP_TEMPLATE(dev_attrs, field, S_IRUGO, 1)
+
+/**
+ * ata_attach_transport  --  instantiate ATA transport template
+ */
+struct scsi_transport_template *ata_attach_transport(void)
+{
+        struct ata_internal *i;
+        int count;
+
+        i = kzalloc(sizeof(struct ata_internal), GFP_KERNEL);
+        if (!i)
+                return NULL;
+
+        i->t.eh_strategy_handler        = ata_scsi_error;
+        i->t.eh_timed_out               = ata_scsi_timed_out;
+        i->t.user_scan                  = ata_scsi_user_scan;
+
+        i->t.host_attrs.ac.attrs = &i->port_attrs[0];
+        i->t.host_attrs.ac.class = &ata_port_class.class;
+        i->t.host_attrs.ac.match = ata_tport_match;
+        transport_container_register(&i->t.host_attrs);
+
+        i->link_attr_cont.ac.class = &ata_link_class.class;
+        i->link_attr_cont.ac.attrs = &i->link_attrs[0];
+        i->link_attr_cont.ac.match = ata_tlink_match;
+        transport_container_register(&i->link_attr_cont);
+
+        i->dev_attr_cont.ac.class = &ata_dev_class.class;
+        i->dev_attr_cont.ac.attrs = &i->dev_attrs[0];
+        i->dev_attr_cont.ac.match = ata_tdev_match;
+        transport_container_register(&i->dev_attr_cont);
+
+        count = 0;
+        SETUP_PORT_ATTRIBUTE(nr_pmp_links);
+        SETUP_PORT_ATTRIBUTE(idle_irq);
+        BUG_ON(count > ATA_PORT_ATTRS);
+        i->port_attrs[count] = NULL;
+
+        count = 0;
+        SETUP_LINK_ATTRIBUTE(hw_sata_spd_limit);
+        SETUP_LINK_ATTRIBUTE(sata_spd_limit);
+        SETUP_LINK_ATTRIBUTE(sata_spd);
+        BUG_ON(count > ATA_LINK_ATTRS);
+        i->link_attrs[count] = NULL;
+
+        count = 0;
+        SETUP_DEV_ATTRIBUTE(class);
+        SETUP_DEV_ATTRIBUTE(pio_mode);
+        SETUP_DEV_ATTRIBUTE(dma_mode);
+        SETUP_DEV_ATTRIBUTE(xfer_mode);
+        SETUP_DEV_ATTRIBUTE(spdn_cnt);
+        SETUP_DEV_ATTRIBUTE(ering);
+        SETUP_DEV_ATTRIBUTE(id);
+        SETUP_DEV_ATTRIBUTE(gscr);
+        BUG_ON(count > ATA_DEV_ATTRS);
+        i->dev_attrs[count] = NULL;
+
+        return &i->t;
+}
+
+/**
+ * ata_release_transport  --  release ATA transport template instance
+ * @t:          transport template instance
+ */
+void ata_release_transport(struct scsi_transport_template *t)
+{
+        struct ata_internal *i = to_ata_internal(t);
+
+        transport_container_unregister(&i->t.host_attrs);
+        transport_container_unregister(&i->link_attr_cont);
+        transport_container_unregister(&i->dev_attr_cont);
+
+        kfree(i);
+}
+
+__init int libata_transport_init(void)
+{
+        int error;
+
+        error = transport_class_register(&ata_link_class);
+        if (error)
+                goto out_unregister_transport;
+        error = transport_class_register(&ata_port_class);
+        if (error)
+                goto out_unregister_link;
+        error = transport_class_register(&ata_dev_class);
+        if (error)
+                goto out_unregister_port;
+        return 0;
+
+ out_unregister_port:
+        transport_class_unregister(&ata_port_class);
+ out_unregister_link:
+        transport_class_unregister(&ata_link_class);
+ out_unregister_transport:
+        return error;
+
+}
+
+void __exit libata_transport_exit(void)
+{
+        transport_class_unregister(&ata_link_class);
+        transport_class_unregister(&ata_port_class);
+        transport_class_unregister(&ata_dev_class);
+}
diff --git a/drivers/ata/libata-transport.h b/drivers/ata/libata-transport.h
new file mode 100644
index 000000000000..2820cf864f11
--- /dev/null
+++ b/drivers/ata/libata-transport.h
@@ -0,0 +1,18 @@
+#ifndef _LIBATA_TRANSPORT_H
+#define _LIBATA_TRANSPORT_H
+
+
+extern struct scsi_transport_template *ata_scsi_transport_template;
+
+int ata_tlink_add(struct ata_link *link);
+void ata_tlink_delete(struct ata_link *link);
+
+int ata_tport_add(struct device *parent, struct ata_port *ap);
+void ata_tport_delete(struct ata_port *ap);
+
+struct scsi_transport_template *ata_attach_transport(void);
+void ata_release_transport(struct scsi_transport_template *t);
+
+__init int libata_transport_init(void);
+void __exit libata_transport_exit(void);
+#endif
diff --git a/drivers/ata/libata.h b/drivers/ata/libata.h
index 9ce1ecc63e39..773de97988a2 100644
--- a/drivers/ata/libata.h
+++ b/drivers/ata/libata.h
@@ -86,6 +86,8 @@ extern int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
 extern int ata_dev_configure(struct ata_device *dev);
 extern int sata_down_spd_limit(struct ata_link *link, u32 spd_limit);
 extern int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel);
+extern unsigned int ata_dev_set_feature(struct ata_device *dev,
+                                        u8 enable, u8 feature);
 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);
@@ -100,8 +102,8 @@ 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);
-extern void ata_dev_enable_pm(struct ata_device *dev, enum link_pm policy);
-extern void ata_lpm_schedule(struct ata_port *ap, enum link_pm);
+extern const char *sata_spd_string(unsigned int spd);
+extern int ata_port_probe(struct ata_port *ap);
 
 /* libata-acpi.c */
 #ifdef CONFIG_ATA_ACPI
@@ -137,10 +139,15 @@ extern void ata_scsi_hotplug(struct work_struct *work);
 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);
+extern int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
+                              unsigned int id, unsigned int lun);
+
 
 /* libata-eh.c */
 extern unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd);
 extern void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd);
+extern void ata_eh_acquire(struct ata_port *ap);
+extern void ata_eh_release(struct ata_port *ap);
 extern enum blk_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);
@@ -164,11 +171,16 @@ extern int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
                           ata_postreset_fn_t postreset,
                           struct ata_link **r_failed_disk);
 extern void ata_eh_finish(struct ata_port *ap);
+extern int ata_ering_map(struct ata_ering *ering,
+                         int (*map_fn)(struct ata_ering_entry *, void *),
+                         void *arg);
 
 /* libata-pmp.c */
 #ifdef CONFIG_SATA_PMP
 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_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                            unsigned hints);
 extern int sata_pmp_attach(struct ata_device *dev);
 #else /* CONFIG_SATA_PMP */
 static inline int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *val)
@@ -181,6 +193,12 @@ static inline int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
         return -EINVAL;
 }
 
+static inline int sata_pmp_set_lpm(struct ata_link *link,
+                                   enum ata_lpm_policy policy, unsigned hints)
+{
+        return -EINVAL;
+}
+
 static inline int sata_pmp_attach(struct ata_device *dev)
 {
         return -EINVAL;
diff --git a/drivers/ata/pata_acpi.c b/drivers/ata/pata_acpi.c
index c8d47034d5e9..91949d997555 100644
--- a/drivers/ata/pata_acpi.c
+++ b/drivers/ata/pata_acpi.c
@@ -245,7 +245,7 @@ static struct ata_port_operations pacpi_ops = {
 static int pacpi_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
 {
         static const struct ata_port_info info = {
-                .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
+                .flags          = ATA_FLAG_SLAVE_POSS,
 
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
diff --git a/drivers/ata/pata_amd.c b/drivers/ata/pata_amd.c
index 620a07cabe31..b0975a5ad8c4 100644
--- a/drivers/ata/pata_amd.c
+++ b/drivers/ata/pata_amd.c
@@ -11,7 +11,7 @@
  *      Power management on ports
  *
  *
- *  Documentation publically available.
+ *  Documentation publicly available.
  */
 
 #include <linux/kernel.h>
diff --git a/drivers/ata/pata_arasan_cf.c b/drivers/ata/pata_arasan_cf.c
new file mode 100644
index 000000000000..719bb73a73e0
--- /dev/null
+++ b/drivers/ata/pata_arasan_cf.c
@@ -0,0 +1,983 @@
+/*
+ * drivers/ata/pata_arasan_cf.c
+ *
+ * Arasan Compact Flash host controller source file
+ *
+ * Copyright (C) 2011 ST Microelectronics
+ * Viresh Kumar <viresh.kumar@st.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+/*
+ * The Arasan CompactFlash Device Controller IP core has three basic modes of
+ * operation: PC card ATA using I/O mode, PC card ATA using memory mode, PC card
+ * ATA using true IDE modes. This driver supports only True IDE mode currently.
+ *
+ * Arasan CF Controller shares global irq register with Arasan XD Controller.
+ *
+ * Tested on arch/arm/mach-spear13xx
+ */
+
+#include <linux/ata.h>
+#include <linux/clk.h>
+#include <linux/completion.h>
+#include <linux/delay.h>
+#include <linux/dmaengine.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/libata.h>
+#include <linux/module.h>
+#include <linux/pata_arasan_cf_data.h>
+#include <linux/platform_device.h>
+#include <linux/pm.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+#include <linux/workqueue.h>
+
+#define DRIVER_NAME     "arasan_cf"
+#define TIMEOUT         msecs_to_jiffies(3000)
+
+/* Registers */
+/* CompactFlash Interface Status */
+#define CFI_STS                 0x000
+        #define STS_CHG                         (1)
+        #define BIN_AUDIO_OUT                   (1 << 1)
+        #define CARD_DETECT1                    (1 << 2)
+        #define CARD_DETECT2                    (1 << 3)
+        #define INP_ACK                         (1 << 4)
+        #define CARD_READY                      (1 << 5)
+        #define IO_READY                        (1 << 6)
+        #define B16_IO_PORT_SEL                 (1 << 7)
+/* IRQ */
+#define IRQ_STS                 0x004
+/* Interrupt Enable */
+#define IRQ_EN                  0x008
+        #define CARD_DETECT_IRQ                 (1)
+        #define STATUS_CHNG_IRQ                 (1 << 1)
+        #define MEM_MODE_IRQ                    (1 << 2)
+        #define IO_MODE_IRQ                     (1 << 3)
+        #define TRUE_IDE_MODE_IRQ               (1 << 8)
+        #define PIO_XFER_ERR_IRQ                (1 << 9)
+        #define BUF_AVAIL_IRQ                   (1 << 10)
+        #define XFER_DONE_IRQ                   (1 << 11)
+        #define IGNORED_IRQS    (STATUS_CHNG_IRQ | MEM_MODE_IRQ | IO_MODE_IRQ |\
+                                        TRUE_IDE_MODE_IRQ)
+        #define TRUE_IDE_IRQS   (CARD_DETECT_IRQ | PIO_XFER_ERR_IRQ |\
+                                        BUF_AVAIL_IRQ | XFER_DONE_IRQ)
+/* Operation Mode */
+#define OP_MODE                 0x00C
+        #define CARD_MODE_MASK                  (0x3)
+        #define MEM_MODE                        (0x0)
+        #define IO_MODE                         (0x1)
+        #define TRUE_IDE_MODE                   (0x2)
+
+        #define CARD_TYPE_MASK                  (1 << 2)
+        #define CF_CARD                         (0)
+        #define CF_PLUS_CARD                    (1 << 2)
+
+        #define CARD_RESET                      (1 << 3)
+        #define CFHOST_ENB                      (1 << 4)
+        #define OUTPUTS_TRISTATE                (1 << 5)
+        #define ULTRA_DMA_ENB                   (1 << 8)
+        #define MULTI_WORD_DMA_ENB              (1 << 9)
+        #define DRQ_BLOCK_SIZE_MASK             (0x3 << 11)
+        #define DRQ_BLOCK_SIZE_512              (0)
+        #define DRQ_BLOCK_SIZE_1024             (1 << 11)
+        #define DRQ_BLOCK_SIZE_2048             (2 << 11)
+        #define DRQ_BLOCK_SIZE_4096             (3 << 11)
+/* CF Interface Clock Configuration */
+#define CLK_CFG                 0x010
+        #define CF_IF_CLK_MASK                  (0XF)
+/* CF Timing Mode Configuration */
+#define TM_CFG                  0x014
+        #define MEM_MODE_TIMING_MASK            (0x3)
+        #define MEM_MODE_TIMING_250NS           (0x0)
+        #define MEM_MODE_TIMING_120NS           (0x1)
+        #define MEM_MODE_TIMING_100NS           (0x2)
+        #define MEM_MODE_TIMING_80NS            (0x3)
+
+        #define IO_MODE_TIMING_MASK             (0x3 << 2)
+        #define IO_MODE_TIMING_250NS            (0x0 << 2)
+        #define IO_MODE_TIMING_120NS            (0x1 << 2)
+        #define IO_MODE_TIMING_100NS            (0x2 << 2)
+        #define IO_MODE_TIMING_80NS             (0x3 << 2)
+
+        #define TRUEIDE_PIO_TIMING_MASK         (0x7 << 4)
+        #define TRUEIDE_PIO_TIMING_SHIFT        4
+
+        #define TRUEIDE_MWORD_DMA_TIMING_MASK   (0x7 << 7)
+        #define TRUEIDE_MWORD_DMA_TIMING_SHIFT  7
+
+        #define ULTRA_DMA_TIMING_MASK           (0x7 << 10)
+        #define ULTRA_DMA_TIMING_SHIFT          10
+/* CF Transfer Address */
+#define XFER_ADDR               0x014
+        #define XFER_ADDR_MASK                  (0x7FF)
+        #define MAX_XFER_COUNT                  0x20000u
+/* Transfer Control */
+#define XFER_CTR                0x01C
+        #define XFER_COUNT_MASK                 (0x3FFFF)
+        #define ADDR_INC_DISABLE                (1 << 24)
+        #define XFER_WIDTH_MASK                 (1 << 25)
+        #define XFER_WIDTH_8B                   (0)
+        #define XFER_WIDTH_16B                  (1 << 25)
+
+        #define MEM_TYPE_MASK                   (1 << 26)
+        #define MEM_TYPE_COMMON                 (0)
+        #define MEM_TYPE_ATTRIBUTE              (1 << 26)
+
+        #define MEM_IO_XFER_MASK                (1 << 27)
+        #define MEM_XFER                        (0)
+        #define IO_XFER                         (1 << 27)
+
+        #define DMA_XFER_MODE                   (1 << 28)
+
+        #define AHB_BUS_NORMAL_PIO_OPRTN        (~(1 << 29))
+        #define XFER_DIR_MASK                   (1 << 30)
+        #define XFER_READ                       (0)
+        #define XFER_WRITE                      (1 << 30)
+
+        #define XFER_START                      (1 << 31)
+/* Write Data Port */
+#define WRITE_PORT              0x024
+/* Read Data Port */
+#define READ_PORT               0x028
+/* ATA Data Port */
+#define ATA_DATA_PORT           0x030
+        #define ATA_DATA_PORT_MASK              (0xFFFF)
+/* ATA Error/Features */
+#define ATA_ERR_FTR             0x034
+/* ATA Sector Count */
+#define ATA_SC                  0x038
+/* ATA Sector Number */
+#define ATA_SN                  0x03C
+/* ATA Cylinder Low */
+#define ATA_CL                  0x040
+/* ATA Cylinder High */
+#define ATA_CH                  0x044
+/* ATA Select Card/Head */
+#define ATA_SH                  0x048
+/* ATA Status-Command */
+#define ATA_STS_CMD             0x04C
+/* ATA Alternate Status/Device Control */
+#define ATA_ASTS_DCTR           0x050
+/* Extended Write Data Port 0x200-0x3FC */
+#define EXT_WRITE_PORT          0x200
+/* Extended Read Data Port 0x400-0x5FC */
+#define EXT_READ_PORT           0x400
+        #define FIFO_SIZE       0x200u
+/* Global Interrupt Status */
+#define GIRQ_STS                0x800
+/* Global Interrupt Status enable */
+#define GIRQ_STS_EN             0x804
+/* Global Interrupt Signal enable */
+#define GIRQ_SGN_EN             0x808
+        #define GIRQ_CF         (1)
+        #define GIRQ_XD         (1 << 1)
+
+/* Compact Flash Controller Dev Structure */
+struct arasan_cf_dev {
+        /* pointer to ata_host structure */
+        struct ata_host *host;
+        /* clk structure, only if HAVE_CLK is defined */
+#ifdef CONFIG_HAVE_CLK
+        struct clk *clk;
+#endif
+
+        /* physical base address of controller */
+        dma_addr_t pbase;
+        /* virtual base address of controller */
+        void __iomem *vbase;
+        /* irq number*/
+        int irq;
+
+        /* status to be updated to framework regarding DMA transfer */
+        u8 dma_status;
+        /* Card is present or Not */
+        u8 card_present;
+
+        /* dma specific */
+        /* Completion for transfer complete interrupt from controller */
+        struct completion cf_completion;
+        /* Completion for DMA transfer complete. */
+        struct completion dma_completion;
+        /* Dma channel allocated */
+        struct dma_chan *dma_chan;
+        /* Mask for DMA transfers */
+        dma_cap_mask_t mask;
+        /* dma channel private data */
+        void *dma_priv;
+        /* DMA transfer work */
+        struct work_struct work;
+        /* DMA delayed finish work */
+        struct delayed_work dwork;
+        /* qc to be transferred using DMA */
+        struct ata_queued_cmd *qc;
+};
+
+static struct scsi_host_template arasan_cf_sht = {
+        ATA_BASE_SHT(DRIVER_NAME),
+        .sg_tablesize = SG_NONE,
+        .dma_boundary = 0xFFFFFFFFUL,
+};
+
+static void cf_dumpregs(struct arasan_cf_dev *acdev)
+{
+        struct device *dev = acdev->host->dev;
+
+        dev_dbg(dev, ": =========== REGISTER DUMP ===========");
+        dev_dbg(dev, ": CFI_STS: %x", readl(acdev->vbase + CFI_STS));
+        dev_dbg(dev, ": IRQ_STS: %x", readl(acdev->vbase + IRQ_STS));
+        dev_dbg(dev, ": IRQ_EN: %x", readl(acdev->vbase + IRQ_EN));
+        dev_dbg(dev, ": OP_MODE: %x", readl(acdev->vbase + OP_MODE));
+        dev_dbg(dev, ": CLK_CFG: %x", readl(acdev->vbase + CLK_CFG));
+        dev_dbg(dev, ": TM_CFG: %x", readl(acdev->vbase + TM_CFG));
+        dev_dbg(dev, ": XFER_CTR: %x", readl(acdev->vbase + XFER_CTR));
+        dev_dbg(dev, ": GIRQ_STS: %x", readl(acdev->vbase + GIRQ_STS));
+        dev_dbg(dev, ": GIRQ_STS_EN: %x", readl(acdev->vbase + GIRQ_STS_EN));
+        dev_dbg(dev, ": GIRQ_SGN_EN: %x", readl(acdev->vbase + GIRQ_SGN_EN));
+        dev_dbg(dev, ": =====================================");
+}
+
+/* Enable/Disable global interrupts shared between CF and XD ctrlr. */
+static void cf_ginterrupt_enable(struct arasan_cf_dev *acdev, bool enable)
+{
+        /* enable should be 0 or 1 */
+        writel(enable, acdev->vbase + GIRQ_STS_EN);
+        writel(enable, acdev->vbase + GIRQ_SGN_EN);
+}
+
+/* Enable/Disable CF interrupts */
+static inline void
+cf_interrupt_enable(struct arasan_cf_dev *acdev, u32 mask, bool enable)
+{
+        u32 val = readl(acdev->vbase + IRQ_EN);
+        /* clear & enable/disable irqs */
+        if (enable) {
+                writel(mask, acdev->vbase + IRQ_STS);
+                writel(val | mask, acdev->vbase + IRQ_EN);
+        } else
+                writel(val & ~mask, acdev->vbase + IRQ_EN);
+}
+
+static inline void cf_card_reset(struct arasan_cf_dev *acdev)
+{
+        u32 val = readl(acdev->vbase + OP_MODE);
+
+        writel(val | CARD_RESET, acdev->vbase + OP_MODE);
+        udelay(200);
+        writel(val & ~CARD_RESET, acdev->vbase + OP_MODE);
+}
+
+static inline void cf_ctrl_reset(struct arasan_cf_dev *acdev)
+{
+        writel(readl(acdev->vbase + OP_MODE) & ~CFHOST_ENB,
+                        acdev->vbase + OP_MODE);
+        writel(readl(acdev->vbase + OP_MODE) | CFHOST_ENB,
+                        acdev->vbase + OP_MODE);
+}
+
+static void cf_card_detect(struct arasan_cf_dev *acdev, bool hotplugged)
+{
+        struct ata_port *ap = acdev->host->ports[0];
+        struct ata_eh_info *ehi = &ap->link.eh_info;
+        u32 val = readl(acdev->vbase + CFI_STS);
+
+        /* Both CD1 & CD2 should be low if card inserted completely */
+        if (!(val & (CARD_DETECT1 | CARD_DETECT2))) {
+                if (acdev->card_present)
+                        return;
+                acdev->card_present = 1;
+                cf_card_reset(acdev);
+        } else {
+                if (!acdev->card_present)
+                        return;
+                acdev->card_present = 0;
+        }
+
+        if (hotplugged) {
+                ata_ehi_hotplugged(ehi);
+                ata_port_freeze(ap);
+        }
+}
+
+static int cf_init(struct arasan_cf_dev *acdev)
+{
+        struct arasan_cf_pdata *pdata = dev_get_platdata(acdev->host->dev);
+        unsigned long flags;
+        int ret = 0;
+
+#ifdef CONFIG_HAVE_CLK
+        ret = clk_enable(acdev->clk);
+        if (ret) {
+                dev_dbg(acdev->host->dev, "clock enable failed");
+                return ret;
+        }
+#endif
+
+        spin_lock_irqsave(&acdev->host->lock, flags);
+        /* configure CF interface clock */
+        writel((pdata->cf_if_clk <= CF_IF_CLK_200M) ? pdata->cf_if_clk :
+                        CF_IF_CLK_166M, acdev->vbase + CLK_CFG);
+
+        writel(TRUE_IDE_MODE | CFHOST_ENB, acdev->vbase + OP_MODE);
+        cf_interrupt_enable(acdev, CARD_DETECT_IRQ, 1);
+        cf_ginterrupt_enable(acdev, 1);
+        spin_unlock_irqrestore(&acdev->host->lock, flags);
+
+        return ret;
+}
+
+static void cf_exit(struct arasan_cf_dev *acdev)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&acdev->host->lock, flags);
+        cf_ginterrupt_enable(acdev, 0);
+        cf_interrupt_enable(acdev, TRUE_IDE_IRQS, 0);
+        cf_card_reset(acdev);
+        writel(readl(acdev->vbase + OP_MODE) & ~CFHOST_ENB,
+                        acdev->vbase + OP_MODE);
+        spin_unlock_irqrestore(&acdev->host->lock, flags);
+#ifdef CONFIG_HAVE_CLK
+        clk_disable(acdev->clk);
+#endif
+}
+
+static void dma_callback(void *dev)
+{
+        struct arasan_cf_dev *acdev = (struct arasan_cf_dev *) dev;
+
+        complete(&acdev->dma_completion);
+}
+
+static bool filter(struct dma_chan *chan, void *slave)
+{
+        chan->private = slave;
+        return true;
+}
+
+static inline void dma_complete(struct arasan_cf_dev *acdev)
+{
+        struct ata_queued_cmd *qc = acdev->qc;
+        unsigned long flags;
+
+        acdev->qc = NULL;
+        ata_sff_interrupt(acdev->irq, acdev->host);
+
+        spin_lock_irqsave(&acdev->host->lock, flags);
+        if (unlikely(qc->err_mask) && ata_is_dma(qc->tf.protocol))
+                ata_ehi_push_desc(&qc->ap->link.eh_info, "DMA Failed: Timeout");
+        spin_unlock_irqrestore(&acdev->host->lock, flags);
+}
+
+static inline int wait4buf(struct arasan_cf_dev *acdev)
+{
+        if (!wait_for_completion_timeout(&acdev->cf_completion, TIMEOUT)) {
+                u32 rw = acdev->qc->tf.flags & ATA_TFLAG_WRITE;
+
+                dev_err(acdev->host->dev, "%s TimeOut", rw ? "write" : "read");
+                return -ETIMEDOUT;
+        }
+
+        /* Check if PIO Error interrupt has occurred */
+        if (acdev->dma_status & ATA_DMA_ERR)
+                return -EAGAIN;
+
+        return 0;
+}
+
+static int
+dma_xfer(struct arasan_cf_dev *acdev, dma_addr_t src, dma_addr_t dest, u32 len)
+{
+        struct dma_async_tx_descriptor *tx;
+        struct dma_chan *chan = acdev->dma_chan;
+        dma_cookie_t cookie;
+        unsigned long flags = DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_SRC_UNMAP |
+                DMA_COMPL_SKIP_DEST_UNMAP;
+        int ret = 0;
+
+        tx = chan->device->device_prep_dma_memcpy(chan, dest, src, len, flags);
+        if (!tx) {
+                dev_err(acdev->host->dev, "device_prep_dma_memcpy failed\n");
+                return -EAGAIN;
+        }
+
+        tx->callback = dma_callback;
+        tx->callback_param = acdev;
+        cookie = tx->tx_submit(tx);
+
+        ret = dma_submit_error(cookie);
+        if (ret) {
+                dev_err(acdev->host->dev, "dma_submit_error\n");
+                return ret;
+        }
+
+        chan->device->device_issue_pending(chan);
+
+        /* Wait for DMA to complete */
+        if (!wait_for_completion_timeout(&acdev->dma_completion, TIMEOUT)) {
+                chan->device->device_control(chan, DMA_TERMINATE_ALL, 0);
+                dev_err(acdev->host->dev, "wait_for_completion_timeout\n");
+                return -ETIMEDOUT;
+        }
+
+        return ret;
+}
+
+static int sg_xfer(struct arasan_cf_dev *acdev, struct scatterlist *sg)
+{
+        dma_addr_t dest = 0, src = 0;
+        u32 xfer_cnt, sglen, dma_len, xfer_ctr;
+        u32 write = acdev->qc->tf.flags & ATA_TFLAG_WRITE;
+        unsigned long flags;
+        int ret = 0;
+
+        sglen = sg_dma_len(sg);
+        if (write) {
+                src = sg_dma_address(sg);
+                dest = acdev->pbase + EXT_WRITE_PORT;
+        } else {
+                dest = sg_dma_address(sg);
+                src = acdev->pbase + EXT_READ_PORT;
+        }
+
+        /*
+         * For each sg:
+         * MAX_XFER_COUNT data will be transferred before we get transfer
+         * complete interrupt. Between after FIFO_SIZE data
+         * buffer available interrupt will be generated. At this time we will
+         * fill FIFO again: max FIFO_SIZE data.
+         */
+        while (sglen) {
+                xfer_cnt = min(sglen, MAX_XFER_COUNT);
+                spin_lock_irqsave(&acdev->host->lock, flags);
+                xfer_ctr = readl(acdev->vbase + XFER_CTR) &
+                        ~XFER_COUNT_MASK;
+                writel(xfer_ctr | xfer_cnt | XFER_START,
+                                acdev->vbase + XFER_CTR);
+                spin_unlock_irqrestore(&acdev->host->lock, flags);
+
+                /* continue dma xfers until current sg is completed */
+                while (xfer_cnt) {
+                        /* wait for read to complete */
+                        if (!write) {
+                                ret = wait4buf(acdev);
+                                if (ret)
+                                        goto fail;
+                        }
+
+                        /* read/write FIFO in chunk of FIFO_SIZE */
+                        dma_len = min(xfer_cnt, FIFO_SIZE);
+                        ret = dma_xfer(acdev, src, dest, dma_len);
+                        if (ret) {
+                                dev_err(acdev->host->dev, "dma failed");
+                                goto fail;
+                        }
+
+                        if (write)
+                                src += dma_len;
+                        else
+                                dest += dma_len;
+
+                        sglen -= dma_len;
+                        xfer_cnt -= dma_len;
+
+                        /* wait for write to complete */
+                        if (write) {
+                                ret = wait4buf(acdev);
+                                if (ret)
+                                        goto fail;
+                        }
+                }
+        }
+
+fail:
+        spin_lock_irqsave(&acdev->host->lock, flags);
+        writel(readl(acdev->vbase + XFER_CTR) & ~XFER_START,
+                        acdev->vbase + XFER_CTR);
+        spin_unlock_irqrestore(&acdev->host->lock, flags);
+
+        return ret;
+}
+
+/*
+ * This routine uses External DMA controller to read/write data to FIFO of CF
+ * controller. There are two xfer related interrupt supported by CF controller:
+ * - buf_avail: This interrupt is generated as soon as we have buffer of 512
+ *      bytes available for reading or empty buffer available for writing.
+ * - xfer_done: This interrupt is generated on transfer of "xfer_size" amount of
+ *      data to/from FIFO. xfer_size is programmed in XFER_CTR register.
+ *
+ * Max buffer size = FIFO_SIZE = 512 Bytes.
+ * Max xfer_size = MAX_XFER_COUNT = 256 KB.
+ */
+static void data_xfer(struct work_struct *work)
+{
+        struct arasan_cf_dev *acdev = container_of(work, struct arasan_cf_dev,
+                        work);
+        struct ata_queued_cmd *qc = acdev->qc;
+        struct scatterlist *sg;
+        unsigned long flags;
+        u32 temp;
+        int ret = 0;
+
+        /* request dma channels */
+        /* dma_request_channel may sleep, so calling from process context */
+        acdev->dma_chan = dma_request_channel(acdev->mask, filter,
+                        acdev->dma_priv);
+        if (!acdev->dma_chan) {
+                dev_err(acdev->host->dev, "Unable to get dma_chan\n");
+                goto chan_request_fail;
+        }
+
+        for_each_sg(qc->sg, sg, qc->n_elem, temp) {
+                ret = sg_xfer(acdev, sg);
+                if (ret)
+                        break;
+        }
+
+        dma_release_channel(acdev->dma_chan);
+
+        /* data xferred successfully */
+        if (!ret) {
+                u32 status;
+
+                spin_lock_irqsave(&acdev->host->lock, flags);
+                status = ioread8(qc->ap->ioaddr.altstatus_addr);
+                spin_unlock_irqrestore(&acdev->host->lock, flags);
+                if (status & (ATA_BUSY | ATA_DRQ)) {
+                        ata_sff_queue_delayed_work(&acdev->dwork, 1);
+                        return;
+                }
+
+                goto sff_intr;
+        }
+
+        cf_dumpregs(acdev);
+
+chan_request_fail:
+        spin_lock_irqsave(&acdev->host->lock, flags);
+        /* error when transferring data to/from memory */
+        qc->err_mask |= AC_ERR_HOST_BUS;
+        qc->ap->hsm_task_state = HSM_ST_ERR;
+
+        cf_ctrl_reset(acdev);
+        spin_unlock_irqrestore(qc->ap->lock, flags);
+sff_intr:
+        dma_complete(acdev);
+}
+
+static void delayed_finish(struct work_struct *work)
+{
+        struct arasan_cf_dev *acdev = container_of(work, struct arasan_cf_dev,
+                        dwork.work);
+        struct ata_queued_cmd *qc = acdev->qc;
+        unsigned long flags;
+        u8 status;
+
+        spin_lock_irqsave(&acdev->host->lock, flags);
+        status = ioread8(qc->ap->ioaddr.altstatus_addr);
+        spin_unlock_irqrestore(&acdev->host->lock, flags);
+
+        if (status & (ATA_BUSY | ATA_DRQ))
+                ata_sff_queue_delayed_work(&acdev->dwork, 1);
+        else
+                dma_complete(acdev);
+}
+
+static irqreturn_t arasan_cf_interrupt(int irq, void *dev)
+{
+        struct arasan_cf_dev *acdev = ((struct ata_host *)dev)->private_data;
+        unsigned long flags;
+        u32 irqsts;
+
+        irqsts = readl(acdev->vbase + GIRQ_STS);
+        if (!(irqsts & GIRQ_CF))
+                return IRQ_NONE;
+
+        spin_lock_irqsave(&acdev->host->lock, flags);
+        irqsts = readl(acdev->vbase + IRQ_STS);
+        writel(irqsts, acdev->vbase + IRQ_STS);         /* clear irqs */
+        writel(GIRQ_CF, acdev->vbase + GIRQ_STS);       /* clear girqs */
+
+        /* handle only relevant interrupts */
+        irqsts &= ~IGNORED_IRQS;
+
+        if (irqsts & CARD_DETECT_IRQ) {
+                cf_card_detect(acdev, 1);
+                spin_unlock_irqrestore(&acdev->host->lock, flags);
+                return IRQ_HANDLED;
+        }
+
+        if (irqsts & PIO_XFER_ERR_IRQ) {
+                acdev->dma_status = ATA_DMA_ERR;
+                writel(readl(acdev->vbase + XFER_CTR) & ~XFER_START,
+                                acdev->vbase + XFER_CTR);
+                spin_unlock_irqrestore(&acdev->host->lock, flags);
+                complete(&acdev->cf_completion);
+                dev_err(acdev->host->dev, "pio xfer err irq\n");
+                return IRQ_HANDLED;
+        }
+
+        spin_unlock_irqrestore(&acdev->host->lock, flags);
+
+        if (irqsts & BUF_AVAIL_IRQ) {
+                complete(&acdev->cf_completion);
+                return IRQ_HANDLED;
+        }
+
+        if (irqsts & XFER_DONE_IRQ) {
+                struct ata_queued_cmd *qc = acdev->qc;
+
+                /* Send Complete only for write */
+                if (qc->tf.flags & ATA_TFLAG_WRITE)
+                        complete(&acdev->cf_completion);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static void arasan_cf_freeze(struct ata_port *ap)
+{
+        struct arasan_cf_dev *acdev = ap->host->private_data;
+
+        /* stop transfer and reset controller */
+        writel(readl(acdev->vbase + XFER_CTR) & ~XFER_START,
+                        acdev->vbase + XFER_CTR);
+        cf_ctrl_reset(acdev);
+        acdev->dma_status = ATA_DMA_ERR;
+
+        ata_sff_dma_pause(ap);
+        ata_sff_freeze(ap);
+}
+
+void arasan_cf_error_handler(struct ata_port *ap)
+{
+        struct arasan_cf_dev *acdev = ap->host->private_data;
+
+        /*
+         * DMA transfers using an external DMA controller may be scheduled.
+         * Abort them before handling error. Refer data_xfer() for further
+         * details.
+         */
+        cancel_work_sync(&acdev->work);
+        cancel_delayed_work_sync(&acdev->dwork);
+        return ata_sff_error_handler(ap);
+}
+
+static void arasan_cf_dma_start(struct arasan_cf_dev *acdev)
+{
+        u32 xfer_ctr = readl(acdev->vbase + XFER_CTR) & ~XFER_DIR_MASK;
+        u32 write = acdev->qc->tf.flags & ATA_TFLAG_WRITE;
+
+        xfer_ctr |= write ? XFER_WRITE : XFER_READ;
+        writel(xfer_ctr, acdev->vbase + XFER_CTR);
+
+        acdev->qc->ap->ops->sff_exec_command(acdev->qc->ap, &acdev->qc->tf);
+        ata_sff_queue_work(&acdev->work);
+}
+
+unsigned int arasan_cf_qc_issue(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct arasan_cf_dev *acdev = ap->host->private_data;
+
+        /* defer PIO handling to sff_qc_issue */
+        if (!ata_is_dma(qc->tf.protocol))
+                return ata_sff_qc_issue(qc);
+
+        /* select the device */
+        ata_wait_idle(ap);
+        ata_sff_dev_select(ap, qc->dev->devno);
+        ata_wait_idle(ap);
+
+        /* start the command */
+        switch (qc->tf.protocol) {
+        case ATA_PROT_DMA:
+                WARN_ON_ONCE(qc->tf.flags & ATA_TFLAG_POLLING);
+
+                ap->ops->sff_tf_load(ap, &qc->tf);
+                acdev->dma_status = 0;
+                acdev->qc = qc;
+                arasan_cf_dma_start(acdev);
+                ap->hsm_task_state = HSM_ST_LAST;
+                break;
+
+        default:
+                WARN_ON(1);
+                return AC_ERR_SYSTEM;
+        }
+
+        return 0;
+}
+
+static void arasan_cf_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        struct arasan_cf_dev *acdev = ap->host->private_data;
+        u8 pio = adev->pio_mode - XFER_PIO_0;
+        unsigned long flags;
+        u32 val;
+
+        /* Arasan ctrl supports Mode0 -> Mode6 */
+        if (pio > 6) {
+                dev_err(ap->dev, "Unknown PIO mode\n");
+                return;
+        }
+
+        spin_lock_irqsave(&acdev->host->lock, flags);
+        val = readl(acdev->vbase + OP_MODE) &
+                ~(ULTRA_DMA_ENB | MULTI_WORD_DMA_ENB | DRQ_BLOCK_SIZE_MASK);
+        writel(val, acdev->vbase + OP_MODE);
+        val = readl(acdev->vbase + TM_CFG) & ~TRUEIDE_PIO_TIMING_MASK;
+        val |= pio << TRUEIDE_PIO_TIMING_SHIFT;
+        writel(val, acdev->vbase + TM_CFG);
+
+        cf_interrupt_enable(acdev, BUF_AVAIL_IRQ | XFER_DONE_IRQ, 0);
+        cf_interrupt_enable(acdev, PIO_XFER_ERR_IRQ, 1);
+        spin_unlock_irqrestore(&acdev->host->lock, flags);
+}
+
+static void arasan_cf_set_dmamode(struct ata_port *ap, struct ata_device *adev)
+{
+        struct arasan_cf_dev *acdev = ap->host->private_data;
+        u32 opmode, tmcfg, dma_mode = adev->dma_mode;
+        unsigned long flags;
+
+        spin_lock_irqsave(&acdev->host->lock, flags);
+        opmode = readl(acdev->vbase + OP_MODE) &
+                ~(MULTI_WORD_DMA_ENB | ULTRA_DMA_ENB);
+        tmcfg = readl(acdev->vbase + TM_CFG);
+
+        if ((dma_mode >= XFER_UDMA_0) && (dma_mode <= XFER_UDMA_6)) {
+                opmode |= ULTRA_DMA_ENB;
+                tmcfg &= ~ULTRA_DMA_TIMING_MASK;
+                tmcfg |= (dma_mode - XFER_UDMA_0) << ULTRA_DMA_TIMING_SHIFT;
+        } else if ((dma_mode >= XFER_MW_DMA_0) && (dma_mode <= XFER_MW_DMA_4)) {
+                opmode |= MULTI_WORD_DMA_ENB;
+                tmcfg &= ~TRUEIDE_MWORD_DMA_TIMING_MASK;
+                tmcfg |= (dma_mode - XFER_MW_DMA_0) <<
+                        TRUEIDE_MWORD_DMA_TIMING_SHIFT;
+        } else {
+                dev_err(ap->dev, "Unknown DMA mode\n");
+                spin_unlock_irqrestore(&acdev->host->lock, flags);
+                return;
+        }
+
+        writel(opmode, acdev->vbase + OP_MODE);
+        writel(tmcfg, acdev->vbase + TM_CFG);
+        writel(DMA_XFER_MODE, acdev->vbase + XFER_CTR);
+
+        cf_interrupt_enable(acdev, PIO_XFER_ERR_IRQ, 0);
+        cf_interrupt_enable(acdev, BUF_AVAIL_IRQ | XFER_DONE_IRQ, 1);
+        spin_unlock_irqrestore(&acdev->host->lock, flags);
+}
+
+static struct ata_port_operations arasan_cf_ops = {
+        .inherits = &ata_sff_port_ops,
+        .freeze = arasan_cf_freeze,
+        .error_handler = arasan_cf_error_handler,
+        .qc_issue = arasan_cf_qc_issue,
+        .set_piomode = arasan_cf_set_piomode,
+        .set_dmamode = arasan_cf_set_dmamode,
+};
+
+static int __devinit arasan_cf_probe(struct platform_device *pdev)
+{
+        struct arasan_cf_dev *acdev;
+        struct arasan_cf_pdata *pdata = dev_get_platdata(&pdev->dev);
+        struct ata_host *host;
+        struct ata_port *ap;
+        struct resource *res;
+        irq_handler_t irq_handler = NULL;
+        int ret = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -EINVAL;
+
+        if (!devm_request_mem_region(&pdev->dev, res->start, resource_size(res),
+                                DRIVER_NAME)) {
+                dev_warn(&pdev->dev, "Failed to get memory region resource\n");
+                return -ENOENT;
+        }
+
+        acdev = devm_kzalloc(&pdev->dev, sizeof(*acdev), GFP_KERNEL);
+        if (!acdev) {
+                dev_warn(&pdev->dev, "kzalloc fail\n");
+                return -ENOMEM;
+        }
+
+        /* if irq is 0, support only PIO */
+        acdev->irq = platform_get_irq(pdev, 0);
+        if (acdev->irq)
+                irq_handler = arasan_cf_interrupt;
+        else
+                pdata->quirk |= CF_BROKEN_MWDMA | CF_BROKEN_UDMA;
+
+        acdev->pbase = res->start;
+        acdev->vbase = devm_ioremap_nocache(&pdev->dev, res->start,
+                        resource_size(res));
+        if (!acdev->vbase) {
+                dev_warn(&pdev->dev, "ioremap fail\n");
+                return -ENOMEM;
+        }
+
+#ifdef CONFIG_HAVE_CLK
+        acdev->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(acdev->clk)) {
+                dev_warn(&pdev->dev, "Clock not found\n");
+                return PTR_ERR(acdev->clk);
+        }
+#endif
+
+        /* allocate host */
+        host = ata_host_alloc(&pdev->dev, 1);
+        if (!host) {
+                ret = -ENOMEM;
+                dev_warn(&pdev->dev, "alloc host fail\n");
+                goto free_clk;
+        }
+
+        ap = host->ports[0];
+        host->private_data = acdev;
+        acdev->host = host;
+        ap->ops = &arasan_cf_ops;
+        ap->pio_mask = ATA_PIO6;
+        ap->mwdma_mask = ATA_MWDMA4;
+        ap->udma_mask = ATA_UDMA6;
+
+        init_completion(&acdev->cf_completion);
+        init_completion(&acdev->dma_completion);
+        INIT_WORK(&acdev->work, data_xfer);
+        INIT_DELAYED_WORK(&acdev->dwork, delayed_finish);
+        dma_cap_set(DMA_MEMCPY, acdev->mask);
+        acdev->dma_priv = pdata->dma_priv;
+
+        /* Handle platform specific quirks */
+        if (pdata->quirk) {
+                if (pdata->quirk & CF_BROKEN_PIO) {
+                        ap->ops->set_piomode = NULL;
+                        ap->pio_mask = 0;
+                }
+                if (pdata->quirk & CF_BROKEN_MWDMA)
+                        ap->mwdma_mask = 0;
+                if (pdata->quirk & CF_BROKEN_UDMA)
+                        ap->udma_mask = 0;
+        }
+        ap->flags |= ATA_FLAG_PIO_POLLING | ATA_FLAG_NO_ATAPI;
+
+        ap->ioaddr.cmd_addr = acdev->vbase + ATA_DATA_PORT;
+        ap->ioaddr.data_addr = acdev->vbase + ATA_DATA_PORT;
+        ap->ioaddr.error_addr = acdev->vbase + ATA_ERR_FTR;
+        ap->ioaddr.feature_addr = acdev->vbase + ATA_ERR_FTR;
+        ap->ioaddr.nsect_addr = acdev->vbase + ATA_SC;
+        ap->ioaddr.lbal_addr = acdev->vbase + ATA_SN;
+        ap->ioaddr.lbam_addr = acdev->vbase + ATA_CL;
+        ap->ioaddr.lbah_addr = acdev->vbase + ATA_CH;
+        ap->ioaddr.device_addr = acdev->vbase + ATA_SH;
+        ap->ioaddr.status_addr = acdev->vbase + ATA_STS_CMD;
+        ap->ioaddr.command_addr = acdev->vbase + ATA_STS_CMD;
+        ap->ioaddr.altstatus_addr = acdev->vbase + ATA_ASTS_DCTR;
+        ap->ioaddr.ctl_addr = acdev->vbase + ATA_ASTS_DCTR;
+
+        ata_port_desc(ap, "phy_addr %llx virt_addr %p",
+                      (unsigned long long) res->start, acdev->vbase);
+
+        ret = cf_init(acdev);
+        if (ret)
+                goto free_clk;
+
+        cf_card_detect(acdev, 0);
+
+        return ata_host_activate(host, acdev->irq, irq_handler, 0,
+                        &arasan_cf_sht);
+
+free_clk:
+#ifdef CONFIG_HAVE_CLK
+        clk_put(acdev->clk);
+#endif
+        return ret;
+}
+
+static int __devexit arasan_cf_remove(struct platform_device *pdev)
+{
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        struct arasan_cf_dev *acdev = host->ports[0]->private_data;
+
+        ata_host_detach(host);
+        cf_exit(acdev);
+#ifdef CONFIG_HAVE_CLK
+        clk_put(acdev->clk);
+#endif
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int arasan_cf_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        struct arasan_cf_dev *acdev = host->ports[0]->private_data;
+
+        if (acdev->dma_chan) {
+                acdev->dma_chan->device->device_control(acdev->dma_chan,
+                                DMA_TERMINATE_ALL, 0);
+                dma_release_channel(acdev->dma_chan);
+        }
+        cf_exit(acdev);
+        return ata_host_suspend(host, PMSG_SUSPEND);
+}
+
+static int arasan_cf_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        struct arasan_cf_dev *acdev = host->ports[0]->private_data;
+
+        cf_init(acdev);
+        ata_host_resume(host);
+
+        return 0;
+}
+
+static const struct dev_pm_ops arasan_cf_pm_ops = {
+        .suspend        = arasan_cf_suspend,
+        .resume         = arasan_cf_resume,
+};
+#endif
+
+static struct platform_driver arasan_cf_driver = {
+        .probe          = arasan_cf_probe,
+        .remove         = __devexit_p(arasan_cf_remove),
+        .driver         = {
+                .name   = DRIVER_NAME,
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm             = &arasan_cf_pm_ops,
+#endif
+        },
+};
+
+static int __init arasan_cf_init(void)
+{
+        return platform_driver_register(&arasan_cf_driver);
+}
+module_init(arasan_cf_init);
+
+static void __exit arasan_cf_exit(void)
+{
+        platform_driver_unregister(&arasan_cf_driver);
+}
+module_exit(arasan_cf_exit);
+
+MODULE_AUTHOR("Viresh Kumar <viresh.kumar@st.com>");
+MODULE_DESCRIPTION("Arasan ATA Compact Flash driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/ata/pata_at32.c b/drivers/ata/pata_at32.c
index 66ce6a526f27..36f189c7ee8c 100644
--- a/drivers/ata/pata_at32.c
+++ b/drivers/ata/pata_at32.c
@@ -194,7 +194,7 @@ static int __init pata_at32_init_one(struct device *dev,
         /* Setup ATA bindings */
         ap->ops      = &at32_port_ops;
         ap->pio_mask = PIO_MASK;
-        ap->flags   |= ATA_FLAG_MMIO | ATA_FLAG_SLAVE_POSS;
+        ap->flags   |= ATA_FLAG_SLAVE_POSS;
 
         /*
          * Since all 8-bit taskfile transfers has to go on the lower
diff --git a/drivers/ata/pata_at91.c b/drivers/ata/pata_at91.c
index 0da0dcc7dd08..960c72571395 100644
--- a/drivers/ata/pata_at91.c
+++ b/drivers/ata/pata_at91.c
@@ -3,6 +3,7 @@
  * with CompactFlash interface in True IDE mode
  *
  * Copyright (C) 2009 Matyukevich Sergey
+ *               2011 Igor Plyatov
  *
  * Based on:
  *      * generic platform driver by Paul Mundt: drivers/ata/pata_platform.c
@@ -31,26 +32,149 @@
 #include <mach/board.h>
 #include <mach/gpio.h>
 
+#define DRV_NAME                "pata_at91"
+#define DRV_VERSION             "0.3"
 
-#define DRV_NAME "pata_at91"
-#define DRV_VERSION "0.1"
-
-#define CF_IDE_OFFSET       0x00c00000
-#define CF_ALT_IDE_OFFSET   0x00e00000
-#define CF_IDE_RES_SIZE     0x08
+#define CF_IDE_OFFSET           0x00c00000
+#define CF_ALT_IDE_OFFSET       0x00e00000
+#define CF_IDE_RES_SIZE         0x08
+#define CS_PULSE_MAXIMUM        319
+#define ER_SMC_CALC             1
+#define ER_SMC_RECALC           2
 
 struct at91_ide_info {
         unsigned long mode;
         unsigned int cs;
-
         struct clk *mck;
-
         void __iomem *ide_addr;
         void __iomem *alt_addr;
 };
 
-static const struct ata_timing initial_timing =
-        {XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0};
+/**
+ * struct smc_range - range of valid values for SMC register.
+ */
+struct smc_range {
+        int min;
+        int max;
+};
+
+/**
+ * adjust_smc_value - adjust value for one of SMC registers.
+ * @value: adjusted value
+ * @range: array of SMC ranges with valid values
+ * @size: SMC ranges array size
+ *
+ * This returns the difference between input and output value or negative
+ * in case of invalid input value.
+ * If negative returned, then output value = maximal possible from ranges.
+ */
+static int adjust_smc_value(int *value, struct smc_range *range, int size)
+{
+        int maximum = (range + size - 1)->max;
+        int remainder;
+
+        do {
+                if (*value < range->min) {
+                        remainder = range->min - *value;
+                        *value = range->min; /* nearest valid value */
+                        return remainder;
+                } else if ((range->min <= *value) && (*value <= range->max))
+                        return 0;
+
+                range++;
+        } while (--size);
+        *value = maximum;
+
+        return -1; /* invalid value */
+}
+
+/**
+ * calc_smc_vals - calculate SMC register values
+ * @dev: ATA device
+ * @setup: SMC_SETUP register value
+ * @pulse: SMC_PULSE register value
+ * @cycle: SMC_CYCLE register value
+ *
+ * This returns negative in case of invalid values for SMC registers:
+ * -ER_SMC_RECALC - recalculation required for SMC values,
+ * -ER_SMC_CALC - calculation failed (invalid input values).
+ *
+ * SMC use special coding scheme, see "Coding and Range of Timing
+ * Parameters" table from AT91SAM9 datasheets.
+ *
+ *      SMC_SETUP = 128*setup[5] + setup[4:0]
+ *      SMC_PULSE = 256*pulse[6] + pulse[5:0]
+ *      SMC_CYCLE = 256*cycle[8:7] + cycle[6:0]
+ */
+static int calc_smc_vals(struct device *dev,
+                int *setup, int *pulse, int *cycle, int *cs_pulse)
+{
+        int ret_val;
+        int err = 0;
+        struct smc_range range_setup[] = {      /* SMC_SETUP valid values */
+                {.min = 0,      .max = 31},     /* first  range */
+                {.min = 128,    .max = 159}     /* second range */
+        };
+        struct smc_range range_pulse[] = {      /* SMC_PULSE valid values */
+                {.min = 0,      .max = 63},     /* first  range */
+                {.min = 256,    .max = 319}     /* second range */
+        };
+        struct smc_range range_cycle[] = {      /* SMC_CYCLE valid values */
+                {.min = 0,      .max = 127},    /* first  range */
+                {.min = 256,    .max = 383},    /* second range */
+                {.min = 512,    .max = 639},    /* third  range */
+                {.min = 768,    .max = 895}     /* fourth range */
+        };
+
+        ret_val = adjust_smc_value(setup, range_setup, ARRAY_SIZE(range_setup));
+        if (ret_val < 0)
+                dev_warn(dev, "maximal SMC Setup value\n");
+        else
+                *cycle += ret_val;
+
+        ret_val = adjust_smc_value(pulse, range_pulse, ARRAY_SIZE(range_pulse));
+        if (ret_val < 0)
+                dev_warn(dev, "maximal SMC Pulse value\n");
+        else
+                *cycle += ret_val;
+
+        ret_val = adjust_smc_value(cycle, range_cycle, ARRAY_SIZE(range_cycle));
+        if (ret_val < 0)
+                dev_warn(dev, "maximal SMC Cycle value\n");
+
+        *cs_pulse = *cycle;
+        if (*cs_pulse > CS_PULSE_MAXIMUM) {
+                dev_err(dev, "unable to calculate valid SMC settings\n");
+                return -ER_SMC_CALC;
+        }
+
+        ret_val = adjust_smc_value(cs_pulse, range_pulse,
+                                        ARRAY_SIZE(range_pulse));
+        if (ret_val < 0) {
+                dev_warn(dev, "maximal SMC CS Pulse value\n");
+        } else if (ret_val != 0) {
+                *cycle = *cs_pulse;
+                dev_warn(dev, "SMC Cycle extended\n");
+                err = -ER_SMC_RECALC;
+        }
+
+        return err;
+}
+
+/**
+ * to_smc_format - convert values into SMC format
+ * @setup: SETUP value of SMC Setup Register
+ * @pulse: PULSE value of SMC Pulse Register
+ * @cycle: CYCLE value of SMC Cycle Register
+ * @cs_pulse: NCS_PULSE value of SMC Pulse Register
+ */
+static void to_smc_format(int *setup, int *pulse, int *cycle, int *cs_pulse)
+{
+        *setup = (*setup & 0x1f) | ((*setup & 0x80) >> 2);
+        *pulse = (*pulse & 0x3f) | ((*pulse & 0x100) >> 2);
+        *cycle = (*cycle & 0x7f) | ((*cycle & 0x300) >> 1);
+        *cs_pulse = (*cs_pulse & 0x3f) | ((*cs_pulse & 0x100) >> 2);
+}
 
 static unsigned long calc_mck_cycles(unsigned long ns, unsigned long mck_hz)
 {
@@ -69,80 +193,77 @@ static unsigned long calc_mck_cycles(unsigned long ns, unsigned long mck_hz)
         return (ns * mul + 65536) >> 16;    /* rounding */
 }
 
-static void set_smc_mode(struct at91_ide_info *info)
-{
-        at91_sys_write(AT91_SMC_MODE(info->cs), info->mode);
-        return;
-}
-
-static void set_smc_timing(struct device *dev,
+/**
+ * set_smc_timing - SMC timings setup.
+ * @dev: device
+ * @info: AT91 IDE info
+ * @ata: ATA timings
+ *
+ * Its assumed that write timings are same as read timings,
+ * cs_setup = 0 and cs_pulse = cycle.
+ */
+static void set_smc_timing(struct device *dev, struct ata_device *adev,
                 struct at91_ide_info *info, const struct ata_timing *ata)
 {
-        unsigned long read_cycle, write_cycle, active, recover;
-        unsigned long nrd_setup, nrd_pulse, nrd_recover;
-        unsigned long nwe_setup, nwe_pulse;
-
-        unsigned long ncs_write_setup, ncs_write_pulse;
-        unsigned long ncs_read_setup, ncs_read_pulse;
-
-        unsigned long mck_hz;
-
-        read_cycle  = ata->cyc8b;
-        nrd_setup   = ata->setup;
-        nrd_pulse   = ata->act8b;
-        nrd_recover = ata->rec8b;
-
+        int ret = 0;
+        int use_iordy;
+        unsigned int t6z;         /* data tristate time in ns */
+        unsigned int cycle;       /* SMC Cycle width in MCK ticks */
+        unsigned int setup;       /* SMC Setup width in MCK ticks */
+        unsigned int pulse;       /* CFIOR and CFIOW pulse width in MCK ticks */
+        unsigned int cs_setup = 0;/* CS4 or CS5 setup width in MCK ticks */
+        unsigned int cs_pulse;    /* CS4 or CS5 pulse width in MCK ticks*/
+        unsigned int tdf_cycles;  /* SMC TDF MCK ticks */
+        unsigned long mck_hz;     /* MCK frequency in Hz */
+
+        t6z = (ata->mode < XFER_PIO_5) ? 30 : 20;
         mck_hz = clk_get_rate(info->mck);
+        cycle = calc_mck_cycles(ata->cyc8b, mck_hz);
+        setup = calc_mck_cycles(ata->setup, mck_hz);
+        pulse = calc_mck_cycles(ata->act8b, mck_hz);
+        tdf_cycles = calc_mck_cycles(t6z, mck_hz);
+
+        do {
+                ret = calc_smc_vals(dev, &setup, &pulse, &cycle, &cs_pulse);
+        } while (ret == -ER_SMC_RECALC);
+
+        if (ret == -ER_SMC_CALC)
+                dev_err(dev, "Interface may not operate correctly\n");
+
+        dev_dbg(dev, "SMC Setup=%u, Pulse=%u, Cycle=%u, CS Pulse=%u\n",
+                setup, pulse, cycle, cs_pulse);
+        to_smc_format(&setup, &pulse, &cycle, &cs_pulse);
+        /* disable or enable waiting for IORDY signal */
+        use_iordy = ata_pio_need_iordy(adev);
+        if (use_iordy)
+                info->mode |= AT91_SMC_EXNWMODE_READY;
+
+        if (tdf_cycles > 15) {
+                tdf_cycles = 15;
+                dev_warn(dev, "maximal SMC TDF Cycles value\n");
+        }
 
-        read_cycle  = calc_mck_cycles(read_cycle, mck_hz);
-        nrd_setup   = calc_mck_cycles(nrd_setup, mck_hz);
-        nrd_pulse   = calc_mck_cycles(nrd_pulse, mck_hz);
-        nrd_recover = calc_mck_cycles(nrd_recover, mck_hz);
-
-        active  = nrd_setup + nrd_pulse;
-        recover = read_cycle - active;
-
-        /* Need at least two cycles recovery */
-        if (recover < 2)
-                read_cycle = active + 2;
-
-        /* (CS0, CS1, DIR, OE) <= (CFCE1, CFCE2, CFRNW, NCSX) timings */
-        ncs_read_setup = 1;
-        ncs_read_pulse = read_cycle - 2;
-
-        /* Write timings same as read timings */
-        write_cycle = read_cycle;
-        nwe_setup = nrd_setup;
-        nwe_pulse = nrd_pulse;
-        ncs_write_setup = ncs_read_setup;
-        ncs_write_pulse = ncs_read_pulse;
-
-        dev_dbg(dev, "ATA timings: nrd_setup = %lu nrd_pulse = %lu nrd_cycle = %lu\n",
-                        nrd_setup, nrd_pulse, read_cycle);
-        dev_dbg(dev, "ATA timings: nwe_setup = %lu nwe_pulse = %lu nwe_cycle = %lu\n",
-                        nwe_setup, nwe_pulse, write_cycle);
-        dev_dbg(dev, "ATA timings: ncs_read_setup = %lu ncs_read_pulse = %lu\n",
-                        ncs_read_setup, ncs_read_pulse);
-        dev_dbg(dev, "ATA timings: ncs_write_setup = %lu ncs_write_pulse = %lu\n",
-                        ncs_write_setup, ncs_write_pulse);
+        dev_dbg(dev, "Use IORDY=%u, TDF Cycles=%u\n", use_iordy, tdf_cycles);
+        info->mode |= AT91_SMC_TDF_(tdf_cycles);
 
+        /* write SMC Setup Register */
         at91_sys_write(AT91_SMC_SETUP(info->cs),
-                        AT91_SMC_NWESETUP_(nwe_setup) |
-                        AT91_SMC_NRDSETUP_(nrd_setup) |
-                        AT91_SMC_NCS_WRSETUP_(ncs_write_setup) |
-                        AT91_SMC_NCS_RDSETUP_(ncs_read_setup));
-
+                        AT91_SMC_NWESETUP_(setup) |
+                        AT91_SMC_NRDSETUP_(setup) |
+                        AT91_SMC_NCS_WRSETUP_(cs_setup) |
+                        AT91_SMC_NCS_RDSETUP_(cs_setup));
+        /* write SMC Pulse Register */
         at91_sys_write(AT91_SMC_PULSE(info->cs),
-                        AT91_SMC_NWEPULSE_(nwe_pulse) |
-                        AT91_SMC_NRDPULSE_(nrd_pulse) |
-                        AT91_SMC_NCS_WRPULSE_(ncs_write_pulse) |
-                        AT91_SMC_NCS_RDPULSE_(ncs_read_pulse));
-
+                        AT91_SMC_NWEPULSE_(pulse) |
+                        AT91_SMC_NRDPULSE_(pulse) |
+                        AT91_SMC_NCS_WRPULSE_(cs_pulse) |
+                        AT91_SMC_NCS_RDPULSE_(cs_pulse));
+        /* write SMC Cycle Register */
         at91_sys_write(AT91_SMC_CYCLE(info->cs),
-                        AT91_SMC_NWECYCLE_(write_cycle) |
-                        AT91_SMC_NRDCYCLE_(read_cycle));
-
-        return;
+                        AT91_SMC_NWECYCLE_(cycle) |
+                        AT91_SMC_NRDCYCLE_(cycle));
+        /* write SMC Mode Register*/
+        at91_sys_write(AT91_SMC_MODE(info->cs), info->mode);
 }
 
 static void pata_at91_set_piomode(struct ata_port *ap, struct ata_device *adev)
@@ -156,15 +277,9 @@ static void pata_at91_set_piomode(struct ata_port *ap, struct ata_device *adev)
         if (ret) {
                 dev_warn(ap->dev, "Failed to compute ATA timing %d, "
                          "set PIO_0 timing\n", ret);
-                set_smc_timing(ap->dev, info, &initial_timing);
-        } else {
-                set_smc_timing(ap->dev, info, &timing);
+                timing = *ata_timing_find_mode(XFER_PIO_0);
         }
-
-        /* Setup SMC mode */
-        set_smc_mode(info);
-
-        return;
+        set_smc_timing(ap->dev, adev, info, &timing);
 }
 
 static unsigned int pata_at91_data_xfer_noirq(struct ata_device *dev,
@@ -330,7 +445,7 @@ static int __devexit pata_at91_remove(struct platform_device *pdev)
 static struct platform_driver pata_at91_driver = {
         .probe          = pata_at91_probe,
         .remove         = __devexit_p(pata_at91_remove),
-        .driver         = {
+        .driver         = {
                 .name           = DRV_NAME,
                 .owner          = THIS_MODULE,
         },
diff --git a/drivers/ata/pata_bf54x.c b/drivers/ata/pata_bf54x.c
index 9cae65de750e..ea64967000ff 100644
--- a/drivers/ata/pata_bf54x.c
+++ b/drivers/ata/pata_bf54x.c
@@ -826,7 +826,7 @@ static void bfin_dev_select(struct ata_port *ap, unsigned int device)
  *      @ctl: value to write
  */
 
-static u8 bfin_set_devctl(struct ata_port *ap, u8 ctl)
+static void bfin_set_devctl(struct ata_port *ap, u8 ctl)
 {
         void __iomem *base = (void __iomem *)ap->ioaddr.ctl_addr;
         write_atapi_register(base, ATA_REG_CTRL, ctl);
@@ -1046,7 +1046,7 @@ static void bfin_bus_post_reset(struct ata_port *ap, unsigned int devmask)
                         dev1 = 0;
                         break;
                 }
-                msleep(50);     /* give drive a breather */
+                ata_msleep(ap, 50);     /* give drive a breather */
         }
         if (dev1)
                 ata_sff_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
@@ -1087,7 +1087,7 @@ static unsigned int bfin_bus_softreset(struct ata_port *ap,
          *
          * Old drivers/ide uses the 2mS rule and then waits for ready
          */
-        msleep(150);
+        ata_msleep(ap, 150);
 
         /* Before we perform post reset processing we want to see if
          * the bus shows 0xFF because the odd clown forgets the D7
@@ -1342,7 +1342,7 @@ static unsigned int bfin_ata_host_intr(struct ata_port *ap,
                         ap->ops->bmdma_stop(qc);
 
                         if (unlikely(host_stat & ATA_DMA_ERR)) {
-                                /* error when transfering data to/from memory */
+                                /* error when transferring data to/from memory */
                                 qc->err_mask |= AC_ERR_HOST_BUS;
                                 ap->hsm_task_state = HSM_ST_ERR;
                         }
@@ -1454,9 +1454,7 @@ static struct ata_port_operations bfin_pata_ops = {
 
 static struct ata_port_info bfin_port_info[] = {
         {
-                .flags          = ATA_FLAG_SLAVE_POSS
-                                | ATA_FLAG_MMIO
-                                | ATA_FLAG_NO_LEGACY,
+                .flags          = ATA_FLAG_SLAVE_POSS,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = 0,
                 .udma_mask      = 0,
@@ -1588,7 +1586,7 @@ static int __devinit bfin_atapi_probe(struct platform_device *pdev)
         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");
+                dev_err(&pdev->dev, "Requesting Peripherals failed\n");
                 return -EFAULT;
         }
 
diff --git a/drivers/ata/pata_cmd640.c b/drivers/ata/pata_cmd640.c
index e5f289f59ca3..549d28dbf90d 100644
--- a/drivers/ata/pata_cmd640.c
+++ b/drivers/ata/pata_cmd640.c
@@ -161,6 +161,17 @@ static int cmd640_port_start(struct ata_port *ap)
         return 0;
 }
 
+static bool cmd640_sff_irq_check(struct ata_port *ap)
+{
+        struct pci_dev *pdev    = to_pci_dev(ap->host->dev);
+        int irq_reg             = ap->port_no ? ARTIM23 : CFR;
+        u8  irq_stat, irq_mask  = ap->port_no ? 0x10 : 0x04;
+
+        pci_read_config_byte(pdev, irq_reg, &irq_stat);
+
+        return irq_stat & irq_mask;
+}
+
 static struct scsi_host_template cmd640_sht = {
         ATA_PIO_SHT(DRV_NAME),
 };
@@ -169,6 +180,7 @@ static struct ata_port_operations cmd640_port_ops = {
         .inherits       = &ata_sff_port_ops,
         /* In theory xfer_noirq is not needed once we kill the prefetcher */
         .sff_data_xfer  = ata_sff_data_xfer_noirq,
+        .sff_irq_check  = cmd640_sff_irq_check,
         .qc_issue       = cmd640_qc_issue,
         .cable_detect   = ata_cable_40wire,
         .set_piomode    = cmd640_set_piomode,
diff --git a/drivers/ata/pata_cmd64x.c b/drivers/ata/pata_cmd64x.c
index 905ff76d3cbb..7bafc16cf5e0 100644
--- a/drivers/ata/pata_cmd64x.c
+++ b/drivers/ata/pata_cmd64x.c
@@ -41,6 +41,9 @@
 enum {
         CFR             = 0x50,
                 CFR_INTR_CH0  = 0x04,
+        CNTRL           = 0x51,
+                CNTRL_CH0     = 0x04,
+                CNTRL_CH1     = 0x08,
         CMDTIM          = 0x52,
         ARTTIM0         = 0x53,
         DRWTIM0         = 0x54,
@@ -328,9 +331,19 @@ static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                         .port_ops = &cmd648_port_ops
                 }
         };
-        const struct ata_port_info *ppi[] = { &cmd_info[id->driver_data], NULL };
-        u8 mrdmode;
+        const struct ata_port_info *ppi[] = { 
+                &cmd_info[id->driver_data],
+                &cmd_info[id->driver_data],
+                NULL
+        };
+        u8 mrdmode, reg;
         int rc;
+        struct pci_dev *bridge = pdev->bus->self;
+        /* mobility split bridges don't report enabled ports correctly */
+        int port_ok = !(bridge && bridge->vendor ==
+                        PCI_VENDOR_ID_MOBILITY_ELECTRONICS);
+        /* all (with exceptions below) apart from 643 have CNTRL_CH0 bit */
+        int cntrl_ch0_ok = (id->driver_data != 0);
 
         rc = pcim_enable_device(pdev);
         if (rc)
@@ -341,11 +354,18 @@ static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
         if (pdev->device == PCI_DEVICE_ID_CMD_646) {
                 /* Does UDMA work ? */
-                if (pdev->revision > 4)
+                if (pdev->revision > 4) {
                         ppi[0] = &cmd_info[2];
+                        ppi[1] = &cmd_info[2];
+                }
                 /* Early rev with other problems ? */
-                else if (pdev->revision == 1)
+                else if (pdev->revision == 1) {
                         ppi[0] = &cmd_info[3];
+                        ppi[1] = &cmd_info[3];
+                }
+                /* revs 1,2 have no CNTRL_CH0 */
+                if (pdev->revision < 3)
+                        cntrl_ch0_ok = 0;
         }
 
         pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
@@ -354,6 +374,20 @@ static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         mrdmode |= 0x02;        /* Memory read line enable */
         pci_write_config_byte(pdev, MRDMODE, mrdmode);
 
+        /* check for enabled ports */
+        pci_read_config_byte(pdev, CNTRL, &reg);
+        if (!port_ok)
+                dev_printk(KERN_NOTICE, &pdev->dev, "Mobility Bridge detected, ignoring CNTRL port enable/disable\n");
+        if (port_ok && cntrl_ch0_ok && !(reg & CNTRL_CH0)) {
+                dev_printk(KERN_NOTICE, &pdev->dev, "Primary port is disabled\n");
+                ppi[0] = &ata_dummy_port_info;
+                
+        }
+        if (port_ok && !(reg & CNTRL_CH1)) {
+                dev_printk(KERN_NOTICE, &pdev->dev, "Secondary port is disabled\n");
+                ppi[1] = &ata_dummy_port_info;
+        }
+
         /* Force PIO 0 here.. */
 
         /* PPC specific fixup copied from old driver */
diff --git a/drivers/ata/pata_cs5520.c b/drivers/ata/pata_cs5520.c
index 030952f1f97c..e3254fcff0f1 100644
--- a/drivers/ata/pata_cs5520.c
+++ b/drivers/ata/pata_cs5520.c
@@ -29,7 +29,7 @@
  * General Public License for more details.
  *
  * Documentation:
- *      Not publically available.
+ *      Not publicly available.
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
diff --git a/drivers/ata/pata_cs5536.c b/drivers/ata/pata_cs5536.c
index 21ee23f89e88..628c8fae5937 100644
--- a/drivers/ata/pata_cs5536.c
+++ b/drivers/ata/pata_cs5536.c
@@ -37,10 +37,22 @@
 #include <linux/delay.h>
 #include <linux/libata.h>
 #include <scsi/scsi_host.h>
+
+#ifdef CONFIG_X86_32
 #include <asm/msr.h>
+static int use_msr;
+module_param_named(msr, use_msr, int, 0644);
+MODULE_PARM_DESC(msr, "Force using MSR to configure IDE function (Default: 0)");
+#else
+#undef rdmsr    /* avoid accidental MSR usage on, e.g. x86-64 */
+#undef wrmsr
+#define rdmsr(x, y, z) do { } while (0)
+#define wrmsr(x, y, z) do { } while (0)
+#define use_msr 0
+#endif
 
 #define DRV_NAME        "pata_cs5536"
-#define DRV_VERSION     "0.0.7"
+#define DRV_VERSION     "0.0.8"
 
 enum {
         CFG                     = 0,
@@ -75,8 +87,6 @@ enum {
         IDE_ETC_NODMA           = 0x03,
 };
 
-static int use_msr;
-
 static const u32 msr_reg[4] = {
         MSR_IDE_CFG, MSR_IDE_DTC, MSR_IDE_CAST, MSR_IDE_ETC,
 };
@@ -88,7 +98,7 @@ static const u8 pci_reg[4] = {
 static inline int cs5536_read(struct pci_dev *pdev, int reg, u32 *val)
 {
         if (unlikely(use_msr)) {
-                u32 dummy;
+                u32 dummy __maybe_unused;
 
                 rdmsr(msr_reg[reg], *val, dummy);
                 return 0;
@@ -294,8 +304,6 @@ MODULE_DESCRIPTION("low-level driver for the CS5536 IDE controller");
 MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, cs5536);
 MODULE_VERSION(DRV_VERSION);
-module_param_named(msr, use_msr, int, 0644);
-MODULE_PARM_DESC(msr, "Force using MSR to configure IDE function (Default: 0)");
 
 module_init(cs5536_init);
 module_exit(cs5536_exit);
diff --git a/drivers/ata/pata_hpt366.c b/drivers/ata/pata_hpt366.c
index 7688868557b9..6c77d68dbd05 100644
--- a/drivers/ata/pata_hpt366.c
+++ b/drivers/ata/pata_hpt366.c
@@ -14,6 +14,7 @@
  *      Look into engine reset on timeout errors. Should not be required.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -25,7 +26,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME        "pata_hpt366"
-#define DRV_VERSION     "0.6.8"
+#define DRV_VERSION     "0.6.11"
 
 struct hpt_clock {
         u8      xfer_mode;
@@ -110,18 +111,23 @@ static const struct hpt_clock hpt366_25[] = {
         {       0,              0x01208585      }
 };
 
-static const char *bad_ata33[] = {
-        "Maxtor 92720U8", "Maxtor 92040U6", "Maxtor 91360U4", "Maxtor 91020U3", "Maxtor 90845U3", "Maxtor 90650U2",
-        "Maxtor 91360D8", "Maxtor 91190D7", "Maxtor 91020D6", "Maxtor 90845D5", "Maxtor 90680D4", "Maxtor 90510D3", "Maxtor 90340D2",
-        "Maxtor 91152D8", "Maxtor 91008D7", "Maxtor 90845D6", "Maxtor 90840D6", "Maxtor 90720D5", "Maxtor 90648D5", "Maxtor 90576D4",
+static const char * const bad_ata33[] = {
+        "Maxtor 92720U8", "Maxtor 92040U6", "Maxtor 91360U4", "Maxtor 91020U3",
+        "Maxtor 90845U3", "Maxtor 90650U2",
+        "Maxtor 91360D8", "Maxtor 91190D7", "Maxtor 91020D6", "Maxtor 90845D5",
+        "Maxtor 90680D4", "Maxtor 90510D3", "Maxtor 90340D2",
+        "Maxtor 91152D8", "Maxtor 91008D7", "Maxtor 90845D6", "Maxtor 90840D6",
+        "Maxtor 90720D5", "Maxtor 90648D5", "Maxtor 90576D4",
         "Maxtor 90510D4",
         "Maxtor 90432D3", "Maxtor 90288D2", "Maxtor 90256D2",
-        "Maxtor 91000D8", "Maxtor 90910D8", "Maxtor 90875D7", "Maxtor 90840D7", "Maxtor 90750D6", "Maxtor 90625D5", "Maxtor 90500D4",
-        "Maxtor 91728D8", "Maxtor 91512D7", "Maxtor 91303D6", "Maxtor 91080D5", "Maxtor 90845D4", "Maxtor 90680D4", "Maxtor 90648D3", "Maxtor 90432D2",
+        "Maxtor 91000D8", "Maxtor 90910D8", "Maxtor 90875D7", "Maxtor 90840D7",
+        "Maxtor 90750D6", "Maxtor 90625D5", "Maxtor 90500D4",
+        "Maxtor 91728D8", "Maxtor 91512D7", "Maxtor 91303D6", "Maxtor 91080D5",
+        "Maxtor 90845D4", "Maxtor 90680D4", "Maxtor 90648D3", "Maxtor 90432D2",
         NULL
 };
 
-static const char *bad_ata66_4[] = {
+static const char * const bad_ata66_4[] = {
         "IBM-DTLA-307075",
         "IBM-DTLA-307060",
         "IBM-DTLA-307045",
@@ -140,12 +146,13 @@ static const char *bad_ata66_4[] = {
         NULL
 };
 
-static const char *bad_ata66_3[] = {
+static const char * const bad_ata66_3[] = {
         "WDC AC310200R",
         NULL
 };
 
-static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr, const char *list[])
+static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr,
+                               const char * const list[])
 {
         unsigned char model_num[ATA_ID_PROD_LEN + 1];
         int i = 0;
@@ -154,7 +161,7 @@ static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr, cons
 
         while (list[i] != NULL) {
                 if (!strcmp(list[i], model_num)) {
-                        printk(KERN_WARNING DRV_NAME ": %s is not supported for %s.\n",
+                        pr_warn("%s is not supported for %s\n",
                                 modestr, list[i]);
                         return 1;
                 }
@@ -288,6 +295,7 @@ static struct ata_port_operations hpt366_port_ops = {
 static void hpt36x_init_chipset(struct pci_dev *dev)
 {
         u8 drive_fast;
+
         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, (L1_CACHE_BYTES / 4));
         pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x78);
         pci_write_config_byte(dev, PCI_MIN_GNT, 0x08);
@@ -349,16 +357,16 @@ static int hpt36x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 
         /* PCI clocking determines the ATA timing values to use */
         /* info_hpt366 is safe against re-entry so we can scribble on it */
-        switch((reg1 & 0x700) >> 8) {
-                case 9:
-                        hpriv = &hpt366_40;
-                        break;
-                case 5:
-                        hpriv = &hpt366_25;
-                        break;
-                default:
-                        hpriv = &hpt366_33;
-                        break;
+        switch ((reg1 & 0x700) >> 8) {
+        case 9:
+                hpriv = &hpt366_40;
+                break;
+        case 5:
+                hpriv = &hpt366_25;
+                break;
+        default:
+                hpriv = &hpt366_33;
+                break;
         }
         /* Now kick off ATA set up */
         return ata_pci_bmdma_init_one(dev, ppi, &hpt36x_sht, hpriv, 0);
@@ -385,9 +393,9 @@ static const struct pci_device_id hpt36x[] = {
 };
 
 static struct pci_driver hpt36x_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
         .id_table       = hpt36x,
-        .probe          = hpt36x_init_one,
+        .probe          = hpt36x_init_one,
         .remove         = ata_pci_remove_one,
 #ifdef CONFIG_PM
         .suspend        = ata_pci_device_suspend,
diff --git a/drivers/ata/pata_hpt37x.c b/drivers/ata/pata_hpt37x.c
index 9ae4c0830577..9620636aa405 100644
--- a/drivers/ata/pata_hpt37x.c
+++ b/drivers/ata/pata_hpt37x.c
@@ -8,12 +8,14 @@
  * Copyright (C) 1999-2003              Andre Hedrick <andre@linux-ide.org>
  * Portions Copyright (C) 2001          Sun Microsystems, Inc.
  * Portions Copyright (C) 2003          Red Hat Inc
- * Portions Copyright (C) 2005-2009     MontaVista Software, Inc.
+ * Portions Copyright (C) 2005-2010     MontaVista Software, Inc.
  *
  * TODO
  *      Look into engine reset on timeout errors. Should not be required.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/pci.h>
@@ -24,7 +26,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME        "pata_hpt37x"
-#define DRV_VERSION     "0.6.15"
+#define DRV_VERSION     "0.6.23"
 
 struct hpt_clock {
         u8      xfer_speed;
@@ -210,7 +212,7 @@ static u32 hpt37x_find_mode(struct ata_port *ap, int speed)
 {
         struct hpt_clock *clocks = ap->host->private_data;
 
-        while(clocks->xfer_speed) {
+        while (clocks->xfer_speed) {
                 if (clocks->xfer_speed == speed)
                         return clocks->timing;
                 clocks++;
@@ -219,7 +221,8 @@ static u32 hpt37x_find_mode(struct ata_port *ap, int speed)
         return 0xffffffffU;     /* silence compiler warning */
 }
 
-static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr, const char *list[])
+static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr,
+                               const char * const list[])
 {
         unsigned char model_num[ATA_ID_PROD_LEN + 1];
         int i = 0;
@@ -228,7 +231,7 @@ static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr, cons
 
         while (list[i] != NULL) {
                 if (!strcmp(list[i], model_num)) {
-                        printk(KERN_WARNING DRV_NAME ": %s is not supported for %s.\n",
+                        pr_warn("%s is not supported for %s\n",
                                 modestr, list[i]);
                         return 1;
                 }
@@ -237,18 +240,23 @@ static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr, cons
         return 0;
 }
 
-static const char *bad_ata33[] = {
-        "Maxtor 92720U8", "Maxtor 92040U6", "Maxtor 91360U4", "Maxtor 91020U3", "Maxtor 90845U3", "Maxtor 90650U2",
-        "Maxtor 91360D8", "Maxtor 91190D7", "Maxtor 91020D6", "Maxtor 90845D5", "Maxtor 90680D4", "Maxtor 90510D3", "Maxtor 90340D2",
-        "Maxtor 91152D8", "Maxtor 91008D7", "Maxtor 90845D6", "Maxtor 90840D6", "Maxtor 90720D5", "Maxtor 90648D5", "Maxtor 90576D4",
+static const char * const bad_ata33[] = {
+        "Maxtor 92720U8", "Maxtor 92040U6", "Maxtor 91360U4", "Maxtor 91020U3",
+        "Maxtor 90845U3", "Maxtor 90650U2",
+        "Maxtor 91360D8", "Maxtor 91190D7", "Maxtor 91020D6", "Maxtor 90845D5",
+        "Maxtor 90680D4", "Maxtor 90510D3", "Maxtor 90340D2",
+        "Maxtor 91152D8", "Maxtor 91008D7", "Maxtor 90845D6", "Maxtor 90840D6",
+        "Maxtor 90720D5", "Maxtor 90648D5", "Maxtor 90576D4",
         "Maxtor 90510D4",
         "Maxtor 90432D3", "Maxtor 90288D2", "Maxtor 90256D2",
-        "Maxtor 91000D8", "Maxtor 90910D8", "Maxtor 90875D7", "Maxtor 90840D7", "Maxtor 90750D6", "Maxtor 90625D5", "Maxtor 90500D4",
-        "Maxtor 91728D8", "Maxtor 91512D7", "Maxtor 91303D6", "Maxtor 91080D5", "Maxtor 90845D4", "Maxtor 90680D4", "Maxtor 90648D3", "Maxtor 90432D2",
+        "Maxtor 91000D8", "Maxtor 90910D8", "Maxtor 90875D7", "Maxtor 90840D7",
+        "Maxtor 90750D6", "Maxtor 90625D5", "Maxtor 90500D4",
+        "Maxtor 91728D8", "Maxtor 91512D7", "Maxtor 91303D6", "Maxtor 91080D5",
+        "Maxtor 90845D4", "Maxtor 90680D4", "Maxtor 90648D3", "Maxtor 90432D2",
         NULL
 };
 
-static const char *bad_ata100_5[] = {
+static const char * const bad_ata100_5[] = {
         "IBM-DTLA-307075",
         "IBM-DTLA-307060",
         "IBM-DTLA-307045",
@@ -302,6 +310,22 @@ static unsigned long hpt370a_filter(struct ata_device *adev, unsigned long mask)
 }
 
 /**
+ *      hpt372_filter   -       mode selection filter
+ *      @adev: ATA device
+ *      @mask: mode mask
+ *
+ *      The Marvell bridge chips used on the HighPoint SATA cards do not seem
+ *      to support the UltraDMA modes 1, 2, and 3 as well as any MWDMA modes...
+ */
+static unsigned long hpt372_filter(struct ata_device *adev, unsigned long mask)
+{
+        if (ata_id_is_sata(adev->id))
+                mask &= ~((0xE << ATA_SHIFT_UDMA) | ATA_MASK_MWDMA);
+
+        return mask;
+}
+
+/**
  *      hpt37x_cable_detect     -       Detect the cable type
  *      @ap: ATA port to detect on
  *
@@ -373,6 +397,7 @@ static int hpt37x_pre_reset(struct ata_link *link, unsigned long deadline)
                 { 0x50, 1, 0x04, 0x04 },
                 { 0x54, 1, 0x04, 0x04 }
         };
+
         if (!pci_test_config_bits(pdev, &hpt37x_enable_bits[ap->port_no]))
                 return -ENOENT;
 
@@ -586,11 +611,11 @@ static struct ata_port_operations hpt370a_port_ops = {
 };
 
 /*
- *      Configuration for HPT372, HPT371, HPT302. Slightly different PIO
- *      and DMA mode setting functionality.
+ *      Configuration for HPT371 and HPT302. Slightly different PIO and DMA
+ *      mode setting functionality.
  */
 
-static struct ata_port_operations hpt372_port_ops = {
+static struct ata_port_operations hpt302_port_ops = {
         .inherits       = &ata_bmdma_port_ops,
 
         .bmdma_stop     = hpt37x_bmdma_stop,
@@ -602,14 +627,23 @@ static struct ata_port_operations hpt372_port_ops = {
 };
 
 /*
- *      Configuration for HPT374. Mode setting works like 372 and friends
+ *      Configuration for HPT372. Mode setting works like 371 and 302
+ *      but we have a mode filter.
+ */
+
+static struct ata_port_operations hpt372_port_ops = {
+        .inherits       = &hpt302_port_ops,
+        .mode_filter    = hpt372_filter,
+};
+
+/*
+ *      Configuration for HPT374. Mode setting and filtering works like 372
  *      but we have a different cable detection procedure for function 1.
  */
 
 static struct ata_port_operations hpt374_fn1_port_ops = {
         .inherits       = &hpt372_port_ops,
         .cable_detect   = hpt374_fn1_cable_detect,
-        .prereset       = hpt37x_pre_reset,
 };
 
 /**
@@ -647,12 +681,12 @@ static int hpt37x_calibrate_dpll(struct pci_dev *dev)
         u32 reg5c;
         int tries;
 
-        for(tries = 0; tries < 0x5000; tries++) {
+        for (tries = 0; tries < 0x5000; tries++) {
                 udelay(50);
                 pci_read_config_byte(dev, 0x5b, &reg5b);
                 if (reg5b & 0x80) {
                         /* See if it stays set */
-                        for(tries = 0; tries < 0x1000; tries ++) {
+                        for (tries = 0; tries < 0x1000; tries++) {
                                 pci_read_config_byte(dev, 0x5b, &reg5b);
                                 /* Failed ? */
                                 if ((reg5b & 0x80) == 0)
@@ -660,7 +694,7 @@ static int hpt37x_calibrate_dpll(struct pci_dev *dev)
                         }
                         /* Turn off tuning, we have the DPLL set */
                         pci_read_config_dword(dev, 0x5c, &reg5c);
-                        pci_write_config_dword(dev, 0x5c, reg5c & ~ 0x100);
+                        pci_write_config_dword(dev, 0x5c, reg5c & ~0x100);
                         return 1;
                 }
         }
@@ -672,6 +706,7 @@ static u32 hpt374_read_freq(struct pci_dev *pdev)
 {
         u32 freq;
         unsigned long io_base = pci_resource_start(pdev, 4);
+
         if (PCI_FUNC(pdev->devfn) & 1) {
                 struct pci_dev *pdev_0;
 
@@ -737,23 +772,23 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 .udma_mask = ATA_UDMA5,
                 .port_ops = &hpt370a_port_ops
         };
-        /* HPT370 - UDMA100 */
+        /* HPT370 - UDMA66 */
         static const struct ata_port_info info_hpt370_33 = {
                 .flags = ATA_FLAG_SLAVE_POSS,
                 .pio_mask = ATA_PIO4,
                 .mwdma_mask = ATA_MWDMA2,
-                .udma_mask = ATA_UDMA5,
+                .udma_mask = ATA_UDMA4,
                 .port_ops = &hpt370_port_ops
         };
-        /* HPT370A - UDMA100 */
+        /* HPT370A - UDMA66 */
         static const struct ata_port_info info_hpt370a_33 = {
                 .flags = ATA_FLAG_SLAVE_POSS,
                 .pio_mask = ATA_PIO4,
                 .mwdma_mask = ATA_MWDMA2,
-                .udma_mask = ATA_UDMA5,
+                .udma_mask = ATA_UDMA4,
                 .port_ops = &hpt370a_port_ops
         };
-        /* HPT371, 372 and friends - UDMA133 */
+        /* HPT372 - UDMA133 */
         static const struct ata_port_info info_hpt372 = {
                 .flags = ATA_FLAG_SLAVE_POSS,
                 .pio_mask = ATA_PIO4,
@@ -761,7 +796,15 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 .udma_mask = ATA_UDMA6,
                 .port_ops = &hpt372_port_ops
         };
-        /* HPT374 - UDMA100, function 1 uses different prereset method */
+        /* HPT371, 302 - UDMA133 */
+        static const struct ata_port_info info_hpt302 = {
+                .flags = ATA_FLAG_SLAVE_POSS,
+                .pio_mask = ATA_PIO4,
+                .mwdma_mask = ATA_MWDMA2,
+                .udma_mask = ATA_UDMA6,
+                .port_ops = &hpt302_port_ops
+        };
+        /* HPT374 - UDMA100, function 1 uses different cable_detect method */
         static const struct ata_port_info info_hpt374_fn0 = {
                 .flags = ATA_FLAG_SLAVE_POSS,
                 .pio_mask = ATA_PIO4,
@@ -796,7 +839,8 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         if (rc)
                 return rc;
 
-        if (dev->device == PCI_DEVICE_ID_TTI_HPT366) {
+        switch (dev->device) {
+        case PCI_DEVICE_ID_TTI_HPT366:
                 /* May be a later chip in disguise. Check */
                 /* Older chips are in the HPT366 driver. Ignore them */
                 if (rev < 3)
@@ -805,66 +849,65 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 if (rev == 6)
                         return -ENODEV;
 
-                switch(rev) {
-                        case 3:
-                                ppi[0] = &info_hpt370;
-                                chip_table = &hpt370;
-                                prefer_dpll = 0;
-                                break;
-                        case 4:
-                                ppi[0] = &info_hpt370a;
-                                chip_table = &hpt370a;
-                                prefer_dpll = 0;
-                                break;
-                        case 5:
-                                ppi[0] = &info_hpt372;
-                                chip_table = &hpt372;
-                                break;
-                        default:
-                                printk(KERN_ERR "pata_hpt37x: Unknown HPT366 "
-                                       "subtype, please report (%d).\n", rev);
-                                return -ENODEV;
-                }
-        } else {
-                switch(dev->device) {
-                        case PCI_DEVICE_ID_TTI_HPT372:
-                                /* 372N if rev >= 2*/
-                                if (rev >= 2)
-                                        return -ENODEV;
-                                ppi[0] = &info_hpt372;
-                                chip_table = &hpt372a;
-                                break;
-                        case PCI_DEVICE_ID_TTI_HPT302:
-                                /* 302N if rev > 1 */
-                                if (rev > 1)
-                                        return -ENODEV;
-                                ppi[0] = &info_hpt372;
-                                /* Check this */
-                                chip_table = &hpt302;
-                                break;
-                        case PCI_DEVICE_ID_TTI_HPT371:
-                                if (rev > 1)
-                                        return -ENODEV;
-                                ppi[0] = &info_hpt372;
-                                chip_table = &hpt371;
-                                /* Single channel device, master is not present
-                                   but the BIOS (or us for non x86) must mark it
-                                   absent */
-                                pci_read_config_byte(dev, 0x50, &mcr1);
-                                mcr1 &= ~0x04;
-                                pci_write_config_byte(dev, 0x50, mcr1);
-                                break;
-                        case PCI_DEVICE_ID_TTI_HPT374:
-                                chip_table = &hpt374;
-                                if (!(PCI_FUNC(dev->devfn) & 1))
-                                        *ppi = &info_hpt374_fn0;
-                                else
-                                        *ppi = &info_hpt374_fn1;
-                                break;
-                        default:
-                                printk(KERN_ERR "pata_hpt37x: PCI table is bogus please report (%d).\n", dev->device);
-                                return -ENODEV;
+                switch (rev) {
+                case 3:
+                        ppi[0] = &info_hpt370;
+                        chip_table = &hpt370;
+                        prefer_dpll = 0;
+                        break;
+                case 4:
+                        ppi[0] = &info_hpt370a;
+                        chip_table = &hpt370a;
+                        prefer_dpll = 0;
+                        break;
+                case 5:
+                        ppi[0] = &info_hpt372;
+                        chip_table = &hpt372;
+                        break;
+                default:
+                        pr_err("Unknown HPT366 subtype, please report (%d)\n",
+                               rev);
+                        return -ENODEV;
                 }
+                break;
+        case PCI_DEVICE_ID_TTI_HPT372:
+                /* 372N if rev >= 2 */
+                if (rev >= 2)
+                        return -ENODEV;
+                ppi[0] = &info_hpt372;
+                chip_table = &hpt372a;
+                break;
+        case PCI_DEVICE_ID_TTI_HPT302:
+                /* 302N if rev > 1 */
+                if (rev > 1)
+                        return -ENODEV;
+                ppi[0] = &info_hpt302;
+                /* Check this */
+                chip_table = &hpt302;
+                break;
+        case PCI_DEVICE_ID_TTI_HPT371:
+                if (rev > 1)
+                        return -ENODEV;
+                ppi[0] = &info_hpt302;
+                chip_table = &hpt371;
+                /*
+                 * Single channel device, master is not present but the BIOS
+                 * (or us for non x86) must mark it absent
+                 */
+                pci_read_config_byte(dev, 0x50, &mcr1);
+                mcr1 &= ~0x04;
+                pci_write_config_byte(dev, 0x50, mcr1);
+                break;
+        case PCI_DEVICE_ID_TTI_HPT374:
+                chip_table = &hpt374;
+                if (!(PCI_FUNC(dev->devfn) & 1))
+                        *ppi = &info_hpt374_fn0;
+                else
+                        *ppi = &info_hpt374_fn1;
+                break;
+        default:
+                pr_err("PCI table is bogus, please report (%d)\n", dev->device);
+                return -ENODEV;
         }
         /* Ok so this is a chip we support */
 
@@ -893,9 +936,11 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         if (chip_table == &hpt372a)
                 outb(0x0e, iobase + 0x9c);
 
-        /* Some devices do not let this value be accessed via PCI space
-           according to the old driver. In addition we must use the value
-           from FN 0 on the HPT374 */
+        /*
+         * Some devices do not let this value be accessed via PCI space
+         * according to the old driver. In addition we must use the value
+         * from FN 0 on the HPT374.
+         */
 
         if (chip_table == &hpt374) {
                 freq = hpt374_read_freq(dev);
@@ -909,10 +954,10 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 u8 sr;
                 u32 total = 0;
 
-                printk(KERN_WARNING "pata_hpt37x: BIOS has not set timing clocks.\n");
+                pr_warn("BIOS has not set timing clocks\n");
 
                 /* This is the process the HPT371 BIOS is reported to use */
-                for(i = 0; i < 128; i++) {
+                for (i = 0; i < 128; i++) {
                         pci_read_config_byte(dev, 0x78, &sr);
                         total += sr & 0x1FF;
                         udelay(15);
@@ -947,20 +992,25 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 
                 /* Select the DPLL clock. */
                 pci_write_config_byte(dev, 0x5b, 0x21);
-                pci_write_config_dword(dev, 0x5C, (f_high << 16) | f_low | 0x100);
+                pci_write_config_dword(dev, 0x5C,
+                                       (f_high << 16) | f_low | 0x100);
 
-                for(adjust = 0; adjust < 8; adjust++) {
+                for (adjust = 0; adjust < 8; adjust++) {
                         if (hpt37x_calibrate_dpll(dev))
                                 break;
-                        /* See if it'll settle at a fractionally different clock */
+                        /*
+                         * See if it'll settle at a fractionally
+                         * different clock
+                         */
                         if (adjust & 1)
                                 f_low -= adjust >> 1;
                         else
                                 f_high += adjust >> 1;
-                        pci_write_config_dword(dev, 0x5C, (f_high << 16) | f_low | 0x100);
+                        pci_write_config_dword(dev, 0x5C,
+                                               (f_high << 16) | f_low | 0x100);
                 }
                 if (adjust == 8) {
-                        printk(KERN_ERR "pata_hpt37x: DPLL did not stabilize!\n");
+                        pr_err("DPLL did not stabilize!\n");
                         return -ENODEV;
                 }
                 if (dpll == 3)
@@ -968,22 +1018,23 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 else
                         private_data = (void *)hpt37x_timings_50;
 
-                printk(KERN_INFO "pata_hpt37x: bus clock %dMHz, using %dMHz DPLL.\n",
-                       MHz[clock_slot], MHz[dpll]);
+                pr_info("bus clock %dMHz, using %dMHz DPLL\n",
+                        MHz[clock_slot], MHz[dpll]);
         } else {
                 private_data = (void *)chip_table->clocks[clock_slot];
                 /*
                  *      Perform a final fixup. Note that we will have used the
                  *      DPLL on the HPT372 which means we don't have to worry
                  *      about lack of UDMA133 support on lower clocks
-                 */
+                 */
 
                 if (clock_slot < 2 && ppi[0] == &info_hpt370)
                         ppi[0] = &info_hpt370_33;
                 if (clock_slot < 2 && ppi[0] == &info_hpt370a)
                         ppi[0] = &info_hpt370a_33;
-                printk(KERN_INFO "pata_hpt37x: %s using %dMHz bus clock.\n",
-                       chip_table->name, MHz[clock_slot]);
+
+                pr_info("%s using %dMHz bus clock\n",
+                        chip_table->name, MHz[clock_slot]);
         }
 
         /* Now kick off ATA set up */
@@ -1001,9 +1052,9 @@ static const struct pci_device_id hpt37x[] = {
 };
 
 static struct pci_driver hpt37x_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
         .id_table       = hpt37x,
-        .probe          = hpt37x_init_one,
+        .probe          = hpt37x_init_one,
         .remove         = ata_pci_remove_one
 };
 
diff --git a/drivers/ata/pata_hpt3x2n.c b/drivers/ata/pata_hpt3x2n.c
index 32f3463216b8..765f136d8cd3 100644
--- a/drivers/ata/pata_hpt3x2n.c
+++ b/drivers/ata/pata_hpt3x2n.c
@@ -1,5 +1,5 @@
 /*
- * Libata driver for the highpoint 372N and 302N UDMA66 ATA controllers.
+ * Libata driver for the HighPoint 371N, 372N, and 302N UDMA66 ATA controllers.
  *
  * This driver is heavily based upon:
  *
@@ -8,13 +8,15 @@
  * Copyright (C) 1999-2003              Andre Hedrick <andre@linux-ide.org>
  * Portions Copyright (C) 2001          Sun Microsystems, Inc.
  * Portions Copyright (C) 2003          Red Hat Inc
- * Portions Copyright (C) 2005-2009     MontaVista Software, Inc.
+ * Portions Copyright (C) 2005-2010     MontaVista Software, Inc.
  *
  *
  * TODO
  *      Work out best PLL policy
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/pci.h>
@@ -25,7 +27,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME        "pata_hpt3x2n"
-#define DRV_VERSION     "0.3.10"
+#define DRV_VERSION     "0.3.15"
 
 enum {
         HPT_PCI_FAST    =       (1 << 31),
@@ -103,7 +105,7 @@ static u32 hpt3x2n_find_mode(struct ata_port *ap, int speed)
 {
         struct hpt_clock *clocks = hpt3x2n_clocks;
 
-        while(clocks->xfer_speed) {
+        while (clocks->xfer_speed) {
                 if (clocks->xfer_speed == speed)
                         return clocks->timing;
                 clocks++;
@@ -113,6 +115,22 @@ static u32 hpt3x2n_find_mode(struct ata_port *ap, int speed)
 }
 
 /**
+ *      hpt372n_filter  -       mode selection filter
+ *      @adev: ATA device
+ *      @mask: mode mask
+ *
+ *      The Marvell bridge chips used on the HighPoint SATA cards do not seem
+ *      to support the UltraDMA modes 1, 2, and 3 as well as any MWDMA modes...
+ */
+static unsigned long hpt372n_filter(struct ata_device *adev, unsigned long mask)
+{
+        if (ata_id_is_sata(adev->id))
+                mask &= ~((0xE << ATA_SHIFT_UDMA) | ATA_MASK_MWDMA);
+
+        return mask;
+}
+
+/**
  *      hpt3x2n_cable_detect    -       Detect the cable type
  *      @ap: ATA port to detect on
  *
@@ -153,6 +171,7 @@ static int hpt3x2n_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);
@@ -328,10 +347,10 @@ static struct scsi_host_template hpt3x2n_sht = {
 };
 
 /*
- *      Configuration for HPT3x2n.
+ *      Configuration for HPT302N/371N.
  */
 
-static struct ata_port_operations hpt3x2n_port_ops = {
+static struct ata_port_operations hpt3xxn_port_ops = {
         .inherits       = &ata_bmdma_port_ops,
 
         .bmdma_stop     = hpt3x2n_bmdma_stop,
@@ -345,6 +364,15 @@ static struct ata_port_operations hpt3x2n_port_ops = {
         .prereset       = hpt3x2n_pre_reset,
 };
 
+/*
+ *      Configuration for HPT372N. Same as 302N/371N but we have a mode filter.
+ */
+
+static struct ata_port_operations hpt372n_port_ops = {
+        .inherits       = &hpt3xxn_port_ops,
+        .mode_filter    = &hpt372n_filter,
+};
+
 /**
  *      hpt3xn_calibrate_dpll           -       Calibrate the DPLL loop
  *      @dev: PCI device
@@ -359,12 +387,12 @@ static int hpt3xn_calibrate_dpll(struct pci_dev *dev)
         u32 reg5c;
         int tries;
 
-        for(tries = 0; tries < 0x5000; tries++) {
+        for (tries = 0; tries < 0x5000; tries++) {
                 udelay(50);
                 pci_read_config_byte(dev, 0x5b, &reg5b);
                 if (reg5b & 0x80) {
                         /* See if it stays set */
-                        for(tries = 0; tries < 0x1000; tries ++) {
+                        for (tries = 0; tries < 0x1000; tries++) {
                                 pci_read_config_byte(dev, 0x5b, &reg5b);
                                 /* Failed ? */
                                 if ((reg5b & 0x80) == 0)
@@ -372,7 +400,7 @@ static int hpt3xn_calibrate_dpll(struct pci_dev *dev)
                         }
                         /* Turn off tuning, we have the DPLL set */
                         pci_read_config_dword(dev, 0x5c, &reg5c);
-                        pci_write_config_dword(dev, 0x5c, reg5c & ~ 0x100);
+                        pci_write_config_dword(dev, 0x5c, reg5c & ~0x100);
                         return 1;
                 }
         }
@@ -388,8 +416,19 @@ static int hpt3x2n_pci_clock(struct pci_dev *pdev)
 
         fcnt = inl(iobase + 0x90);      /* Not PCI readable for some chips */
         if ((fcnt >> 12) != 0xABCDE) {
-                printk(KERN_WARNING "hpt3xn: BIOS clock data not set.\n");
-                return 33;      /* Not BIOS set */
+                int i;
+                u16 sr;
+                u32 total = 0;
+
+                pr_warn("BIOS clock data not set\n");
+
+                /* This is the process the HPT371 BIOS is reported to use */
+                for (i = 0; i < 128; i++) {
+                        pci_read_config_word(pdev, 0x78, &sr);
+                        total += sr & 0x1FF;
+                        udelay(15);
+                }
+                fcnt = total / 128;
         }
         fcnt &= 0x1FF;
 
@@ -431,21 +470,27 @@ static int hpt3x2n_pci_clock(struct pci_dev *pdev)
  *      HPT372N                 9 (HPT372N)     *       UDMA133
  *
  *      (1) UDMA133 support depends on the bus clock
- *
- *      To pin down             HPT371N
  */
 
 static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
-        /* HPT372N and friends - UDMA133 */
-        static const struct ata_port_info info = {
+        /* HPT372N - UDMA133 */
+        static const struct ata_port_info info_hpt372n = {
                 .flags = ATA_FLAG_SLAVE_POSS,
                 .pio_mask = ATA_PIO4,
                 .mwdma_mask = ATA_MWDMA2,
                 .udma_mask = ATA_UDMA6,
-                .port_ops = &hpt3x2n_port_ops
+                .port_ops = &hpt372n_port_ops
         };
-        const struct ata_port_info *ppi[] = { &info, NULL };
+        /* HPT302N and HPT371N - UDMA133 */
+        static const struct ata_port_info info_hpt3xxn = {
+                .flags = ATA_FLAG_SLAVE_POSS,
+                .pio_mask = ATA_PIO4,
+                .mwdma_mask = ATA_MWDMA2,
+                .udma_mask = ATA_UDMA6,
+                .port_ops = &hpt3xxn_port_ops
+        };
+        const struct ata_port_info *ppi[] = { &info_hpt3xxn, NULL };
         u8 rev = dev->revision;
         u8 irqmask;
         unsigned int pci_mhz;
@@ -459,30 +504,34 @@ static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         if (rc)
                 return rc;
 
-        switch(dev->device) {
-                case PCI_DEVICE_ID_TTI_HPT366:
-                        if (rev < 6)
-                                return -ENODEV;
-                        break;
-                case PCI_DEVICE_ID_TTI_HPT371:
-                        if (rev < 2)
-                                return -ENODEV;
-                        /* 371N if rev > 1 */
-                        break;
-                case PCI_DEVICE_ID_TTI_HPT372:
-                        /* 372N if rev >= 2*/
-                        if (rev < 2)
-                                return -ENODEV;
-                        break;
-                case PCI_DEVICE_ID_TTI_HPT302:
-                        if (rev < 2)
-                                return -ENODEV;
-                        break;
-                case PCI_DEVICE_ID_TTI_HPT372N:
-                        break;
-                default:
-                        printk(KERN_ERR "pata_hpt3x2n: PCI table is bogus please report (%d).\n", dev->device);
+        switch (dev->device) {
+        case PCI_DEVICE_ID_TTI_HPT366:
+                /* 372N if rev >= 6 */
+                if (rev < 6)
                         return -ENODEV;
+                goto hpt372n;
+        case PCI_DEVICE_ID_TTI_HPT371:
+                /* 371N if rev >= 2 */
+                if (rev < 2)
+                        return -ENODEV;
+                break;
+        case PCI_DEVICE_ID_TTI_HPT372:
+                /* 372N if rev >= 2 */
+                if (rev < 2)
+                        return -ENODEV;
+                goto hpt372n;
+        case PCI_DEVICE_ID_TTI_HPT302:
+                /* 302N if rev >= 2 */
+                if (rev < 2)
+                        return -ENODEV;
+                break;
+        case PCI_DEVICE_ID_TTI_HPT372N:
+hpt372n:
+                ppi[0] = &info_hpt372n;
+                break;
+        default:
+                pr_err("PCI table is bogus, please report (%d)\n", dev->device);
+                return -ENODEV;
         }
 
         /* Ok so this is a chip we support */
@@ -509,8 +558,10 @@ static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 pci_write_config_byte(dev, 0x50, mcr1);
         }
 
-        /* Tune the PLL. HPT recommend using 75 for SATA, 66 for UDMA133 or
-           50 for UDMA100. Right now we always use 66 */
+        /*
+         * Tune the PLL. HPT recommend using 75 for SATA, 66 for UDMA133 or
+         * 50 for UDMA100. Right now we always use 66
+         */
 
         pci_mhz = hpt3x2n_pci_clock(dev);
 
@@ -522,20 +573,22 @@ static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         pci_write_config_byte(dev, 0x5B, 0x21);
 
         /* Unlike the 37x we don't try jiggling the frequency */
-        for(adjust = 0; adjust < 8; adjust++) {
+        for (adjust = 0; adjust < 8; adjust++) {
                 if (hpt3xn_calibrate_dpll(dev))
                         break;
                 pci_write_config_dword(dev, 0x5C, (f_high << 16) | f_low);
         }
         if (adjust == 8) {
-                printk(KERN_ERR "pata_hpt3x2n: DPLL did not stabilize!\n");
+                pr_err("DPLL did not stabilize!\n");
                 return -ENODEV;
         }
 
-        printk(KERN_INFO "pata_hpt37x: bus clock %dMHz, using 66MHz DPLL.\n",
-               pci_mhz);
-        /* Set our private data up. We only need a few flags so we use
-           it directly */
+        pr_info("bus clock %dMHz, using 66MHz DPLL\n", pci_mhz);
+
+        /*
+         * Set our private data up. We only need a few flags
+         * so we use it directly.
+         */
         if (pci_mhz > 60)
                 hpriv = (void *)(PCI66 | USE_DPLL);
 
@@ -562,9 +615,9 @@ static const struct pci_device_id hpt3x2n[] = {
 };
 
 static struct pci_driver hpt3x2n_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
         .id_table       = hpt3x2n,
-        .probe          = hpt3x2n_init_one,
+        .probe          = hpt3x2n_init_one,
         .remove         = ata_pci_remove_one
 };
 
@@ -579,7 +632,7 @@ static void __exit hpt3x2n_exit(void)
 }
 
 MODULE_AUTHOR("Alan Cox");
-MODULE_DESCRIPTION("low-level driver for the Highpoint HPT3x2n/30x");
+MODULE_DESCRIPTION("low-level driver for the Highpoint HPT3xxN");
 MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, hpt3x2n);
 MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/ata/pata_hpt3x3.c b/drivers/ata/pata_hpt3x3.c
index b63d5e2d4628..24d7df81546b 100644
--- a/drivers/ata/pata_hpt3x3.c
+++ b/drivers/ata/pata_hpt3x3.c
@@ -151,7 +151,7 @@ static struct ata_port_operations hpt3x3_port_ops = {
         .check_atapi_dma= hpt3x3_atapi_dma,
         .freeze         = hpt3x3_freeze,
 #endif
-        
+
 };
 
 /**
diff --git a/drivers/ata/pata_it821x.c b/drivers/ata/pata_it821x.c
index bf88f71a21f4..2d15f2548a10 100644
--- a/drivers/ata/pata_it821x.c
+++ b/drivers/ata/pata_it821x.c
@@ -15,8 +15,8 @@
  *  May be copied or modified under the terms of the GNU General Public License
  *  Based in part on the ITE vendor provided SCSI driver.
  *
- *  Documentation available from
- *      http://www.ite.com.tw/pc/IT8212F_V04.pdf
+ *  Documentation available from IT8212F_V04.pdf
+ *      http://www.ite.com.tw/EN/products_more.aspx?CategoryID=3&ID=5,91
  *  Some other documents are NDA.
  *
  *  The ITE8212 isn't exactly a standard IDE controller. It has two
@@ -616,7 +616,7 @@ static void it821x_display_disk(int n, u8 *buf)
         if (buf[52] > 4)        /* No Disk */
                 return;
 
-        ata_id_c_string((u16 *)buf, id, 0, 41); 
+        ata_id_c_string((u16 *)buf, id, 0, 41);
 
         if (buf[51]) {
                 mode = ffs(buf[51]);
@@ -910,7 +910,7 @@ static int it821x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         rc = pcim_enable_device(pdev);
         if (rc)
                 return rc;
-                
+
         if (pdev->vendor == PCI_VENDOR_ID_RDC) {
                 /* Deal with Vortex86SX */
                 if (pdev->revision == 0x11)
diff --git a/drivers/ata/pata_ixp4xx_cf.c b/drivers/ata/pata_ixp4xx_cf.c
index ba54b089f98c..f6b3f995f58a 100644
--- a/drivers/ata/pata_ixp4xx_cf.c
+++ b/drivers/ata/pata_ixp4xx_cf.c
@@ -167,7 +167,7 @@ static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
 
         irq = platform_get_irq(pdev, 0);
         if (irq)
-                set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
+                irq_set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
 
         /* Setup expansion bus chip selects */
         *data->cs0_cfg = data->cs0_bits;
@@ -177,7 +177,7 @@ static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
 
         ap->ops = &ixp4xx_port_ops;
         ap->pio_mask = ATA_PIO4;
-        ap->flags |= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY | ATA_FLAG_NO_ATAPI;
+        ap->flags |= ATA_FLAG_NO_ATAPI;
 
         ixp4xx_setup_port(ap, data, cs0->start, cs1->start);
 
diff --git a/drivers/ata/pata_legacy.c b/drivers/ata/pata_legacy.c
index eaf194138f21..6bd9425ba5ab 100644
--- a/drivers/ata/pata_legacy.c
+++ b/drivers/ata/pata_legacy.c
@@ -142,7 +142,7 @@ static int autospeed;		/* Chip present which snoops speed changes */
 static int pio_mask = ATA_PIO4; /* PIO range for autospeed devices */
 static int iordy_mask = 0xFFFFFFFF;     /* Use iordy if available */
 
-#ifdef PATA_WINBOND_VLB_MODULE
+#ifdef CONFIG_PATA_WINBOND_VLB_MODULE
 static int winbond = 1;         /* Set to probe Winbond controllers,
                                         give I/O port if non standard */
 #else
diff --git a/drivers/ata/pata_macio.c b/drivers/ata/pata_macio.c
index 75b49d01780b..46f589edccdb 100644
--- a/drivers/ata/pata_macio.c
+++ b/drivers/ata/pata_macio.c
@@ -1053,8 +1053,7 @@ static int __devinit pata_macio_common_init(struct pata_macio_priv	*priv,
         /* Allocate libata host for 1 port */
         memset(&pinfo, 0, sizeof(struct ata_port_info));
         pmac_macio_calc_timing_masks(priv, &pinfo);
-        pinfo.flags             = ATA_FLAG_SLAVE_POSS | ATA_FLAG_MMIO |
-                                  ATA_FLAG_NO_LEGACY;
+        pinfo.flags             = ATA_FLAG_SLAVE_POSS;
         pinfo.port_ops          = &pata_macio_ops;
         pinfo.private_data      = priv;
 
diff --git a/drivers/ata/pata_marvell.c b/drivers/ata/pata_marvell.c
index dd38083dcbeb..5d7f58a7e34d 100644
--- a/drivers/ata/pata_marvell.c
+++ b/drivers/ata/pata_marvell.c
@@ -38,7 +38,7 @@ static int marvell_pata_active(struct pci_dev *pdev)
 
         /* We don't yet know how to do this for other devices */
         if (pdev->device != 0x6145)
-                return 1;       
+                return 1;
 
         barp = pci_iomap(pdev, 5, 0x10);
         if (barp == NULL)
@@ -161,6 +161,9 @@ static const struct pci_device_id marvell_pci_tbl[] = {
         { PCI_DEVICE(0x11AB, 0x6121), },
         { PCI_DEVICE(0x11AB, 0x6123), },
         { PCI_DEVICE(0x11AB, 0x6145), },
+        { PCI_DEVICE(0x1B4B, 0x91A0), },
+        { PCI_DEVICE(0x1B4B, 0x91A4), },
+
         { }     /* terminate list */
 };
 
diff --git a/drivers/ata/pata_mpc52xx.c b/drivers/ata/pata_mpc52xx.c
index 8cc536e49a0a..2fcac511d39c 100644
--- a/drivers/ata/pata_mpc52xx.c
+++ b/drivers/ata/pata_mpc52xx.c
@@ -610,7 +610,7 @@ static struct scsi_host_template mpc52xx_ata_sht = {
 };
 
 static struct ata_port_operations mpc52xx_ata_port_ops = {
-        .inherits               = &ata_sff_port_ops,
+        .inherits               = &ata_bmdma_port_ops,
         .sff_dev_select         = mpc52xx_ata_dev_select,
         .set_piomode            = mpc52xx_ata_set_piomode,
         .set_dmamode            = mpc52xx_ata_set_dmamode,
@@ -680,7 +680,7 @@ mpc52xx_ata_remove_one(struct device *dev)
 /* ======================================================================== */
 
 static int __devinit
-mpc52xx_ata_probe(struct platform_device *op, const struct of_device_id *match)
+mpc52xx_ata_probe(struct platform_device *op)
 {
         unsigned int ipb_freq;
         struct resource res_mem;
@@ -883,7 +883,7 @@ static struct of_device_id mpc52xx_ata_of_match[] = {
 };
 
 
-static struct of_platform_driver mpc52xx_ata_of_platform_driver = {
+static struct platform_driver mpc52xx_ata_of_platform_driver = {
         .probe          = mpc52xx_ata_probe,
         .remove         = mpc52xx_ata_remove,
 #ifdef CONFIG_PM
@@ -906,13 +906,13 @@ static int __init
 mpc52xx_ata_init(void)
 {
         printk(KERN_INFO "ata: MPC52xx IDE/ATA libata driver\n");
-        return of_register_platform_driver(&mpc52xx_ata_of_platform_driver);
+        return platform_driver_register(&mpc52xx_ata_of_platform_driver);
 }
 
 static void __exit
 mpc52xx_ata_exit(void)
 {
-        of_unregister_platform_driver(&mpc52xx_ata_of_platform_driver);
+        platform_driver_unregister(&mpc52xx_ata_of_platform_driver);
 }
 
 module_init(mpc52xx_ata_init);
diff --git a/drivers/ata/pata_mpiix.c b/drivers/ata/pata_mpiix.c
index b21f0021f54a..d8d9c5807740 100644
--- a/drivers/ata/pata_mpiix.c
+++ b/drivers/ata/pata_mpiix.c
@@ -15,7 +15,7 @@
  * with PCI IDE and also that we do not disable the device when our driver is
  * unloaded (as it has many other functions).
  *
- * The driver conciously keeps this logic internally to avoid pushing quirky
+ * The driver consciously keeps this logic internally to avoid pushing quirky
  * PATA history into the clean libata layer.
  *
  * Thinkpad specific note: If you boot an MPIIX using a thinkpad with a PCMCIA
diff --git a/drivers/ata/pata_ninja32.c b/drivers/ata/pata_ninja32.c
index cc50bd09aa26..e277a142138c 100644
--- a/drivers/ata/pata_ninja32.c
+++ b/drivers/ata/pata_ninja32.c
@@ -165,7 +165,7 @@ static int ninja32_reinit_one(struct pci_dev *pdev)
                 return rc;
         ninja32_program(host->iomap[0]);
         ata_host_resume(host);
-        return 0;                       
+        return 0;
 }
 #endif
 
diff --git a/drivers/ata/pata_octeon_cf.c b/drivers/ata/pata_octeon_cf.c
index 06ddd91ffeda..220ddc90608f 100644
--- a/drivers/ata/pata_octeon_cf.c
+++ b/drivers/ata/pata_octeon_cf.c
@@ -60,7 +60,7 @@ static unsigned int ns_to_tim_reg(unsigned int tim_mult, unsigned int nsecs)
          * Compute # of eclock periods to get desired duration in
          * nanoseconds.
          */
-        val = DIV_ROUND_UP(nsecs * (octeon_get_clock_rate() / 1000000),
+        val = DIV_ROUND_UP(nsecs * (octeon_get_io_clock_rate() / 1000000),
                           1000 * tim_mult);
 
         return val;
@@ -653,8 +653,6 @@ static irqreturn_t octeon_cf_interrupt(int irq, void *dev_instance)
 
                 ap = host->ports[i];
                 ocd = ap->dev->platform_data;
-
-                ocd = ap->dev->platform_data;
                 cf_port = ap->private_data;
                 dma_int.u64 =
                         cvmx_read_csr(CVMX_MIO_BOOT_DMA_INTX(ocd->dma_engine));
@@ -850,8 +848,7 @@ static int __devinit octeon_cf_probe(struct platform_device *pdev)
         cf_port->ap = ap;
         ap->ops = &octeon_cf_ops;
         ap->pio_mask = ATA_PIO6;
-        ap->flags |= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY
-                  | ATA_FLAG_NO_ATAPI | ATA_FLAG_PIO_POLLING;
+        ap->flags |= ATA_FLAG_NO_ATAPI | ATA_FLAG_PIO_POLLING;
 
         base = cs0 + ocd->base_region_bias;
         if (!ocd->is16bit) {
diff --git a/drivers/ata/pata_of_platform.c b/drivers/ata/pata_of_platform.c
index 480e043ce6b8..f3054009bd25 100644
--- a/drivers/ata/pata_of_platform.c
+++ b/drivers/ata/pata_of_platform.c
@@ -14,8 +14,7 @@
 #include <linux/of_platform.h>
 #include <linux/ata_platform.h>
 
-static int __devinit pata_of_platform_probe(struct platform_device *ofdev,
-                                            const struct of_device_id *match)
+static int __devinit pata_of_platform_probe(struct platform_device *ofdev)
 {
         int ret;
         struct device_node *dn = ofdev->dev.of_node;
@@ -90,7 +89,7 @@ static struct of_device_id pata_of_platform_match[] = {
 };
 MODULE_DEVICE_TABLE(of, pata_of_platform_match);
 
-static struct of_platform_driver pata_of_platform_driver = {
+static struct platform_driver pata_of_platform_driver = {
         .driver = {
                 .name = "pata_of_platform",
                 .owner = THIS_MODULE,
@@ -102,13 +101,13 @@ static struct of_platform_driver pata_of_platform_driver = {
 
 static int __init pata_of_platform_init(void)
 {
-        return of_register_platform_driver(&pata_of_platform_driver);
+        return platform_driver_register(&pata_of_platform_driver);
 }
 module_init(pata_of_platform_init);
 
 static void __exit pata_of_platform_exit(void)
 {
-        of_unregister_platform_driver(&pata_of_platform_driver);
+        platform_driver_unregister(&pata_of_platform_driver);
 }
 module_exit(pata_of_platform_exit);
 
diff --git a/drivers/ata/pata_palmld.c b/drivers/ata/pata_palmld.c
index 11fb4ccc74b4..b86d7e22595e 100644
--- a/drivers/ata/pata_palmld.c
+++ b/drivers/ata/pata_palmld.c
@@ -33,6 +33,11 @@
 
 #define DRV_NAME "pata_palmld"
 
+static struct gpio palmld_hdd_gpios[] = {
+        { GPIO_NR_PALMLD_IDE_PWEN,      GPIOF_INIT_HIGH,        "HDD Power" },
+        { GPIO_NR_PALMLD_IDE_RESET,     GPIOF_INIT_LOW,         "HDD Reset" },
+};
+
 static struct scsi_host_template palmld_sht = {
         ATA_PIO_SHT(DRV_NAME),
 };
@@ -52,28 +57,23 @@ static __devinit int palmld_pata_probe(struct platform_device *pdev)
 
         /* allocate host */
         host = ata_host_alloc(&pdev->dev, 1);
-        if (!host)
-                return -ENOMEM;
+        if (!host) {
+                ret = -ENOMEM;
+                goto err1;
+        }
 
         /* remap drive's physical memory address */
         mem = devm_ioremap(&pdev->dev, PALMLD_IDE_PHYS, 0x1000);
-        if (!mem)
-                return -ENOMEM;
+        if (!mem) {
+                ret = -ENOMEM;
+                goto err1;
+        }
 
         /* request and activate power GPIO, IRQ GPIO */
-        ret = gpio_request(GPIO_NR_PALMLD_IDE_PWEN, "HDD PWR");
+        ret = gpio_request_array(palmld_hdd_gpios,
+                                ARRAY_SIZE(palmld_hdd_gpios));
         if (ret)
                 goto err1;
-        ret = gpio_direction_output(GPIO_NR_PALMLD_IDE_PWEN, 1);
-        if (ret)
-                goto err2;
-
-        ret = gpio_request(GPIO_NR_PALMLD_IDE_RESET, "HDD RST");
-        if (ret)
-                goto err2;
-        ret = gpio_direction_output(GPIO_NR_PALMLD_IDE_RESET, 0);
-        if (ret)
-                goto err3;
 
         /* reset the drive */
         gpio_set_value(GPIO_NR_PALMLD_IDE_RESET, 0);
@@ -85,7 +85,7 @@ static __devinit int palmld_pata_probe(struct platform_device *pdev)
         ap = host->ports[0];
         ap->ops = &palmld_port_ops;
         ap->pio_mask = ATA_PIO4;
-        ap->flags |= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY | ATA_FLAG_PIO_POLLING;
+        ap->flags |= ATA_FLAG_PIO_POLLING;
 
         /* memory mapping voodoo */
         ap->ioaddr.cmd_addr = mem + 0x10;
@@ -96,13 +96,15 @@ static __devinit int palmld_pata_probe(struct platform_device *pdev)
         ata_sff_std_ports(&ap->ioaddr);
 
         /* activate host */
-        return ata_host_activate(host, 0, NULL, IRQF_TRIGGER_RISING,
+        ret = ata_host_activate(host, 0, NULL, IRQF_TRIGGER_RISING,
                                         &palmld_sht);
+        if (ret)
+                goto err2;
+
+        return ret;
 
-err3:
-        gpio_free(GPIO_NR_PALMLD_IDE_RESET);
 err2:
-        gpio_free(GPIO_NR_PALMLD_IDE_PWEN);
+        gpio_free_array(palmld_hdd_gpios, ARRAY_SIZE(palmld_hdd_gpios));
 err1:
         return ret;
 }
@@ -116,8 +118,7 @@ static __devexit int palmld_pata_remove(struct platform_device *dev)
         /* power down the HDD */
         gpio_set_value(GPIO_NR_PALMLD_IDE_PWEN, 0);
 
-        gpio_free(GPIO_NR_PALMLD_IDE_RESET);
-        gpio_free(GPIO_NR_PALMLD_IDE_PWEN);
+        gpio_free_array(palmld_hdd_gpios, ARRAY_SIZE(palmld_hdd_gpios));
 
         return 0;
 }
diff --git a/drivers/ata/pata_pcmcia.c b/drivers/ata/pata_pcmcia.c
index e944aa0c5517..021abe6d8527 100644
--- a/drivers/ata/pata_pcmcia.c
+++ b/drivers/ata/pata_pcmcia.c
@@ -34,7 +34,6 @@
 #include <linux/ata.h>
 #include <linux/libata.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <pcmcia/cisreg.h>
@@ -125,7 +124,7 @@ static unsigned int ata_data_xfer_8bit(struct ata_device *dev,
  *      reset will recover the device.
  *
  */
- 
+
 static void pcmcia_8bit_drain_fifo(struct ata_queued_cmd *qc)
 {
         int count;
@@ -168,63 +167,26 @@ static struct ata_port_operations pcmcia_8bit_port_ops = {
 };
 
 
-struct pcmcia_config_check {
-        unsigned long ctl_base;
-        int skip_vcc;
-        int is_kme;
-};
-
-static int pcmcia_check_one_config(struct pcmcia_device *pdev,
-                                   cistpl_cftable_entry_t *cfg,
-                                   cistpl_cftable_entry_t *dflt,
-                                   unsigned int vcc,
-                                   void *priv_data)
+static int pcmcia_check_one_config(struct pcmcia_device *pdev, void *priv_data)
 {
-        struct pcmcia_config_check *stk = priv_data;
-
-        /* Check for matching Vcc, unless we're desperate */
-        if (!stk->skip_vcc) {
-                if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                        if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
-                                return -ENODEV;
-                } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                        if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
-                                return -ENODEV;
-                }
+        int *is_kme = priv_data;
+
+        if (!(pdev->resource[0]->flags & IO_DATA_PATH_WIDTH_8)) {
+                pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
         }
+        pdev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+        pdev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
 
-        if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                pdev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                pdev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                pdev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                pdev->resource[0]->start = io->win[0].base;
-                if (!(io->flags & CISTPL_IO_16BIT)) {
-                        pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                        pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-                }
-                if (io->nwin == 2) {
-                        pdev->resource[0]->end = 8;
-                        pdev->resource[1]->start = io->win[1].base;
-                        pdev->resource[1]->end = (stk->is_kme) ? 2 : 1;
-                        if (pcmcia_request_io(pdev) != 0)
-                                return -ENODEV;
-                        stk->ctl_base = pdev->resource[1]->start;
-                } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
-                        pdev->resource[0]->end = io->win[0].len;
-                        pdev->resource[1]->end = 0;
-                        if (pcmcia_request_io(pdev) != 0)
-                                return -ENODEV;
-                        stk->ctl_base = pdev->resource[0]->start + 0x0e;
-                } else
+        if (pdev->resource[1]->end) {
+                pdev->resource[0]->end = 8;
+                pdev->resource[1]->end = (*is_kme) ? 2 : 1;
+        } else {
+                if (pdev->resource[0]->end < 16)
                         return -ENODEV;
-                /* If we've got this far, we're done */
-                return 0;
         }
-        return -ENODEV;
+
+        return pcmcia_request_io(pdev);
 }
 
 /**
@@ -239,7 +201,6 @@ static int pcmcia_init_one(struct pcmcia_device *pdev)
 {
         struct ata_host *host;
         struct ata_port *ap;
-        struct pcmcia_config_check *stk = NULL;
         int is_kme = 0, ret = -ENOMEM, p;
         unsigned long io_base, ctl_base;
         void __iomem *io_addr, *ctl_addr;
@@ -247,10 +208,8 @@ static int pcmcia_init_one(struct pcmcia_device *pdev)
         struct ata_port_operations *ops = &pcmcia_port_ops;
 
         /* Set up attributes in order to probe card and get resources */
-        pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        pdev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
-        pdev->conf.Attributes = CONF_ENABLE_IRQ;
-        pdev->conf.IntType = INT_MEMORY_AND_IO;
+        pdev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO |
+                CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC;
 
         /* See if we have a manufacturer identifier. Use it to set is_kme for
            vendor quirks */
@@ -258,25 +217,21 @@ static int pcmcia_init_one(struct pcmcia_device *pdev)
                   ((pdev->card_id == PRODID_KME_KXLC005_A) ||
                    (pdev->card_id == PRODID_KME_KXLC005_B)));
 
-        /* Allocate resoure probing structures */
-
-        stk = kzalloc(sizeof(*stk), GFP_KERNEL);
-        if (!stk)
-                goto out1;
-        stk->is_kme = is_kme;
-        stk->skip_vcc = io_base = ctl_base = 0;
-
-        if (pcmcia_loop_config(pdev, pcmcia_check_one_config, stk)) {
-                stk->skip_vcc = 1;
-                if (pcmcia_loop_config(pdev, pcmcia_check_one_config, stk))
+        if (pcmcia_loop_config(pdev, pcmcia_check_one_config, &is_kme)) {
+                pdev->config_flags &= ~CONF_AUTO_CHECK_VCC;
+                if (pcmcia_loop_config(pdev, pcmcia_check_one_config, &is_kme))
                         goto failed; /* No suitable config found */
         }
         io_base = pdev->resource[0]->start;
-        ctl_base = stk->ctl_base;
+        if (pdev->resource[1]->end)
+                ctl_base = pdev->resource[1]->start;
+        else
+                ctl_base = pdev->resource[0]->start + 0x0e;
+
         if (!pdev->irq)
                 goto failed;
 
-        ret = pcmcia_request_configuration(pdev, &pdev->conf);
+        ret = pcmcia_enable_device(pdev);
         if (ret)
                 goto failed;
 
@@ -329,13 +284,10 @@ static int pcmcia_init_one(struct pcmcia_device *pdev)
                 goto failed;
 
         pdev->priv = host;
-        kfree(stk);
         return 0;
 
 failed:
-        kfree(stk);
         pcmcia_disable_device(pdev);
-out1:
         return ret;
 }
 
@@ -357,7 +309,7 @@ static void pcmcia_remove_one(struct pcmcia_device *pdev)
         pcmcia_disable_device(pdev);
 }
 
-static struct pcmcia_device_id pcmcia_devices[] = {
+static const struct pcmcia_device_id pcmcia_devices[] = {
         PCMCIA_DEVICE_FUNC_ID(4),
         PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),        /* Corsair */
         PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000),        /* Hitachi */
@@ -430,9 +382,7 @@ MODULE_DEVICE_TABLE(pcmcia, pcmcia_devices);
 
 static struct pcmcia_driver pcmcia_driver = {
         .owner          = THIS_MODULE,
-        .drv = {
-                .name           = DRV_NAME,
-        },
+        .name           = DRV_NAME,
         .id_table       = pcmcia_devices,
         .probe          = pcmcia_init_one,
         .remove         = pcmcia_remove_one,
diff --git a/drivers/ata/pata_pdc2027x.c b/drivers/ata/pata_pdc2027x.c
index b18351122525..9765ace16921 100644
--- a/drivers/ata/pata_pdc2027x.c
+++ b/drivers/ata/pata_pdc2027x.c
@@ -150,8 +150,7 @@ static struct ata_port_operations pdc2027x_pata133_ops = {
 static struct ata_port_info pdc2027x_port_info[] = {
         /* PDC_UDMA_100 */
         {
-                .flags          = ATA_FLAG_NO_LEGACY | ATA_FLAG_SLAVE_POSS |
-                                  ATA_FLAG_MMIO,
+                .flags          = ATA_FLAG_SLAVE_POSS,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA5,
@@ -159,8 +158,7 @@ static struct ata_port_info pdc2027x_port_info[] = {
         },
         /* PDC_UDMA_133 */
         {
-                .flags          = ATA_FLAG_NO_LEGACY | ATA_FLAG_SLAVE_POSS |
-                                  ATA_FLAG_MMIO,
+                .flags          = ATA_FLAG_SLAVE_POSS,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA6,
diff --git a/drivers/ata/pata_pdc202xx_old.c b/drivers/ata/pata_pdc202xx_old.c
index c39f213e1bbc..c2ed5868dda6 100644
--- a/drivers/ata/pata_pdc202xx_old.c
+++ b/drivers/ata/pata_pdc202xx_old.c
@@ -44,6 +44,27 @@ static void pdc202xx_exec_command(struct ata_port *ap,
         ndelay(400);
 }
 
+static bool pdc202xx_irq_check(struct ata_port *ap)
+{
+        struct pci_dev *pdev    = to_pci_dev(ap->host->dev);
+        unsigned long master    = pci_resource_start(pdev, 4);
+        u8 sc1d                 = inb(master + 0x1d);
+
+        if (ap->port_no) {
+                /*
+                 * bit 7: error, bit 6: interrupting,
+                 * bit 5: FIFO full, bit 4: FIFO empty
+                 */
+                return sc1d & 0x40;
+        } else  {
+                /*
+                 * bit 3: error, bit 2: interrupting,
+                 * bit 1: FIFO full, bit 0: FIFO empty
+                 */
+                return sc1d & 0x04;
+        }
+}
+
 /**
  *      pdc202xx_configure_piomode      -       set chip PIO timing
  *      @ap: ATA interface
@@ -282,6 +303,7 @@ static struct ata_port_operations pdc2024x_port_ops = {
         .set_dmamode            = pdc202xx_set_dmamode,
 
         .sff_exec_command       = pdc202xx_exec_command,
+        .sff_irq_check          = pdc202xx_irq_check,
 };
 
 static struct ata_port_operations pdc2026x_port_ops = {
@@ -297,6 +319,7 @@ static struct ata_port_operations pdc2026x_port_ops = {
         .port_start             = pdc2026x_port_start,
 
         .sff_exec_command       = pdc202xx_exec_command,
+        .sff_irq_check          = pdc202xx_irq_check,
 };
 
 static int pdc202xx_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ata/pata_pxa.c b/drivers/ata/pata_pxa.c
index 1898c6ed4b4e..b4ede40f8ae1 100644
--- a/drivers/ata/pata_pxa.c
+++ b/drivers/ata/pata_pxa.c
@@ -292,7 +292,6 @@ static int __devinit pxa_ata_probe(struct platform_device *pdev)
         ap->ops         = &pxa_ata_port_ops;
         ap->pio_mask    = ATA_PIO4;
         ap->mwdma_mask  = ATA_MWDMA2;
-        ap->flags       = ATA_FLAG_MMIO;
 
         ap->ioaddr.cmd_addr     = devm_ioremap(&pdev->dev, cmd_res->start,
                                                 resource_size(cmd_res));
diff --git a/drivers/ata/pata_rb532_cf.c b/drivers/ata/pata_rb532_cf.c
index 0ffd631000b7..1b9d10d9c5d9 100644
--- a/drivers/ata/pata_rb532_cf.c
+++ b/drivers/ata/pata_rb532_cf.c
@@ -60,10 +60,10 @@ static irqreturn_t rb532_pata_irq_handler(int irq, void *dev_instance)
         struct rb532_cf_info *info = ah->private_data;
 
         if (gpio_get_value(info->gpio_line)) {
-                set_irq_type(info->irq, IRQ_TYPE_LEVEL_LOW);
+                irq_set_irq_type(info->irq, IRQ_TYPE_LEVEL_LOW);
                 ata_sff_interrupt(info->irq, dev_instance);
         } else {
-                set_irq_type(info->irq, IRQ_TYPE_LEVEL_HIGH);
+                irq_set_irq_type(info->irq, IRQ_TYPE_LEVEL_HIGH);
         }
 
         return IRQ_HANDLED;
@@ -91,7 +91,6 @@ static void rb532_pata_setup_ports(struct ata_host *ah)
 
         ap->ops         = &rb532_pata_port_ops;
         ap->pio_mask    = ATA_PIO4;
-        ap->flags       = ATA_FLAG_NO_LEGACY | ATA_FLAG_MMIO;
 
         ap->ioaddr.cmd_addr     = info->iobase + RB500_CF_REG_BASE;
         ap->ioaddr.ctl_addr     = info->iobase + RB500_CF_REG_CTRL;
diff --git a/drivers/ata/pata_rz1000.c b/drivers/ata/pata_rz1000.c
index 4a454a88aa9d..4d04471794b6 100644
--- a/drivers/ata/pata_rz1000.c
+++ b/drivers/ata/pata_rz1000.c
@@ -112,7 +112,7 @@ static int rz1000_reinit_one(struct pci_dev *pdev)
         if (rc)
                 return rc;
 
-        /* If this fails on resume (which is a "cant happen" case), we
+        /* If this fails on resume (which is a "can't happen" case), we
            must stop as any progress risks data loss */
         if (rz1000_fifo_disable(pdev))
                 panic("rz1000 fifo");
diff --git a/drivers/ata/pata_samsung_cf.c b/drivers/ata/pata_samsung_cf.c
index 6f9cfb24b751..c446ae6055a3 100644
--- a/drivers/ata/pata_samsung_cf.c
+++ b/drivers/ata/pata_samsung_cf.c
@@ -322,7 +322,7 @@ static int pata_s3c_wait_after_reset(struct ata_link *link,
 {
         int rc;
 
-        msleep(ATA_WAIT_AFTER_RESET);
+        ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
 
         /* always check readiness of the master device */
         rc = ata_sff_wait_ready(link, deadline);
@@ -531,7 +531,6 @@ static int __init pata_s3c_probe(struct platform_device *pdev)
         }
 
         ap = host->ports[0];
-        ap->flags |= ATA_FLAG_MMIO;
         ap->pio_mask = ATA_PIO4;
 
         if (cpu_type == TYPE_S3C64XX) {
diff --git a/drivers/ata/pata_scc.c b/drivers/ata/pata_scc.c
index fe36966f7e34..88ea9b677b47 100644
--- a/drivers/ata/pata_scc.c
+++ b/drivers/ata/pata_scc.c
@@ -530,7 +530,7 @@ static int scc_wait_after_reset(struct ata_link *link, unsigned int devmask,
          *
          * Old drivers/ide uses the 2mS rule and then waits for ready.
          */
-        msleep(150);
+        ata_msleep(ap, 150);
 
         /* always check readiness of the master device */
         rc = ata_sff_wait_ready(link, deadline);
@@ -559,7 +559,7 @@ static int scc_wait_after_reset(struct ata_link *link, unsigned int devmask,
                         lbal = in_be32(ioaddr->lbal_addr);
                         if ((nsect == 1) && (lbal == 1))
                                 break;
-                        msleep(50);     /* give drive a breather */
+                        ata_msleep(ap, 50);     /* give drive a breather */
                 }
 
                 rc = ata_sff_wait_ready(link, deadline);
@@ -959,7 +959,7 @@ static struct ata_port_operations scc_pata_ops = {
 
 static struct ata_port_info scc_port_info[] = {
         {
-                .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY,
+                .flags          = ATA_FLAG_SLAVE_POSS,
                 .pio_mask       = ATA_PIO4,
                 /* No MWDMA */
                 .udma_mask      = ATA_UDMA6,
diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
index d3190d7ec304..118787caa93f 100644
--- a/drivers/ata/pata_sil680.c
+++ b/drivers/ata/pata_sil680.c
@@ -11,7 +11,7 @@
  *
  *  May be copied or modified under the terms of the GNU General Public License
  *
- *  Documentation publically available.
+ *  Documentation publicly available.
  *
  *      If you have strange problems with nVidia chipset systems please
  *      see the SI support documentation and update your system BIOS
@@ -43,7 +43,7 @@
  *
  *      Turn a config register offset into the right address in either
  *      PCI space or MMIO space to access the control register in question
- *      Thankfully this is a configuration operation so isnt performance
+ *      Thankfully this is a configuration operation so isn't performance
  *      criticial.
  */
 
@@ -202,14 +202,25 @@ static void sil680_set_dmamode(struct ata_port *ap, struct ata_device *adev)
  *      LOCKING:
  *      spin_lock_irqsave(host lock)
  */
-void sil680_sff_exec_command(struct ata_port *ap,
-                                        const struct ata_taskfile *tf)
+static void sil680_sff_exec_command(struct ata_port *ap,
+                                    const struct ata_taskfile *tf)
 {
         DPRINTK("ata%u: cmd 0x%X\n", ap->print_id, tf->command);
         iowrite8(tf->command, ap->ioaddr.command_addr);
         ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
 }
 
+static bool sil680_sff_irq_check(struct ata_port *ap)
+{
+        struct pci_dev *pdev    = to_pci_dev(ap->host->dev);
+        unsigned long addr      = sil680_selreg(ap, 1);
+        u8 val;
+
+        pci_read_config_byte(pdev, addr, &val);
+
+        return val & 0x08;
+}
+
 static struct scsi_host_template sil680_sht = {
         ATA_BMDMA_SHT(DRV_NAME),
 };
@@ -218,6 +229,7 @@ static struct scsi_host_template sil680_sht = {
 static struct ata_port_operations sil680_port_ops = {
         .inherits               = &ata_bmdma32_port_ops,
         .sff_exec_command       = sil680_sff_exec_command,
+        .sff_irq_check          = sil680_sff_irq_check,
         .cable_detect           = sil680_cable_detect,
         .set_piomode            = sil680_set_piomode,
         .set_dmamode            = sil680_set_dmamode,
diff --git a/drivers/ata/pata_sis.c b/drivers/ata/pata_sis.c
index 60cea13cccce..be08ff92db17 100644
--- a/drivers/ata/pata_sis.c
+++ b/drivers/ata/pata_sis.c
@@ -331,7 +331,7 @@ static void sis_old_set_dmamode (struct ata_port *ap, struct ata_device *adev)
 
         if (adev->dma_mode < XFER_UDMA_0) {
                 /* bits 3-0 hold recovery timing bits 8-10 active timing and
-                   the higher bits are dependant on the device */
+                   the higher bits are dependent on the device */
                 timing &= ~0x870F;
                 timing |= mwdma_bits[speed];
         } else {
@@ -371,7 +371,7 @@ static void sis_66_set_dmamode (struct ata_port *ap, struct ata_device *adev)
 
         if (adev->dma_mode < XFER_UDMA_0) {
                 /* bits 3-0 hold recovery timing bits 8-10 active timing and
-                   the higher bits are dependant on the device, bit 15 udma */
+                   the higher bits are dependent on the device, bit 15 udma */
                 timing &= ~0x870F;
                 timing |= mwdma_bits[speed];
         } else {
@@ -593,7 +593,7 @@ static const struct ata_port_info sis_info133 = {
         .port_ops       = &sis_133_ops,
 };
 const struct ata_port_info sis_info133_for_sata = {
-        .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
+        .flags          = ATA_FLAG_SLAVE_POSS,
         .pio_mask       = ATA_PIO4,
         /* No MWDMA */
         .udma_mask      = ATA_UDMA6,
diff --git a/drivers/ata/pata_sl82c105.c b/drivers/ata/pata_sl82c105.c
index 98548f640c8e..7f5d020ed56c 100644
--- a/drivers/ata/pata_sl82c105.c
+++ b/drivers/ata/pata_sl82c105.c
@@ -227,6 +227,16 @@ static int sl82c105_qc_defer(struct ata_queued_cmd *qc)
         return 0;
 }
 
+static bool sl82c105_sff_irq_check(struct ata_port *ap)
+{
+        struct pci_dev *pdev    = to_pci_dev(ap->host->dev);
+        u32 val, mask           = ap->port_no ? CTRL_IDE_IRQB : CTRL_IDE_IRQA;
+
+        pci_read_config_dword(pdev, 0x40, &val);
+
+        return val & mask;
+}
+
 static struct scsi_host_template sl82c105_sht = {
         ATA_BMDMA_SHT(DRV_NAME),
 };
@@ -239,6 +249,7 @@ static struct ata_port_operations sl82c105_port_ops = {
         .cable_detect   = ata_cable_40wire,
         .set_piomode    = sl82c105_set_piomode,
         .prereset       = sl82c105_pre_reset,
+        .sff_irq_check  = sl82c105_sff_irq_check,
 };
 
 /**
diff --git a/drivers/ata/pata_triflex.c b/drivers/ata/pata_triflex.c
index 0d1f89e571dd..b3e0c9432283 100644
--- a/drivers/ata/pata_triflex.c
+++ b/drivers/ata/pata_triflex.c
@@ -30,7 +30,7 @@
  * Loosely based on the piix & svwks drivers.
  *
  * Documentation:
- *      Not publically available.
+ *      Not publicly available.
  */
 
 #include <linux/kernel.h>
@@ -210,13 +210,34 @@ static const struct pci_device_id triflex[] = {
         { },
 };
 
+#ifdef CONFIG_PM
+static int triflex_ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
+{
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        int rc = 0;
+
+        rc = ata_host_suspend(host, mesg);
+        if (rc)
+                return rc;
+
+        /*
+         * We must not disable or powerdown the device.
+         * APM bios refuses to suspend if IDE is not accessible.
+         */
+        pci_save_state(pdev);
+
+        return 0;
+}
+
+#endif
+
 static struct pci_driver triflex_pci_driver = {
         .name           = DRV_NAME,
         .id_table       = triflex,
         .probe          = triflex_init_one,
         .remove         = ata_pci_remove_one,
 #ifdef CONFIG_PM
-        .suspend        = ata_pci_device_suspend,
+        .suspend        = triflex_ata_pci_device_suspend,
         .resume         = ata_pci_device_resume,
 #endif
 };
diff --git a/drivers/ata/pdc_adma.c b/drivers/ata/pdc_adma.c
index adbe0426c8f0..1111712b3d7d 100644
--- a/drivers/ata/pdc_adma.c
+++ b/drivers/ata/pdc_adma.c
@@ -166,9 +166,7 @@ static 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_NO_LEGACY | ATA_FLAG_MMIO |
-                                  ATA_FLAG_PIO_POLLING,
+                .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_POLLING,
                 .pio_mask       = ATA_PIO4_ONLY,
                 .udma_mask      = ATA_UDMA4,
                 .port_ops       = &adma_ata_ops,
diff --git a/drivers/ata/sata_dwc_460ex.c b/drivers/ata/sata_dwc_460ex.c
index 6cf57c5c2b5f..dc88a39e7db8 100644
--- a/drivers/ata/sata_dwc_460ex.c
+++ b/drivers/ata/sata_dwc_460ex.c
@@ -40,8 +40,11 @@
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_cmnd.h>
 
+/* These two are defined in "libata.h" */
+#undef  DRV_NAME
+#undef  DRV_VERSION
 #define DRV_NAME        "sata-dwc"
-#define DRV_VERSION     "1.0"
+#define DRV_VERSION     "1.3"
 
 /* SATA DMA driver Globals */
 #define DMA_NUM_CHANS           1
@@ -333,11 +336,47 @@ static int dma_dwc_xfer_setup(struct scatterlist *sg, int num_elems,
                               void __iomem *addr, int dir);
 static void dma_dwc_xfer_start(int dma_ch);
 
+static const char *get_prot_descript(u8 protocol)
+{
+        switch ((enum ata_tf_protocols)protocol) {
+        case ATA_PROT_NODATA:
+                return "ATA no data";
+        case ATA_PROT_PIO:
+                return "ATA PIO";
+        case ATA_PROT_DMA:
+                return "ATA DMA";
+        case ATA_PROT_NCQ:
+                return "ATA NCQ";
+        case ATAPI_PROT_NODATA:
+                return "ATAPI no data";
+        case ATAPI_PROT_PIO:
+                return "ATAPI PIO";
+        case ATAPI_PROT_DMA:
+                return "ATAPI DMA";
+        default:
+                return "unknown";
+        }
+}
+
+static const char *get_dma_dir_descript(int dma_dir)
+{
+        switch ((enum dma_data_direction)dma_dir) {
+        case DMA_BIDIRECTIONAL:
+                return "bidirectional";
+        case DMA_TO_DEVICE:
+                return "to device";
+        case DMA_FROM_DEVICE:
+                return "from device";
+        default:
+                return "none";
+        }
+}
+
 static void sata_dwc_tf_dump(struct ata_taskfile *tf)
 {
         dev_vdbg(host_pvt.dwc_dev, "taskfile cmd: 0x%02x protocol: %s flags:"
-                "0x%lx device: %x\n", tf->command, ata_get_cmd_descript\
-                (tf->protocol), tf->flags, tf->device);
+                "0x%lx device: %x\n", tf->command,
+                get_prot_descript(tf->protocol), tf->flags, tf->device);
         dev_vdbg(host_pvt.dwc_dev, "feature: 0x%02x nsect: 0x%x lbal: 0x%x "
                 "lbam: 0x%x lbah: 0x%x\n", tf->feature, tf->nsect, tf->lbal,
                  tf->lbam, tf->lbah);
@@ -350,7 +389,7 @@ static void sata_dwc_tf_dump(struct ata_taskfile *tf)
 /*
  * Function: get_burst_length_encode
  * arguments: datalength: length in bytes of data
- * returns value to be programmed in register corrresponding to data length
+ * returns value to be programmed in register corresponding to data length
  * This value is effectively the log(base 2) of the length
  */
 static  int get_burst_length_encode(int datalength)
@@ -715,7 +754,7 @@ static int dma_dwc_xfer_setup(struct scatterlist *sg, int num_elems,
         /* Program the CTL register with src enable / dst enable */
         out_le32(&(host_pvt.sata_dma_regs->chan_regs[dma_ch].ctl.low),
                  DMA_CTL_LLP_SRCEN | DMA_CTL_LLP_DSTEN);
-        return 0;
+        return dma_ch;
 }
 
 /*
@@ -967,7 +1006,7 @@ static irqreturn_t sata_dwc_isr(int irq, void *dev_instance)
                 }
 
                 dev_dbg(ap->dev, "%s non-NCQ cmd interrupt, protocol: %s\n",
-                        __func__, ata_get_cmd_descript(qc->tf.protocol));
+                        __func__, get_prot_descript(qc->tf.protocol));
 DRVSTILLBUSY:
                 if (ata_is_dma(qc->tf.protocol)) {
                         /*
@@ -1057,7 +1096,7 @@ DRVSTILLBUSY:
 
                 /* Process completed command */
                 dev_dbg(ap->dev, "%s NCQ command, protocol: %s\n", __func__,
-                        ata_get_cmd_descript(qc->tf.protocol));
+                        get_prot_descript(qc->tf.protocol));
                 if (ata_is_dma(qc->tf.protocol)) {
                         host_pvt.dma_interrupt_count++;
                         if (hsdevp->dma_pending[tag] == \
@@ -1142,8 +1181,8 @@ static void sata_dwc_dma_xfer_complete(struct ata_port *ap, u32 check_status)
         if (tag > 0) {
                 dev_info(ap->dev, "%s tag=%u cmd=0x%02x dma dir=%s proto=%s "
                          "dmacr=0x%08x\n", __func__, qc->tag, qc->tf.command,
-                         ata_get_cmd_descript(qc->dma_dir),
-                         ata_get_cmd_descript(qc->tf.protocol),
+                         get_dma_dir_descript(qc->dma_dir),
+                         get_prot_descript(qc->tf.protocol),
                          in_le32(&(hsdev->sata_dwc_regs->dmacr)));
         }
 #endif
@@ -1354,7 +1393,7 @@ static void sata_dwc_exec_command_by_tag(struct ata_port *ap,
         struct sata_dwc_device_port *hsdevp = HSDEVP_FROM_AP(ap);
 
         dev_dbg(ap->dev, "%s cmd(0x%02x): %s tag=%d\n", __func__, tf->command,
-                ata_get_cmd_descript(tf), tag);
+                ata_get_cmd_descript(tf->command), tag);
 
         spin_lock_irqsave(&ap->host->lock, flags);
         hsdevp->cmd_issued[tag] = cmd_issued;
@@ -1413,7 +1452,7 @@ static void sata_dwc_bmdma_start_by_tag(struct ata_queued_cmd *qc, u8 tag)
 
         dev_dbg(ap->dev, "%s qc=%p tag: %x cmd: 0x%02x dma_dir: %s "
                 "start_dma? %x\n", __func__, qc, tag, qc->tf.command,
-                ata_get_cmd_descript(qc->dma_dir), start_dma);
+                get_dma_dir_descript(qc->dma_dir), start_dma);
         sata_dwc_tf_dump(&(qc->tf));
 
         if (start_dma) {
@@ -1462,10 +1501,9 @@ static void sata_dwc_qc_prep_by_tag(struct ata_queued_cmd *qc, u8 tag)
         int dma_chan;
         struct sata_dwc_device *hsdev = HSDEV_FROM_AP(ap);
         struct sata_dwc_device_port *hsdevp = HSDEVP_FROM_AP(ap);
-        int err;
 
         dev_dbg(ap->dev, "%s: port=%d dma dir=%s n_elem=%d\n",
-                __func__, ap->port_no, ata_get_cmd_descript(qc->dma_dir),
+                __func__, ap->port_no, get_dma_dir_descript(qc->dma_dir),
                  qc->n_elem);
 
         dma_chan = dma_dwc_xfer_setup(sg, qc->n_elem, hsdevp->llit[tag],
@@ -1474,7 +1512,7 @@ static void sata_dwc_qc_prep_by_tag(struct ata_queued_cmd *qc, u8 tag)
                                       dmadr), qc->dma_dir);
         if (dma_chan < 0) {
                 dev_err(ap->dev, "%s: dma_dwc_xfer_setup returns err %d\n",
-                        __func__, err);
+                        __func__, dma_chan);
                 return;
         }
         hsdevp->dma_chan[tag] = dma_chan;
@@ -1491,8 +1529,8 @@ static unsigned int sata_dwc_qc_issue(struct ata_queued_cmd *qc)
                 dev_info(ap->dev, "%s ap id=%d cmd(0x%02x)=%s qc tag=%d "
                          "prot=%s ap active_tag=0x%08x ap sactive=0x%08x\n",
                          __func__, ap->print_id, qc->tf.command,
-                         ata_get_cmd_descript(&qc->tf),
-                         qc->tag, ata_get_cmd_descript(qc->tf.protocol),
+                         ata_get_cmd_descript(qc->tf.command),
+                         qc->tag, get_prot_descript(qc->tf.protocol),
                          ap->link.active_tag, ap->link.sactive);
 #endif
 
@@ -1533,7 +1571,7 @@ static void sata_dwc_qc_prep(struct ata_queued_cmd *qc)
 #ifdef DEBUG_NCQ
         if (qc->tag > 0)
                 dev_info(qc->ap->dev, "%s: qc->tag=%d ap->active_tag=0x%08x\n",
-                         __func__, tag, qc->ap->link.active_tag);
+                         __func__, qc->tag, qc->ap->link.active_tag);
 
         return ;
 #endif
@@ -1580,16 +1618,14 @@ static struct ata_port_operations sata_dwc_ops = {
 
 static const struct ata_port_info sata_dwc_port_info[] = {
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_NCQ,
-                .pio_mask       = 0x1f, /* pio 0-4 */
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NCQ,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &sata_dwc_ops,
         },
 };
 
-static int sata_dwc_probe(struct platform_device *ofdev,
-                        const struct of_device_id *match)
+static int sata_dwc_probe(struct platform_device *ofdev)
 {
         struct sata_dwc_device *hsdev;
         u32 idr, versionr;
@@ -1727,7 +1763,7 @@ static const struct of_device_id sata_dwc_match[] = {
 };
 MODULE_DEVICE_TABLE(of, sata_dwc_match);
 
-static struct of_platform_driver sata_dwc_driver = {
+static struct platform_driver sata_dwc_driver = {
         .driver = {
                 .name = DRV_NAME,
                 .owner = THIS_MODULE,
@@ -1739,12 +1775,12 @@ static struct of_platform_driver sata_dwc_driver = {
 
 static int __init sata_dwc_init(void)
 {
-        return  of_register_platform_driver(&sata_dwc_driver);
+        return platform_driver_register(&sata_dwc_driver);
 }
 
 static void __exit sata_dwc_exit(void)
 {
-        of_unregister_platform_driver(&sata_dwc_driver);
+        platform_driver_unregister(&sata_dwc_driver);
 }
 
 module_init(sata_dwc_init);
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index 7325f77480dc..35a71d875d0e 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -6,7 +6,7 @@
  * Author: Ashish Kalra <ashish.kalra@freescale.com>
  * Li Yang <leoli@freescale.com>
  *
- * Copyright (c) 2006-2007 Freescale Semiconductor, Inc.
+ * Copyright (c) 2006-2007, 2011 Freescale Semiconductor, Inc.
  *
  * 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
@@ -33,8 +33,7 @@ enum {
         SATA_FSL_MAX_PRD_USABLE = SATA_FSL_MAX_PRD - 1,
         SATA_FSL_MAX_PRD_DIRECT = 16,   /* Direct PRDT entries */
 
-        SATA_FSL_HOST_FLAGS     = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
+        SATA_FSL_HOST_FLAGS     = (ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
                                 ATA_FLAG_PMP | ATA_FLAG_NCQ | ATA_FLAG_AN),
 
         SATA_FSL_MAX_CMDS       = SATA_FSL_QUEUE_DEPTH,
@@ -43,7 +42,7 @@ enum {
 
         /*
          * SATA-FSL host controller supports a max. of (15+1) direct PRDEs, and
-         * chained indirect PRDEs upto a max count of 63.
+         * chained indirect PRDEs up to a max count of 63.
          * We are allocating an array of 63 PRDEs contiguously, but PRDE#15 will
          * be setup as an indirect descriptor, pointing to it's next
          * (contiguous) PRDE. Though chained indirect PRDE arrays are
@@ -158,7 +157,8 @@ enum {
             IE_ON_SINGL_DEVICE_ERR | IE_ON_CMD_COMPLETE,
 
         EXT_INDIRECT_SEG_PRD_FLAG = (1 << 31),
-        DATA_SNOOP_ENABLE = (1 << 22),
+        DATA_SNOOP_ENABLE_V1 = (1 << 22),
+        DATA_SNOOP_ENABLE_V2 = (1 << 28),
 };
 
 /*
@@ -186,6 +186,11 @@ enum {
         COMMANDSTAT = 0x20,
 };
 
+/* TRANSCFG (transport-layer) configuration control */
+enum {
+        TRANSCFG_RX_WATER_MARK = (1 << 4),
+};
+
 /* PHY (link-layer) configuration control */
 enum {
         PHY_BIST_ENABLE = 0x01,
@@ -256,6 +261,7 @@ struct sata_fsl_host_priv {
         void __iomem *ssr_base;
         void __iomem *csr_base;
         int irq;
+        int data_snoop;
 };
 
 static inline unsigned int sata_fsl_tag(unsigned int tag,
@@ -308,7 +314,8 @@ static void sata_fsl_setup_cmd_hdr_entry(struct sata_fsl_port_priv *pp,
 }
 
 static unsigned int sata_fsl_fill_sg(struct ata_queued_cmd *qc, void *cmd_desc,
-                                     u32 *ttl, dma_addr_t cmd_desc_paddr)
+                                     u32 *ttl, dma_addr_t cmd_desc_paddr,
+                                     int data_snoop)
 {
         struct scatterlist *sg;
         unsigned int num_prde = 0;
@@ -358,8 +365,7 @@ static unsigned int sata_fsl_fill_sg(struct ata_queued_cmd *qc, void *cmd_desc,
 
                 ttl_dwords += sg_len;
                 prd->dba = cpu_to_le32(sg_addr);
-                prd->ddc_and_ext =
-                    cpu_to_le32(DATA_SNOOP_ENABLE | (sg_len & ~0x03));
+                prd->ddc_and_ext = cpu_to_le32(data_snoop | (sg_len & ~0x03));
 
                 VPRINTK("sg_fill, ttl=%d, dba=0x%x, ddc=0x%x\n",
                         ttl_dwords, prd->dba, prd->ddc_and_ext);
@@ -374,7 +380,7 @@ static unsigned int sata_fsl_fill_sg(struct ata_queued_cmd *qc, void *cmd_desc,
                 /* set indirect extension flag along with indirect ext. size */
                 prd_ptr_to_indirect_ext->ddc_and_ext =
                     cpu_to_le32((EXT_INDIRECT_SEG_PRD_FLAG |
-                                 DATA_SNOOP_ENABLE |
+                                 data_snoop |
                                  (indirect_ext_segment_sz & ~0x03)));
         }
 
@@ -417,7 +423,8 @@ static void sata_fsl_qc_prep(struct ata_queued_cmd *qc)
 
         if (qc->flags & ATA_QCFLAG_DMAMAP)
                 num_prde = sata_fsl_fill_sg(qc, (void *)cd,
-                                            &ttl_dwords, cd_paddr);
+                                            &ttl_dwords, cd_paddr,
+                                            host_priv->data_snoop);
 
         if (qc->tf.protocol == ATA_PROT_NCQ)
                 desc_info |= FPDMA_QUEUED_CMD;
@@ -678,7 +685,7 @@ static void sata_fsl_port_stop(struct ata_port *ap)
         iowrite32(temp, hcr_base + HCONTROL);
 
         /* Poll for controller to go offline - should happen immediately */
-        ata_wait_register(hcr_base + HSTATUS, ONLINE, ONLINE, 1, 1);
+        ata_wait_register(ap, hcr_base + HSTATUS, ONLINE, ONLINE, 1, 1);
 
         ap->private_data = NULL;
         dma_free_coherent(dev, SATA_FSL_PORT_PRIV_DMA_SZ,
@@ -729,7 +736,8 @@ try_offline_again:
         iowrite32(temp, hcr_base + HCONTROL);
 
         /* Poll for controller to go offline */
-        temp = ata_wait_register(hcr_base + HSTATUS, ONLINE, ONLINE, 1, 500);
+        temp = ata_wait_register(ap, hcr_base + HSTATUS, ONLINE, ONLINE,
+                                 1, 500);
 
         if (temp & ONLINE) {
                 ata_port_printk(ap, KERN_ERR,
@@ -752,7 +760,7 @@ try_offline_again:
         /*
          * PHY reset should remain asserted for atleast 1ms
          */
-        msleep(1);
+        ata_msleep(ap, 1);
 
         /*
          * Now, bring the host controller online again, this can take time
@@ -766,7 +774,7 @@ try_offline_again:
         temp |= HCONTROL_PMP_ATTACHED;
         iowrite32(temp, hcr_base + HCONTROL);
 
-        temp = ata_wait_register(hcr_base + HSTATUS, ONLINE, 0, 1, 500);
+        temp = ata_wait_register(ap, hcr_base + HSTATUS, ONLINE, 0, 1, 500);
 
         if (!(temp & ONLINE)) {
                 ata_port_printk(ap, KERN_ERR,
@@ -784,7 +792,7 @@ try_offline_again:
          * presence
          */
 
-        temp = ata_wait_register(hcr_base + HSTATUS, 0xFF, 0, 1, 500);
+        temp = ata_wait_register(ap, hcr_base + HSTATUS, 0xFF, 0, 1, 500);
         if ((!(temp & 0x10)) || ata_link_offline(link)) {
                 ata_port_printk(ap, KERN_WARNING,
                                 "No Device OR PHYRDY change,Hstatus = 0x%x\n",
@@ -797,7 +805,7 @@ try_offline_again:
          * Wait for the first D2H from device,i.e,signature update notification
          */
         start_jiffies = jiffies;
-        temp = ata_wait_register(hcr_base + HSTATUS, 0xFF, 0x10,
+        temp = ata_wait_register(ap, hcr_base + HSTATUS, 0xFF, 0x10,
                         500, jiffies_to_msecs(deadline - start_jiffies));
 
         if ((temp & 0xFF) != 0x18) {
@@ -880,7 +888,7 @@ static int sata_fsl_softreset(struct ata_link *link, unsigned int *class,
                 iowrite32(pmp, CQPMP + hcr_base);
         iowrite32(1, CQ + hcr_base);
 
-        temp = ata_wait_register(CQ + hcr_base, 0x1, 0x1, 1, 5000);
+        temp = ata_wait_register(ap, CQ + hcr_base, 0x1, 0x1, 1, 5000);
         if (temp & 0x1) {
                 ata_port_printk(ap, KERN_WARNING, "ATA_SRST issue failed\n");
 
@@ -896,10 +904,10 @@ static int sata_fsl_softreset(struct ata_link *link, unsigned int *class,
                 goto err;
         }
 
-        msleep(1);
+        ata_msleep(ap, 1);
 
         /*
-         * SATA device enters reset state after receving a Control register
+         * SATA device enters reset state after receiving a Control register
          * FIS with SRST bit asserted and it awaits another H2D Control reg.
          * FIS with SRST bit cleared, then the device does internal diags &
          * initialization, followed by indicating it's initialization status
@@ -915,7 +923,7 @@ static int sata_fsl_softreset(struct ata_link *link, unsigned int *class,
         if (pmp != SATA_PMP_CTRL_PORT)
                 iowrite32(pmp, CQPMP + hcr_base);
         iowrite32(1, CQ + hcr_base);
-        msleep(150);            /* ?? */
+        ata_msleep(ap, 150);            /* ?? */
 
         /*
          * The above command would have signalled an interrupt on command
@@ -1039,12 +1047,15 @@ static void sata_fsl_error_intr(struct ata_port *ap)
 
                 /* find out the offending link and qc */
                 if (ap->nr_pmp_links) {
+                        unsigned int dev_num;
+
                         dereg = ioread32(hcr_base + DE);
                         iowrite32(dereg, hcr_base + DE);
                         iowrite32(cereg, hcr_base + CE);
 
-                        if (dereg < ap->nr_pmp_links) {
-                                link = &ap->pmp_link[dereg];
+                        dev_num = ffs(dereg) - 1;
+                        if (dev_num < ap->nr_pmp_links && dereg != 0) {
+                                link = &ap->pmp_link[dev_num];
                                 ehi = &link->eh_info;
                                 qc = ata_qc_from_tag(ap, link->active_tag);
                                 /*
@@ -1137,17 +1148,13 @@ static void sata_fsl_host_intr(struct ata_port *ap)
                         ioread32(hcr_base + CE));
 
                 for (i = 0; i < SATA_FSL_QUEUE_DEPTH; i++) {
-                        if (done_mask & (1 << i)) {
-                                qc = ata_qc_from_tag(ap, i);
-                                if (qc) {
-                                        ata_qc_complete(qc);
-                                }
+                        if (done_mask & (1 << i))
                                 DPRINTK
                                     ("completing ncq cmd,tag=%d,CC=0x%x,CA=0x%x\n",
                                      i, ioread32(hcr_base + CC),
                                      ioread32(hcr_base + CA));
-                        }
                 }
+                ata_qc_complete_multiple(ap, ap->qc_active ^ done_mask);
                 return;
 
         } else if ((ap->qc_active & (1 << ATA_TAG_INTERNAL))) {
@@ -1296,8 +1303,7 @@ static const struct ata_port_info sata_fsl_port_info[] = {
          },
 };
 
-static int sata_fsl_probe(struct platform_device *ofdev,
-                        const struct of_device_id *match)
+static int sata_fsl_probe(struct platform_device *ofdev)
 {
         int retval = -ENXIO;
         void __iomem *hcr_base = NULL;
@@ -1306,6 +1312,7 @@ static int sata_fsl_probe(struct platform_device *ofdev,
         struct sata_fsl_host_priv *host_priv = NULL;
         int irq;
         struct ata_host *host;
+        u32 temp;
 
         struct ata_port_info pi = sata_fsl_port_info[0];
         const struct ata_port_info *ppi[] = { &pi, NULL };
@@ -1320,6 +1327,12 @@ static int sata_fsl_probe(struct platform_device *ofdev,
         ssr_base = hcr_base + 0x100;
         csr_base = hcr_base + 0x140;
 
+        if (!of_device_is_compatible(ofdev->dev.of_node, "fsl,mpc8315-sata")) {
+                temp = ioread32(csr_base + TRANSCFG);
+                temp = temp & 0xffffffe0;
+                iowrite32(temp | TRANSCFG_RX_WATER_MARK, csr_base + TRANSCFG);
+        }
+
         DPRINTK("@reset i/o = 0x%x\n", ioread32(csr_base + TRANSCFG));
         DPRINTK("sizeof(cmd_desc) = %d\n", sizeof(struct command_desc));
         DPRINTK("sizeof(#define cmd_desc) = %d\n", SATA_FSL_CMD_DESC_SIZE);
@@ -1339,6 +1352,11 @@ static int sata_fsl_probe(struct platform_device *ofdev,
         }
         host_priv->irq = irq;
 
+        if (of_device_is_compatible(ofdev->dev.of_node, "fsl,pq-sata-v2"))
+                host_priv->data_snoop = DATA_SNOOP_ENABLE_V2;
+        else
+                host_priv->data_snoop = DATA_SNOOP_ENABLE_V1;
+
         /* allocate host structure */
         host = ata_host_alloc_pinfo(&ofdev->dev, ppi, SATA_FSL_MAX_PORTS);
 
@@ -1421,12 +1439,15 @@ static struct of_device_id fsl_sata_match[] = {
         {
                 .compatible = "fsl,pq-sata",
         },
+        {
+                .compatible = "fsl,pq-sata-v2",
+        },
         {},
 };
 
 MODULE_DEVICE_TABLE(of, fsl_sata_match);
 
-static struct of_platform_driver fsl_sata_driver = {
+static struct platform_driver fsl_sata_driver = {
         .driver = {
                 .name = "fsl-sata",
                 .owner = THIS_MODULE,
@@ -1442,13 +1463,13 @@ static struct of_platform_driver fsl_sata_driver = {
 
 static int __init sata_fsl_init(void)
 {
-        of_register_platform_driver(&fsl_sata_driver);
+        platform_driver_register(&fsl_sata_driver);
         return 0;
 }
 
 static void __exit sata_fsl_exit(void)
 {
-        of_unregister_platform_driver(&fsl_sata_driver);
+        platform_driver_unregister(&fsl_sata_driver);
 }
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index a36149ebf4a2..83a44471b189 100644
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -614,7 +614,7 @@ static int inic_hardreset(struct ata_link *link, unsigned int *class,
 
         writew(IDMA_CTL_RST_ATA, idma_ctl);
         readw(idma_ctl);        /* flush */
-        msleep(1);
+        ata_msleep(ap, 1);
         writew(0, idma_ctl);
 
         rc = sata_link_resume(link, timing, deadline);
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index a9fd9709c262..b52c0519ad0b 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -160,8 +160,7 @@ enum {
         /* Host Flags */
         MV_FLAG_DUAL_HC         = (1 << 30),  /* two SATA Host Controllers */
 
-        MV_COMMON_FLAGS         = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_POLLING,
+        MV_COMMON_FLAGS         = ATA_FLAG_SATA | ATA_FLAG_PIO_POLLING,
 
         MV_GEN_I_FLAGS          = MV_COMMON_FLAGS | ATA_FLAG_NO_ATAPI,
 
@@ -1353,7 +1352,7 @@ static int mv_scr_write(struct ata_link *link, unsigned int sc_reg_in, u32 val)
                         /*
                          * Workaround for 88SX60x1 FEr SATA#26:
                          *
-                         * COMRESETs have to take care not to accidently
+                         * COMRESETs have to take care not to accidentally
                          * put the drive to sleep when writing SCR_CONTROL.
                          * Setting bits 12..15 prevents this problem.
                          *
@@ -2045,7 +2044,7 @@ static void mv_qc_prep(struct ata_queued_cmd *qc)
 
         cw = &pp->crqb[in_index].ata_cmd[0];
 
-        /* Sadly, the CRQB cannot accomodate all registers--there are
+        /* Sadly, the CRQB cannot accommodate all registers--there are
          * only 11 bytes...so we must pick and choose required
          * registers based on the command.  So, we drop feature and
          * hob_feature for [RW] DMA commands, but they are needed for
@@ -2743,18 +2742,11 @@ static void mv_err_intr(struct ata_port *ap)
         }
 }
 
-static void mv_process_crpb_response(struct ata_port *ap,
+static bool mv_process_crpb_response(struct ata_port *ap,
                 struct mv_crpb *response, unsigned int tag, int ncq_enabled)
 {
         u8 ata_status;
         u16 edma_status = le16_to_cpu(response->flags);
-        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
-
-        if (unlikely(!qc)) {
-                ata_port_printk(ap, KERN_ERR, "%s: no qc for tag=%d\n",
-                                __func__, tag);
-                return;
-        }
 
         /*
          * edma_status from a response queue entry:
@@ -2768,13 +2760,14 @@ static void mv_process_crpb_response(struct ata_port *ap,
                          * Error will be seen/handled by
                          * mv_err_intr().  So do nothing at all here.
                          */
-                        return;
+                        return false;
                 }
         }
         ata_status = edma_status >> CRPB_FLAG_STATUS_SHIFT;
         if (!ac_err_mask(ata_status))
-                ata_qc_complete(qc);
+                return true;
         /* else: leave it for mv_err_intr() */
+        return false;
 }
 
 static void mv_process_crpb_entries(struct ata_port *ap, struct mv_port_priv *pp)
@@ -2783,6 +2776,7 @@ static void mv_process_crpb_entries(struct ata_port *ap, struct mv_port_priv *pp
         struct mv_host_priv *hpriv = ap->host->private_data;
         u32 in_index;
         bool work_done = false;
+        u32 done_mask = 0;
         int ncq_enabled = (pp->pp_flags & MV_PP_FLAG_NCQ_EN);
 
         /* Get the hardware queue position index */
@@ -2803,15 +2797,19 @@ static void mv_process_crpb_entries(struct ata_port *ap, struct mv_port_priv *pp
                         /* Gen II/IIE: get command tag from CRPB entry */
                         tag = le16_to_cpu(response->id) & 0x1f;
                 }
-                mv_process_crpb_response(ap, response, tag, ncq_enabled);
+                if (mv_process_crpb_response(ap, response, tag, ncq_enabled))
+                        done_mask |= 1 << tag;
                 work_done = true;
         }
 
-        /* Update the software queue position index in hardware */
-        if (work_done)
+        if (work_done) {
+                ata_qc_complete_multiple(ap, ap->qc_active ^ done_mask);
+
+                /* Update the software queue position index in hardware */
                 writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) |
                          (pp->resp_idx << EDMA_RSP_Q_PTR_SHIFT),
                          port_mmio + EDMA_RSP_Q_OUT_PTR);
+        }
 }
 
 static void mv_port_intr(struct ata_port *ap, u32 port_cause)
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index cb89ef8d99d9..f173ef3bfc10 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -539,7 +539,7 @@ struct nv_pi_priv {
 static const struct ata_port_info nv_port_info[] = {
         /* generic */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .flags          = ATA_FLAG_SATA,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -548,7 +548,7 @@ static const struct ata_port_info nv_port_info[] = {
         },
         /* nforce2/3 */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .flags          = ATA_FLAG_SATA,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -557,7 +557,7 @@ static const struct ata_port_info nv_port_info[] = {
         },
         /* ck804 */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .flags          = ATA_FLAG_SATA,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -566,8 +566,7 @@ static const struct ata_port_info nv_port_info[] = {
         },
         /* ADMA */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_NCQ,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NCQ,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -576,7 +575,7 @@ static const struct ata_port_info nv_port_info[] = {
         },
         /* MCP5x */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+                .flags          = ATA_FLAG_SATA,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -585,8 +584,7 @@ static const struct ata_port_info nv_port_info[] = {
         },
         /* SWNCQ */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_NCQ,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NCQ,
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
@@ -873,29 +871,11 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
                         ata_port_freeze(ap);
                 else
                         ata_port_abort(ap);
-                return 1;
+                return -1;
         }
 
-        if (likely(flags & NV_CPB_RESP_DONE)) {
-                struct ata_queued_cmd *qc = ata_qc_from_tag(ap, cpb_num);
-                VPRINTK("CPB flags done, flags=0x%x\n", flags);
-                if (likely(qc)) {
-                        DPRINTK("Completing qc from tag %d\n", cpb_num);
-                        ata_qc_complete(qc);
-                } else {
-                        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. */
-                        ata_port_printk(ap, KERN_ERR,
-                                        "notifier for tag %d with no cmd?\n",
-                                        cpb_num);
-                        ehi->err_mask |= AC_ERR_HSM;
-                        ehi->action |= ATA_EH_RESET;
-                        ata_port_freeze(ap);
-                        return 1;
-                }
-        }
+        if (likely(flags & NV_CPB_RESP_DONE))
+                return 1;
         return 0;
 }
 
@@ -1018,6 +998,7 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                               NV_ADMA_STAT_CPBERR |
                               NV_ADMA_STAT_CMD_COMPLETE)) {
                         u32 check_commands = notifier_clears[i];
+                        u32 done_mask = 0;
                         int pos, rc;
 
                         if (status & NV_ADMA_STAT_CPBERR) {
@@ -1034,10 +1015,13 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                                 pos--;
                                 rc = nv_adma_check_cpb(ap, pos,
                                                 notifier_error & (1 << pos));
-                                if (unlikely(rc))
+                                if (rc > 0)
+                                        done_mask |= 1 << pos;
+                                else if (unlikely(rc < 0))
                                         check_commands = 0;
                                 check_commands &= ~(1 << pos);
                         }
+                        ata_qc_complete_multiple(ap, ap->qc_active ^ done_mask);
                 }
         }
 
@@ -2132,13 +2116,12 @@ static int nv_swncq_sdbfis(struct ata_port *ap)
         struct ata_eh_info *ehi = &ap->link.eh_info;
         u32 sactive;
         u32 done_mask;
-        int i;
         u8 host_stat;
         u8 lack_dhfis = 0;
 
         host_stat = ap->ops->bmdma_status(ap);
         if (unlikely(host_stat & ATA_DMA_ERR)) {
-                /* error when transfering data to/from memory */
+                /* error when transferring data to/from memory */
                 ata_ehi_clear_desc(ehi);
                 ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat);
                 ehi->err_mask |= AC_ERR_HOST_BUS;
@@ -2152,27 +2135,11 @@ static int nv_swncq_sdbfis(struct ata_port *ap)
         sactive = readl(pp->sactive_block);
         done_mask = pp->qc_active ^ sactive;
 
-        if (unlikely(done_mask & sactive)) {
-                ata_ehi_clear_desc(ehi);
-                ata_ehi_push_desc(ehi, "illegal SWNCQ:qc_active transition"
-                                  "(%08x->%08x)", pp->qc_active, sactive);
-                ehi->err_mask |= AC_ERR_HSM;
-                ehi->action |= ATA_EH_RESET;
-                return -EINVAL;
-        }
-        for (i = 0; i < ATA_MAX_QUEUE; i++) {
-                if (!(done_mask & (1 << i)))
-                        continue;
-
-                qc = ata_qc_from_tag(ap, i);
-                if (qc) {
-                        ata_qc_complete(qc);
-                        pp->qc_active &= ~(1 << i);
-                        pp->dhfis_bits &= ~(1 << i);
-                        pp->dmafis_bits &= ~(1 << i);
-                        pp->sdbfis_bits |= (1 << i);
-                }
-        }
+        pp->qc_active &= ~done_mask;
+        pp->dhfis_bits &= ~done_mask;
+        pp->dmafis_bits &= ~done_mask;
+        pp->sdbfis_bits |= done_mask;
+        ata_qc_complete_multiple(ap, ap->qc_active ^ done_mask);
 
         if (!ap->qc_active) {
                 DPRINTK("over\n");
diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index f03ad48273ff..a004b1e0ea6d 100644
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -134,9 +134,7 @@ enum {
         PDC_IRQ_DISABLE         = (1 << 10),
         PDC_RESET               = (1 << 11), /* HDMA reset */
 
-        PDC_COMMON_FLAGS        = ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO |
-                                  ATA_FLAG_PIO_POLLING,
+        PDC_COMMON_FLAGS        = ATA_FLAG_PIO_POLLING,
 
         /* ap->flags bits */
         PDC_FLAG_GEN_II         = (1 << 24),
diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index daeebf19a6a9..c5603265fa58 100644
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -155,8 +155,7 @@ static struct ata_port_operations qs_ata_ops = {
 static const struct ata_port_info qs_port_info[] = {
         /* board_2068_idx */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_POLLING,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_PIO_POLLING,
                 .pio_mask       = ATA_PIO4_ONLY,
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &qs_ata_ops,
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 3a4f84219719..b42edaaf3a53 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -61,8 +61,7 @@ enum {
         SIL_FLAG_RERR_ON_DMA_ACT = (1 << 29),
         SIL_FLAG_MOD15WRITE     = (1 << 30),
 
-        SIL_DFL_PORT_FLAGS      = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO,
+        SIL_DFL_PORT_FLAGS      = ATA_FLAG_SATA,
 
         /*
          * Controller IDs
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index be7726d7686d..06c564e55051 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -244,8 +244,7 @@ enum {
         BID_SIL3131             = 2,
 
         /* host flags */
-        SIL24_COMMON_FLAGS      = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
+        SIL24_COMMON_FLAGS      = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
                                   ATA_FLAG_NCQ | ATA_FLAG_ACPI_SATA |
                                   ATA_FLAG_AN | ATA_FLAG_PMP,
         SIL24_FLAG_PCIX_IRQ_WOC = (1 << 24), /* IRQ loss errata on PCI-X */
@@ -589,9 +588,9 @@ static int sil24_init_port(struct ata_port *ap)
                 sil24_clear_pmp(ap);
 
         writel(PORT_CS_INIT, port + PORT_CTRL_STAT);
-        ata_wait_register(port + PORT_CTRL_STAT,
+        ata_wait_register(ap, port + PORT_CTRL_STAT,
                           PORT_CS_INIT, PORT_CS_INIT, 10, 100);
-        tmp = ata_wait_register(port + PORT_CTRL_STAT,
+        tmp = ata_wait_register(ap, port + PORT_CTRL_STAT,
                                 PORT_CS_RDY, 0, 10, 100);
 
         if ((tmp & (PORT_CS_INIT | PORT_CS_RDY)) != PORT_CS_RDY) {
@@ -631,7 +630,7 @@ static int sil24_exec_polled_cmd(struct ata_port *ap, int pmp,
         writel((u64)paddr >> 32, port + PORT_CMD_ACTIVATE + 4);
 
         irq_mask = (PORT_IRQ_COMPLETE | PORT_IRQ_ERROR) << PORT_IRQ_RAW_SHIFT;
-        irq_stat = ata_wait_register(port + PORT_IRQ_STAT, irq_mask, 0x0,
+        irq_stat = ata_wait_register(ap, port + PORT_IRQ_STAT, irq_mask, 0x0,
                                      10, timeout_msec);
 
         writel(irq_mask, port + PORT_IRQ_STAT); /* clear IRQs */
@@ -719,9 +718,9 @@ static int sil24_hardreset(struct ata_link *link, unsigned int *class,
                                 "state, performing PORT_RST\n");
 
                 writel(PORT_CS_PORT_RST, port + PORT_CTRL_STAT);
-                msleep(10);
+                ata_msleep(ap, 10);
                 writel(PORT_CS_PORT_RST, port + PORT_CTRL_CLR);
-                ata_wait_register(port + PORT_CTRL_STAT, PORT_CS_RDY, 0,
+                ata_wait_register(ap, port + PORT_CTRL_STAT, PORT_CS_RDY, 0,
                                   10, 5000);
 
                 /* restore port configuration */
@@ -740,7 +739,7 @@ static int sil24_hardreset(struct ata_link *link, unsigned int *class,
                 tout_msec = 5000;
 
         writel(PORT_CS_DEV_RST, port + PORT_CTRL_STAT);
-        tmp = ata_wait_register(port + PORT_CTRL_STAT,
+        tmp = ata_wait_register(ap, port + PORT_CTRL_STAT,
                                 PORT_CS_DEV_RST, PORT_CS_DEV_RST, 10,
                                 tout_msec);
 
@@ -1253,7 +1252,7 @@ static void sil24_init_controller(struct ata_host *host)
                 tmp = readl(port + PORT_CTRL_STAT);
                 if (tmp & PORT_CS_PORT_RST) {
                         writel(PORT_CS_PORT_RST, port + PORT_CTRL_CLR);
-                        tmp = ata_wait_register(port + PORT_CTRL_STAT,
+                        tmp = ata_wait_register(NULL, port + PORT_CTRL_STAT,
                                                 PORT_CS_PORT_RST,
                                                 PORT_CS_PORT_RST, 10, 100);
                         if (tmp & PORT_CS_PORT_RST)
diff --git a/drivers/ata/sata_sis.c b/drivers/ata/sata_sis.c
index 2bfe3ae03976..cdcc13e9cf51 100644
--- a/drivers/ata/sata_sis.c
+++ b/drivers/ata/sata_sis.c
@@ -96,7 +96,7 @@ static struct ata_port_operations sis_ops = {
 };
 
 static const struct ata_port_info sis_port_info = {
-        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+        .flags          = ATA_FLAG_SATA,
         .pio_mask       = ATA_PIO4,
         .mwdma_mask     = ATA_MWDMA2,
         .udma_mask      = ATA_UDMA6,
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index 7d9db4aaf07e..35eabcf34568 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -359,8 +359,7 @@ static struct ata_port_operations k2_sata_ops = {
 static const struct ata_port_info k2_port_info[] = {
         /* chip_svw4 */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | K2_FLAG_NO_ATAPI_DMA,
+                .flags          = ATA_FLAG_SATA | K2_FLAG_NO_ATAPI_DMA,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA6,
@@ -368,8 +367,7 @@ static const struct ata_port_info k2_port_info[] = {
         },
         /* chip_svw8 */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | K2_FLAG_NO_ATAPI_DMA |
+                .flags          = ATA_FLAG_SATA | K2_FLAG_NO_ATAPI_DMA |
                                   K2_FLAG_SATA_8_PORTS,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
@@ -378,8 +376,7 @@ static const struct ata_port_info k2_port_info[] = {
         },
         /* chip_svw42 */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO | K2_FLAG_BAR_POS_3,
+                .flags          = ATA_FLAG_SATA | K2_FLAG_BAR_POS_3,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA6,
@@ -387,8 +384,7 @@ static const struct ata_port_info k2_port_info[] = {
         },
         /* chip_svw43 */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO,
+                .flags          = ATA_FLAG_SATA,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA6,
diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index bedd5188e5b0..8fd3b7252bda 100644
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -273,9 +273,8 @@ static struct ata_port_operations pdc_20621_ops = {
 static const struct ata_port_info pdc_port_info[] = {
         /* board_20621 */
         {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
-                                  ATA_FLAG_NO_ATAPI | ATA_FLAG_PIO_POLLING,
+                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_ATAPI |
+                                  ATA_FLAG_PIO_POLLING,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA6,
diff --git a/drivers/ata/sata_uli.c b/drivers/ata/sata_uli.c
index b8578c32d344..235be717a713 100644
--- a/drivers/ata/sata_uli.c
+++ b/drivers/ata/sata_uli.c
@@ -88,8 +88,7 @@ static struct ata_port_operations uli_ops = {
 };
 
 static const struct ata_port_info uli_port_info = {
-        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                          ATA_FLAG_IGN_SIMPLEX,
+        .flags          = ATA_FLAG_SATA | ATA_FLAG_IGN_SIMPLEX,
         .pio_mask       = ATA_PIO4,
         .udma_mask      = ATA_UDMA6,
         .port_ops       = &uli_ops,
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index 4730c42a5ee5..54434db15b12 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -148,7 +148,7 @@ static struct ata_port_operations vt8251_ops = {
 };
 
 static const struct ata_port_info vt6420_port_info = {
-        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+        .flags          = ATA_FLAG_SATA,
         .pio_mask       = ATA_PIO4,
         .mwdma_mask     = ATA_MWDMA2,
         .udma_mask      = ATA_UDMA6,
@@ -156,7 +156,7 @@ static const struct ata_port_info vt6420_port_info = {
 };
 
 static struct ata_port_info vt6421_sport_info = {
-        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+        .flags          = ATA_FLAG_SATA,
         .pio_mask       = ATA_PIO4,
         .mwdma_mask     = ATA_MWDMA2,
         .udma_mask      = ATA_UDMA6,
@@ -164,7 +164,7 @@ static struct ata_port_info vt6421_sport_info = {
 };
 
 static struct ata_port_info vt6421_pport_info = {
-        .flags          = ATA_FLAG_SLAVE_POSS | ATA_FLAG_NO_LEGACY,
+        .flags          = ATA_FLAG_SLAVE_POSS,
         .pio_mask       = ATA_PIO4,
         /* No MWDMA */
         .udma_mask      = ATA_UDMA6,
@@ -172,8 +172,7 @@ static struct ata_port_info vt6421_pport_info = {
 };
 
 static struct ata_port_info vt8251_port_info = {
-        .flags          = ATA_FLAG_SATA | ATA_FLAG_SLAVE_POSS |
-                          ATA_FLAG_NO_LEGACY,
+        .flags          = ATA_FLAG_SATA | ATA_FLAG_SLAVE_POSS,
         .pio_mask       = ATA_PIO4,
         .mwdma_mask     = ATA_MWDMA2,
         .udma_mask      = ATA_UDMA6,
@@ -349,7 +348,7 @@ static int vt6420_prereset(struct ata_link *link, unsigned long deadline)
 
         /* wait for phy to become ready, if necessary */
         do {
-                msleep(200);
+                ata_msleep(link->ap, 200);
                 svia_scr_read(link, SCR_STATUS, &sstatus);
                 if ((sstatus & 0xf) != 1)
                         break;
@@ -538,7 +537,7 @@ static int vt8251_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
         return 0;
 }
 
-static void svia_configure(struct pci_dev *pdev)
+static void svia_configure(struct pci_dev *pdev, int board_id)
 {
         u8 tmp8;
 
@@ -577,13 +576,13 @@ static void svia_configure(struct pci_dev *pdev)
         }
 
         /*
-         * vt6421 has problems talking to some drives.  The following
+         * vt6420/1 has problems talking to some drives.  The following
          * is the fix from Joseph Chan <JosephChan@via.com.tw>.
          *
          * When host issues HOLD, device may send up to 20DW of data
          * before acknowledging it with HOLDA and the host should be
          * able to buffer them in FIFO.  Unfortunately, some WD drives
-         * send upto 40DW before acknowledging HOLD and, in the
+         * send up to 40DW before acknowledging HOLD and, in the
          * default configuration, this ends up overflowing vt6421's
          * FIFO, making the controller abort the transaction with
          * R_ERR.
@@ -596,8 +595,9 @@ static void svia_configure(struct pci_dev *pdev)
          *
          * https://bugzilla.kernel.org/show_bug.cgi?id=15173
          * http://article.gmane.org/gmane.linux.ide/46352
+         * http://thread.gmane.org/gmane.linux.kernel/1062139
          */
-        if (pdev->device == 0x3249) {
+        if (board_id == vt6420 || board_id == vt6421) {
                 pci_read_config_byte(pdev, 0x52, &tmp8);
                 tmp8 |= 1 << 2;
                 pci_write_config_byte(pdev, 0x52, tmp8);
@@ -652,7 +652,7 @@ static int svia_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc)
                 return rc;
 
-        svia_configure(pdev);
+        svia_configure(pdev, board_id);
 
         pci_set_master(pdev);
         return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index b777176ff494..7c987371136e 100644
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -340,8 +340,7 @@ static int __devinit vsc_sata_init_one(struct pci_dev *pdev,
                                        const struct pci_device_id *ent)
 {
         static const struct ata_port_info pi = {
-                .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO,
+                .flags          = ATA_FLAG_SATA,
                 .pio_mask       = ATA_PIO4,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA6,
@@ -370,7 +369,7 @@ static int __devinit vsc_sata_init_one(struct pci_dev *pdev,
         if (pci_resource_len(pdev, 0) == 0)
                 return -ENODEV;
 
-        /* map IO regions and intialize host accordingly */
+        /* map IO regions and initialize host accordingly */
         rc = pcim_iomap_regions(pdev, 1 << VSC_MMIO_BAR, DRV_NAME);
         if (rc == -EBUSY)
                 pcim_pin_device(pdev);