8 files changed, 87 insertions, 38 deletions

diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 73f883333a0d..aa85a98d3a4f 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -168,10 +168,10 @@ config ATA_BMDMA
         default y
         help
           This option adds support for SFF ATA controllers with BMDMA
-          capability.  BMDMA stands for bus-master DMA and the
-          de-facto DMA interface for SFF controllers.
+          capability.  BMDMA stands for bus-master DMA and is the
+          de facto DMA interface for SFF controllers.
 
-          If unuser, say Y.
+          If unsure, say Y.
 
 if ATA_BMDMA
 
diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c
index 1984a6e89e84..261f86d102e8 100644
--- a/drivers/ata/libahci.c
+++ b/drivers/ata/libahci.c
@@ -541,29 +541,11 @@ static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
         return -EINVAL;
 }
 
-static int ahci_is_device_present(void __iomem *port_mmio)
-{
-        u8 status = readl(port_mmio + PORT_TFDATA) & 0xff;
-
-        /* Make sure PxTFD.STS.BSY and PxTFD.STS.DRQ are 0 */
-        if (status & (ATA_BUSY | ATA_DRQ))
-                return 0;
-
-        /* Make sure PxSSTS.DET is 3h */
-        status = readl(port_mmio + PORT_SCR_STAT) & 0xf;
-        if (status != 3)
-                return 0;
-        return 1;
-}
-
 void ahci_start_engine(struct ata_port *ap)
 {
         void __iomem *port_mmio = ahci_port_base(ap);
         u32 tmp;
 
-        if (!ahci_is_device_present(port_mmio))
-                return;
-
         /* start DMA */
         tmp = readl(port_mmio + PORT_CMD);
         tmp |= PORT_CMD_START;
@@ -1892,6 +1874,9 @@ static void ahci_error_handler(struct ata_port *ap)
         }
 
         sata_pmp_error_handler(ap);
+
+        if (!ata_dev_enabled(ap->link.device))
+                ahci_stop_engine(ap);
 }
 
 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc)
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 06b7e49e039c..ddf8e4862787 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -4119,9 +4119,8 @@ int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
             dev->n_sectors > n_sectors && dev->n_sectors == n_native_sectors) {
                 ata_dev_printk(dev, KERN_WARNING,
                                "new n_sectors matches native, probably "
-                               "late HPA unlock, continuing\n");
-                /* keep using the old n_sectors */
-                dev->n_sectors = n_sectors;
+                               "late HPA unlock, n_sectors updated\n");
+                /* use the larger n_sectors */
                 return 0;
         }
 
@@ -6669,6 +6668,7 @@ EXPORT_SYMBOL_GPL(ata_dummy_port_info);
 EXPORT_SYMBOL_GPL(ata_link_next);
 EXPORT_SYMBOL_GPL(ata_dev_next);
 EXPORT_SYMBOL_GPL(ata_std_bios_param);
+EXPORT_SYMBOL_GPL(ata_scsi_unlock_native_capacity);
 EXPORT_SYMBOL_GPL(ata_host_init);
 EXPORT_SYMBOL_GPL(ata_host_alloc);
 EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index cfa9dd3d7253..a54273d2c3c6 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -415,6 +415,35 @@ int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
 }
 
 /**
+ *      ata_scsi_unlock_native_capacity - unlock native capacity
+ *      @sdev: SCSI device to adjust device capacity for
+ *
+ *      This function is called if a partition on @sdev extends beyond
+ *      the end of the device.  It requests EH to unlock HPA.
+ *
+ *      LOCKING:
+ *      Defined by the SCSI layer.  Might sleep.
+ */
+void ata_scsi_unlock_native_capacity(struct scsi_device *sdev)
+{
+        struct ata_port *ap = ata_shost_to_port(sdev->host);
+        struct ata_device *dev;
+        unsigned long flags;
+
+        spin_lock_irqsave(ap->lock, flags);
+
+        dev = ata_scsi_find_dev(ap, sdev);
+        if (dev && dev->n_sectors < dev->n_native_sectors) {
+                dev->flags |= ATA_DFLAG_UNLOCK_HPA;
+                dev->link->eh_info.action |= ATA_EH_RESET;
+                ata_port_schedule_eh(ap);
+        }
+
+        spin_unlock_irqrestore(ap->lock, flags);
+        ata_port_wait_eh(ap);
+}
+
+/**
  *      ata_get_identity - Handler for HDIO_GET_IDENTITY ioctl
  *      @ap: target port
  *      @sdev: SCSI device to get identify data for
diff --git a/drivers/ata/pata_macio.c b/drivers/ata/pata_macio.c
index 76640ac76888..75b49d01780b 100644
--- a/drivers/ata/pata_macio.c
+++ b/drivers/ata/pata_macio.c
@@ -1355,8 +1355,11 @@ static struct of_device_id pata_macio_match[] =
 
 static struct macio_driver pata_macio_driver =
 {
-        .name           = "pata-macio",
-        .match_table    = pata_macio_match,
+        .driver = {
+                .name           = "pata-macio",
+                .owner          = THIS_MODULE,
+                .of_match_table = pata_macio_match,
+        },
         .probe          = pata_macio_attach,
         .remove         = pata_macio_detach,
 #ifdef CONFIG_PM
@@ -1366,9 +1369,6 @@ static struct macio_driver pata_macio_driver =
 #ifdef CONFIG_PMAC_MEDIABAY
         .mediabay_event = pata_macio_mb_event,
 #endif
-        .driver = {
-                .owner          = THIS_MODULE,
-        },
 };
 
 static const struct pci_device_id pata_macio_pci_match[] = {
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 6fd114784116..21161136cad0 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -1669,7 +1669,6 @@ static void nv_mcp55_freeze(struct ata_port *ap)
         mask = readl(mmio_base + NV_INT_ENABLE_MCP55);
         mask &= ~(NV_INT_ALL_MCP55 << shift);
         writel(mask, mmio_base + NV_INT_ENABLE_MCP55);
-        ata_sff_freeze(ap);
 }
 
 static void nv_mcp55_thaw(struct ata_port *ap)
@@ -1683,7 +1682,6 @@ static void nv_mcp55_thaw(struct ata_port *ap)
         mask = readl(mmio_base + NV_INT_ENABLE_MCP55);
         mask |= (NV_INT_MASK_MCP55 << shift);
         writel(mask, mmio_base + NV_INT_ENABLE_MCP55);
-        ata_sff_thaw(ap);
 }
 
 static void nv_adma_error_handler(struct ata_port *ap)
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index e9250514734b..be7726d7686d 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -539,12 +539,12 @@ static void sil24_config_port(struct ata_port *ap)
                 writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_CLR);
 
         /* zero error counters. */
-        writel(0x8000, port + PORT_DECODE_ERR_THRESH);
-        writel(0x8000, port + PORT_CRC_ERR_THRESH);
-        writel(0x8000, port + PORT_HSHK_ERR_THRESH);
-        writel(0x0000, port + PORT_DECODE_ERR_CNT);
-        writel(0x0000, port + PORT_CRC_ERR_CNT);
-        writel(0x0000, port + PORT_HSHK_ERR_CNT);
+        writew(0x8000, port + PORT_DECODE_ERR_THRESH);
+        writew(0x8000, port + PORT_CRC_ERR_THRESH);
+        writew(0x8000, port + PORT_HSHK_ERR_THRESH);
+        writew(0x0000, port + PORT_DECODE_ERR_CNT);
+        writew(0x0000, port + PORT_CRC_ERR_CNT);
+        writew(0x0000, port + PORT_HSHK_ERR_CNT);
 
         /* always use 64bit activation */
         writel(PORT_CS_32BIT_ACTV, port + PORT_CTRL_CLR);
@@ -622,6 +622,11 @@ static int sil24_exec_polled_cmd(struct ata_port *ap, int pmp,
         irq_enabled = readl(port + PORT_IRQ_ENABLE_SET);
         writel(PORT_IRQ_COMPLETE | PORT_IRQ_ERROR, port + PORT_IRQ_ENABLE_CLR);
 
+        /*
+         * The barrier is required to ensure that writes to cmd_block reach
+         * the memory before the write to PORT_CMD_ACTIVATE.
+         */
+        wmb();
         writel((u32)paddr, port + PORT_CMD_ACTIVATE);
         writel((u64)paddr >> 32, port + PORT_CMD_ACTIVATE + 4);
 
@@ -865,7 +870,7 @@ static void sil24_qc_prep(struct ata_queued_cmd *qc)
         } else {
                 prb = &cb->atapi.prb;
                 sge = cb->atapi.sge;
-                memset(cb->atapi.cdb, 0, 32);
+                memset(cb->atapi.cdb, 0, sizeof(cb->atapi.cdb));
                 memcpy(cb->atapi.cdb, qc->cdb, qc->dev->cdb_len);
 
                 if (ata_is_data(qc->tf.protocol)) {
@@ -895,6 +900,11 @@ static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc)
         paddr = pp->cmd_block_dma + tag * sizeof(*pp->cmd_block);
         activate = port + PORT_CMD_ACTIVATE + tag * 8;
 
+        /*
+         * The barrier is required to ensure that writes to cmd_block reach
+         * the memory before the write to PORT_CMD_ACTIVATE.
+         */
+        wmb();
         writel((u32)paddr, activate);
         writel((u64)paddr >> 32, activate + 4);
 
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index 101d8c219caf..4730c42a5ee5 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -575,6 +575,33 @@ static void svia_configure(struct pci_dev *pdev)
                 tmp8 |= NATIVE_MODE_ALL;
                 pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
         }
+
+        /*
+         * vt6421 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
+         * default configuration, this ends up overflowing vt6421's
+         * FIFO, making the controller abort the transaction with
+         * R_ERR.
+         *
+         * Rx52[2] is the internal 128DW FIFO Flow control watermark
+         * adjusting mechanism enable bit and the default value 0
+         * means host will issue HOLD to device when the left FIFO
+         * size goes below 32DW.  Setting it to 1 makes the watermark
+         * 64DW.
+         *
+         * https://bugzilla.kernel.org/show_bug.cgi?id=15173
+         * http://article.gmane.org/gmane.linux.ide/46352
+         */
+        if (pdev->device == 0x3249) {
+                pci_read_config_byte(pdev, 0x52, &tmp8);
+                tmp8 |= 1 << 2;
+                pci_write_config_byte(pdev, 0x52, tmp8);
+        }
 }
 
 static int svia_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)