20 files changed, 201 insertions, 104 deletions

diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index da21552d2b1c..1c94b43d2c9b 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -19,6 +19,10 @@ config ATA
 
 if ATA
 
+config ATA_NONSTANDARD
+       bool
+       default n
+
 config SATA_AHCI
         tristate "AHCI SATA support"
         depends on PCI
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index b517d2493551..48616c6fee9d 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -75,6 +75,7 @@ enum {
         AHCI_CMD_CLR_BUSY       = (1 << 10),
 
         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 */
 
         board_ahci              = 0,
@@ -202,6 +203,10 @@ struct ahci_port_priv {
         dma_addr_t              cmd_tbl_dma;
         void                    *rx_fis;
         dma_addr_t              rx_fis_dma;
+        /* for NCQ spurious interrupt analysis */
+        int                     ncq_saw_spurious_sdb_cnt;
+        unsigned int            ncq_saw_d2h:1;
+        unsigned int            ncq_saw_dmas:1;
 };
 
 static u32 ahci_scr_read (struct ata_port *ap, unsigned int sc_reg);
@@ -361,7 +366,7 @@ static const struct pci_device_id ahci_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, 0x27c1), board_ahci }, /* ICH7 */
         { PCI_VDEVICE(INTEL, 0x27c5), board_ahci }, /* ICH7M */
         { PCI_VDEVICE(INTEL, 0x27c3), board_ahci }, /* ICH7R */
-        { PCI_VDEVICE(AL, 0x5288), board_ahci }, /* ULi M5288 */
+        { PCI_VDEVICE(AL, 0x5288), board_ahci_ign_iferr }, /* ULi M5288 */
         { PCI_VDEVICE(INTEL, 0x2681), board_ahci }, /* ESB2 */
         { PCI_VDEVICE(INTEL, 0x2682), board_ahci }, /* ESB2 */
         { PCI_VDEVICE(INTEL, 0x2683), board_ahci }, /* ESB2 */
@@ -586,35 +591,18 @@ static void ahci_power_down(void __iomem *port_mmio, u32 cap)
 {
         u32 cmd, scontrol;
 
-        cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK;
-
-        if (cap & HOST_CAP_SSC) {
-                /* enable transitions to slumber mode */
-                scontrol = readl(port_mmio + PORT_SCR_CTL);
-                if ((scontrol & 0x0f00) > 0x100) {
-                        scontrol &= ~0xf00;
-                        writel(scontrol, port_mmio + PORT_SCR_CTL);
-                }
-
-                /* put device into slumber mode */
-                writel(cmd | PORT_CMD_ICC_SLUMBER, port_mmio + PORT_CMD);
-
-                /* wait for the transition to complete */
-                ata_wait_register(port_mmio + PORT_CMD, PORT_CMD_ICC_SLUMBER,
-                                  PORT_CMD_ICC_SLUMBER, 1, 50);
-        }
+        if (!(cap & HOST_CAP_SSS))
+                return;
 
-        /* put device into listen mode */
-        if (cap & HOST_CAP_SSS) {
-                /* first set PxSCTL.DET to 0 */
-                scontrol = readl(port_mmio + PORT_SCR_CTL);
-                scontrol &= ~0xf;
-                writel(scontrol, port_mmio + PORT_SCR_CTL);
+        /* put device into listen mode, first set PxSCTL.DET to 0 */
+        scontrol = readl(port_mmio + PORT_SCR_CTL);
+        scontrol &= ~0xf;
+        writel(scontrol, port_mmio + PORT_SCR_CTL);
 
-                /* then set PxCMD.SUD to 0 */
-                cmd &= ~PORT_CMD_SPIN_UP;
-                writel(cmd, port_mmio + PORT_CMD);
-        }
+        /* then set PxCMD.SUD to 0 */
+        cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK;
+        cmd &= ~PORT_CMD_SPIN_UP;
+        writel(cmd, port_mmio + PORT_CMD);
 }
 
 static void ahci_init_port(void __iomem *port_mmio, u32 cap,
@@ -915,7 +903,7 @@ static int ahci_hardreset(struct ata_port *ap, unsigned int *class)
 
         /* clear D2H reception area to properly wait for D2H FIS */
         ata_tf_init(ap->device, &tf);
-        tf.command = 0xff;
+        tf.command = 0x80;
         ata_tf_to_fis(&tf, d2h_fis, 0);
 
         rc = sata_std_hardreset(ap, class);
@@ -1126,8 +1114,9 @@ static void ahci_host_intr(struct ata_port *ap)
         void __iomem *mmio = ap->host->mmio_base;
         void __iomem *port_mmio = ahci_port_base(mmio, ap->port_no);
         struct ata_eh_info *ehi = &ap->eh_info;
+        struct ahci_port_priv *pp = ap->private_data;
         u32 status, qc_active;
-        int rc;
+        int rc, known_irq = 0;
 
         status = readl(port_mmio + PORT_IRQ_STAT);
         writel(status, port_mmio + PORT_IRQ_STAT);
@@ -1154,17 +1143,53 @@ static void ahci_host_intr(struct ata_port *ap)
 
         /* hmmm... a spurious interupt */
 
-        /* some devices send D2H reg with I bit set during NCQ command phase */
-        if (ap->sactive && (status & PORT_IRQ_D2H_REG_FIS))
+        /* if !NCQ, ignore.  No modern ATA device has broken HSM
+         * implementation for non-NCQ commands.
+         */
+        if (!ap->sactive)
                 return;
 
-        /* ignore interim PIO setup fis interrupts */
-        if (ata_tag_valid(ap->active_tag) && (status & PORT_IRQ_PIOS_FIS))
-                return;
+        if (status & PORT_IRQ_D2H_REG_FIS) {
+                if (!pp->ncq_saw_d2h)
+                        ata_port_printk(ap, KERN_INFO,
+                                "D2H reg with I during NCQ, "
+                                "this message won't be printed again\n");
+                pp->ncq_saw_d2h = 1;
+                known_irq = 1;
+        }
+
+        if (status & PORT_IRQ_DMAS_FIS) {
+                if (!pp->ncq_saw_dmas)
+                        ata_port_printk(ap, KERN_INFO,
+                                "DMAS FIS during NCQ, "
+                                "this message won't be printed again\n");
+                pp->ncq_saw_dmas = 1;
+                known_irq = 1;
+        }
+
+        if (status & PORT_IRQ_SDB_FIS &&
+                   pp->ncq_saw_spurious_sdb_cnt < 10) {
+                /* SDB FIS containing spurious completions might be
+                 * dangerous, we need to know more about them.  Print
+                 * more of it.
+                 */
+                const u32 *f = pp->rx_fis + RX_FIS_SDB;
+
+                ata_port_printk(ap, KERN_INFO, "Spurious SDB FIS during NCQ "
+                                "issue=0x%x SAct=0x%x FIS=%08x:%08x%s\n",
+                                readl(port_mmio + PORT_CMD_ISSUE),
+                                readl(port_mmio + PORT_SCR_ACT),
+                                le32_to_cpu(f[0]), le32_to_cpu(f[1]),
+                                pp->ncq_saw_spurious_sdb_cnt < 10 ?
+                                "" : ", shutting up");
+
+                pp->ncq_saw_spurious_sdb_cnt++;
+                known_irq = 1;
+        }
 
-        if (ata_ratelimit())
+        if (!known_irq)
                 ata_port_printk(ap, KERN_INFO, "spurious interrupt "
-                                "(irq_stat 0x%x active_tag %d sactive 0x%x)\n",
+                                "(irq_stat 0x%x active_tag 0x%x sactive 0x%x)\n",
                                 status, ap->active_tag, ap->sactive);
 }
 
@@ -1257,7 +1282,7 @@ static void ahci_thaw(struct ata_port *ap)
         /* clear IRQ */
         tmp = readl(port_mmio + PORT_IRQ_STAT);
         writel(tmp, port_mmio + PORT_IRQ_STAT);
-        writel(1 << ap->id, mmio + HOST_IRQ_STAT);
+        writel(1 << ap->port_no, mmio + HOST_IRQ_STAT);
 
         /* turn IRQ back on */
         writel(DEF_PORT_IRQ, port_mmio + PORT_IRQ_MASK);
diff --git a/drivers/ata/ata_generic.c b/drivers/ata/ata_generic.c
index 908751d27e76..24af56081b5d 100644
--- a/drivers/ata/ata_generic.c
+++ b/drivers/ata/ata_generic.c
@@ -64,6 +64,7 @@ static void generic_error_handler(struct ata_port *ap)
 /**
  *      generic_set_mode        -       mode setting
  *      @ap: interface to set up
+ *      @unused: returned device on error
  *
  *      Use a non standard set_mode function. We don't want to be tuned.
  *      The BIOS configured everything. Our job is not to fiddle. We
@@ -71,7 +72,7 @@ static void generic_error_handler(struct ata_port *ap)
  *      and respect them.
  */
 
-static void generic_set_mode(struct ata_port *ap)
+static int generic_set_mode(struct ata_port *ap, struct ata_device **unused)
 {
         int dma_enabled = 0;
         int i;
@@ -82,7 +83,7 @@ static void generic_set_mode(struct ata_port *ap)
 
         for (i = 0; i < ATA_MAX_DEVICES; i++) {
                 struct ata_device *dev = &ap->device[i];
-                if (ata_dev_enabled(dev)) {
+                if (ata_dev_ready(dev)) {
                         /* We don't really care */
                         dev->pio_mode = XFER_PIO_0;
                         dev->dma_mode = XFER_MW_DMA_0;
@@ -99,6 +100,7 @@ static void generic_set_mode(struct ata_port *ap)
                         }
                 }
         }
+        return 0;
 }
 
 static struct scsi_host_template generic_sht = {
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 0d51d13b16bf..cf707029352e 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -1037,7 +1037,7 @@ static unsigned int ata_id_xfermask(const u16 *id)
                  * the PIO timing number for the maximum. Turn it into
                  * a mask.
                  */
-                u8 mode = id[ATA_ID_OLD_PIO_MODES] & 0xFF;
+                u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
                 if (mode < 5)   /* Valid PIO range */
                         pio_mask = (2 << mode) - 1;
                 else
@@ -2431,18 +2431,8 @@ int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
         int i, rc = 0, used_dma = 0, found = 0;
 
         /* has private set_mode? */
-        if (ap->ops->set_mode) {
-                /* FIXME: make ->set_mode handle no device case and
-                 * return error code and failing device on failure.
-                 */
-                for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                        if (ata_dev_ready(&ap->device[i])) {
-                                ap->ops->set_mode(ap);
-                                break;
-                        }
-                }
-                return 0;
-        }
+        if (ap->ops->set_mode)
+                return ap->ops->set_mode(ap, r_failed_dev);
 
         /* step 1: calculate xfer_mask */
         for (i = 0; i < ATA_MAX_DEVICES; i++) {
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 08ad44b3e48f..748435807d68 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -1796,7 +1796,7 @@ static int ata_eh_suspend(struct ata_port *ap, struct ata_device **r_failed_dev)
                 *r_failed_dev = dev;
 
         DPRINTK("EXIT\n");
-        return 0;
+        return rc;
 }
 
 /**
@@ -1979,6 +1979,10 @@ static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
 
                 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
 
+                /* collect port action mask recorded in dev actions */
+                ehc->i.action |= ehc->i.dev_action[i] & ~ATA_EH_PERDEV_MASK;
+                ehc->i.dev_action[i] &= ATA_EH_PERDEV_MASK;
+
                 /* process hotplug request */
                 if (dev->flags & ATA_DFLAG_DETACH)
                         ata_eh_detach_dev(dev);
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 836947da5b14..73902d335767 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -273,8 +273,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
 {
         int rc = 0;
         u8 scsi_cmd[MAX_COMMAND_SIZE];
-        u8 args[7];
-        struct scsi_sense_hdr sshdr;
+        u8 args[7], *sensebuf = NULL;
+        int cmd_result;
 
         if (arg == NULL)
                 return -EINVAL;
@@ -282,10 +282,14 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
         if (copy_from_user(args, arg, sizeof(args)))
                 return -EFAULT;
 
+        sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
+        if (!sensebuf)
+                return -ENOMEM;
+
         memset(scsi_cmd, 0, sizeof(scsi_cmd));
         scsi_cmd[0]  = ATA_16;
         scsi_cmd[1]  = (3 << 1); /* Non-data */
-        /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
+        scsi_cmd[2]  = 0x20;     /* cc but no off.line or data xfer */
         scsi_cmd[4]  = args[1];
         scsi_cmd[6]  = args[2];
         scsi_cmd[8]  = args[3];
@@ -295,11 +299,46 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
 
         /* Good values for timeout and retries?  Values below
            from scsi_ioctl_send_command() for default case... */
-        if (scsi_execute_req(scsidev, scsi_cmd, DMA_NONE, NULL, 0, &sshdr,
-                             (10*HZ), 5))
+        cmd_result = scsi_execute(scsidev, scsi_cmd, DMA_NONE, NULL, 0,
+                                sensebuf, (10*HZ), 5, 0);
+
+        if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
+                u8 *desc = sensebuf + 8;
+                cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
+
+                /* If we set cc then ATA pass-through will cause a
+                 * check condition even if no error. Filter that. */
+                if (cmd_result & SAM_STAT_CHECK_CONDITION) {
+                        struct scsi_sense_hdr sshdr;
+                        scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
+                                                &sshdr);
+                        if (sshdr.sense_key==0 &&
+                                sshdr.asc==0 && sshdr.ascq==0)
+                                cmd_result &= ~SAM_STAT_CHECK_CONDITION;
+                }
+
+                /* Send userspace ATA registers */
+                if (sensebuf[0] == 0x72 &&      /* format is "descriptor" */
+                                desc[0] == 0x09) {/* code is "ATA Descriptor" */
+                        args[0] = desc[13];     /* status */
+                        args[1] = desc[3];      /* error */
+                        args[2] = desc[5];      /* sector count (0:7) */
+                        args[3] = desc[7];      /* lbal */
+                        args[4] = desc[9];      /* lbam */
+                        args[5] = desc[11];     /* lbah */
+                        args[6] = desc[12];     /* select */
+                        if (copy_to_user(arg, args, sizeof(args)))
+                                rc = -EFAULT;
+                }
+        }
+
+        if (cmd_result) {
                 rc = -EIO;
+                goto error;
+        }
 
-        /* Need code to retrieve data from check condition? */
+ error:
+        kfree(sensebuf);
         return rc;
 }
 
@@ -372,7 +411,7 @@ struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
                 if (cmd->use_sg) {
                         qc->__sg = (struct scatterlist *) cmd->request_buffer;
                         qc->n_elem = cmd->use_sg;
-                } else {
+                } else if (cmd->request_bufflen) {
                         qc->__sg = &qc->sgent;
                         qc->n_elem = 1;
                 }
@@ -983,11 +1022,10 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
                 }
 
                 tf->command = ATA_CMD_VERIFY;   /* READ VERIFY */
-        } else {
-                tf->nsect = 0;  /* time period value (0 implies now) */
-                tf->command = ATA_CMD_STANDBY;
-                /* Consider: ATA STANDBY IMMEDIATE command */
-        }
+        } else
+                /* Issue ATA STANDBY IMMEDIATE command */
+                tf->command = ATA_CMD_STANDBYNOW1;
+
         /*
          * Standby and Idle condition timers could be implemented but that
          * would require libata to implement the Power condition mode page
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 623cec914c9b..12c88c588039 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -827,7 +827,8 @@ void ata_bmdma_error_handler(struct ata_port *ap)
  */
 void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc)
 {
-        ata_bmdma_stop(qc);
+        if (qc->ap->ioaddr.bmdma_addr)
+                ata_bmdma_stop(qc);
 }
 
 #ifdef CONFIG_PCI
@@ -870,7 +871,8 @@ ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int
                         pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
                 bmdma = pci_resource_start(pdev, 4);
                 if (bmdma) {
-                        if (inb(bmdma + 2) & 0x80)
+                        if ((!(port[p]->flags & ATA_FLAG_IGN_SIMPLEX)) &&
+                            (inb(bmdma + 2) & 0x80))
                                 probe_ent->_host_flags |= ATA_HOST_SIMPLEX;
                         probe_ent->port[p].bmdma_addr = bmdma;
                 }
@@ -886,7 +888,8 @@ ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int
                 bmdma = pci_resource_start(pdev, 4);
                 if (bmdma) {
                         bmdma += 8;
-                        if(inb(bmdma + 2) & 0x80)
+                        if ((!(port[p]->flags & ATA_FLAG_IGN_SIMPLEX)) &&
+                            (inb(bmdma + 2) & 0x80))
                                 probe_ent->_host_flags |= ATA_HOST_SIMPLEX;
                         probe_ent->port[p].bmdma_addr = bmdma;
                 }
@@ -914,13 +917,14 @@ static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev,
         probe_ent->irq_flags = IRQF_SHARED;
 
         if (port_mask & ATA_PORT_PRIMARY) {
-                probe_ent->irq = ATA_PRIMARY_IRQ;
+                probe_ent->irq = ATA_PRIMARY_IRQ(pdev);
                 probe_ent->port[0].cmd_addr = ATA_PRIMARY_CMD;
                 probe_ent->port[0].altstatus_addr =
                 probe_ent->port[0].ctl_addr = ATA_PRIMARY_CTL;
                 if (bmdma) {
                         probe_ent->port[0].bmdma_addr = bmdma;
-                        if (inb(bmdma + 2) & 0x80)
+                        if ((!(port[0]->flags & ATA_FLAG_IGN_SIMPLEX)) &&
+                            (inb(bmdma + 2) & 0x80))
                                 probe_ent->_host_flags |= ATA_HOST_SIMPLEX;
                 }
                 ata_std_ports(&probe_ent->port[0]);
@@ -929,15 +933,16 @@ static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev,
 
         if (port_mask & ATA_PORT_SECONDARY) {
                 if (probe_ent->irq)
-                        probe_ent->irq2 = ATA_SECONDARY_IRQ;
+                        probe_ent->irq2 = ATA_SECONDARY_IRQ(pdev);
                 else
-                        probe_ent->irq = ATA_SECONDARY_IRQ;
+                        probe_ent->irq = ATA_SECONDARY_IRQ(pdev);
                 probe_ent->port[1].cmd_addr = ATA_SECONDARY_CMD;
                 probe_ent->port[1].altstatus_addr =
                 probe_ent->port[1].ctl_addr = ATA_SECONDARY_CTL;
                 if (bmdma) {
                         probe_ent->port[1].bmdma_addr = bmdma + 8;
-                        if (inb(bmdma + 10) & 0x80)
+                        if ((!(port[1]->flags & ATA_FLAG_IGN_SIMPLEX)) &&
+                            (inb(bmdma + 10) & 0x80))
                                 probe_ent->_host_flags |= ATA_HOST_SIMPLEX;
                 }
                 ata_std_ports(&probe_ent->port[1]);
diff --git a/drivers/ata/pata_cmd64x.c b/drivers/ata/pata_cmd64x.c
index 15841a563694..449162cbf93e 100644
--- a/drivers/ata/pata_cmd64x.c
+++ b/drivers/ata/pata_cmd64x.c
@@ -197,7 +197,7 @@ static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
 static void cmd64x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 {
         static const u8 udma_data[] = {
-                0x31, 0x21, 0x11, 0x25, 0x15, 0x05
+                0x30, 0x20, 0x10, 0x20, 0x10, 0x00
         };
         static const u8 mwdma_data[] = {
                 0x30, 0x20, 0x10
@@ -213,12 +213,21 @@ static void cmd64x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
         pci_read_config_byte(pdev, pciD, &regD);
         pci_read_config_byte(pdev, pciU, &regU);
 
-        regD &= ~(0x20 << shift);
-        regU &= ~(0x35 << shift);
+        /* DMA bits off */
+        regD &= ~(0x20 << adev->devno);
+        /* DMA control bits */
+        regU &= ~(0x30 << shift);
+        /* DMA timing bits */
+        regU &= ~(0x05 << adev->devno);
 
-        if (adev->dma_mode >= XFER_UDMA_0)
+        if (adev->dma_mode >= XFER_UDMA_0) {
+                /* Merge thge timing value */
                 regU |= udma_data[adev->dma_mode - XFER_UDMA_0] << shift;
-        else
+                /* Merge the control bits */
+                regU |= 1 << adev->devno; /* UDMA on */
+                if (adev->dma_mode > 2) /* 15nS timing */
+                        regU |= 4 << adev->devno;
+        } else
                 regD |= mwdma_data[adev->dma_mode - XFER_MW_DMA_0] << shift;
 
         regD |= 0x20 << adev->devno;
@@ -239,8 +248,8 @@ static void cmd648_bmdma_stop(struct ata_queued_cmd *qc)
         struct ata_port *ap = qc->ap;
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         u8 dma_intr;
-        int dma_reg = ap->port_no ? ARTTIM23_INTR_CH1 : CFR_INTR_CH0;
-        int dma_mask = ap->port_no ? ARTTIM2 : CFR;
+        int dma_mask = ap->port_no ? ARTTIM23_INTR_CH1 : CFR_INTR_CH0;
+        int dma_reg = ap->port_no ? ARTTIM2 : CFR;
 
         ata_bmdma_stop(qc);
 
diff --git a/drivers/ata/pata_hpt3x2n.c b/drivers/ata/pata_hpt3x2n.c
index f6817b4093a4..886fab9aa62c 100644
--- a/drivers/ata/pata_hpt3x2n.c
+++ b/drivers/ata/pata_hpt3x2n.c
@@ -25,7 +25,7 @@
 #include <linux/libata.h>
 
 #define DRV_NAME        "pata_hpt3x2n"
-#define DRV_VERSION     "0.3"
+#define DRV_VERSION     "0.3.2"
 
 enum {
         HPT_PCI_FAST    =       (1 << 31),
@@ -297,11 +297,11 @@ static int hpt3x2n_pair_idle(struct ata_port *ap)
         return 0;
 }
 
-static int hpt3x2n_use_dpll(struct ata_port *ap, int reading)
+static int hpt3x2n_use_dpll(struct ata_port *ap, int writing)
 {
         long flags = (long)ap->host->private_data;
         /* See if we should use the DPLL */
-        if (reading == 0)
+        if (writing)
                 return USE_DPLL;        /* Needed for write */
         if (flags & PCI66)
                 return USE_DPLL;        /* Needed at 66Mhz */
diff --git a/drivers/ata/pata_it821x.c b/drivers/ata/pata_it821x.c
index 0b56ff3d1cfe..e8afd486434a 100644
--- a/drivers/ata/pata_it821x.c
+++ b/drivers/ata/pata_it821x.c
@@ -476,6 +476,7 @@ static unsigned int it821x_passthru_qc_issue_prot(struct ata_queued_cmd *qc)
 /**
  *      it821x_smart_set_mode   -       mode setting
  *      @ap: interface to set up
+ *      @unused: device that failed (error only)
  *
  *      Use a non standard set_mode function. We don't want to be tuned.
  *      The BIOS configured everything. Our job is not to fiddle. We
@@ -483,7 +484,7 @@ static unsigned int it821x_passthru_qc_issue_prot(struct ata_queued_cmd *qc)
  *      and respect them.
  */
 
-static void it821x_smart_set_mode(struct ata_port *ap)
+static int it821x_smart_set_mode(struct ata_port *ap, struct ata_device **unused)
 {
         int dma_enabled = 0;
         int i;
@@ -512,6 +513,7 @@ static void it821x_smart_set_mode(struct ata_port *ap)
                         }
                 }
         }
+        return 0;
 }
 
 /**
diff --git a/drivers/ata/pata_ixp4xx_cf.c b/drivers/ata/pata_ixp4xx_cf.c
index cb8924109f59..23b8aab3ebd8 100644
--- a/drivers/ata/pata_ixp4xx_cf.c
+++ b/drivers/ata/pata_ixp4xx_cf.c
@@ -23,9 +23,9 @@
 #include <scsi/scsi_host.h>
 
 #define DRV_NAME        "pata_ixp4xx_cf"
-#define DRV_VERSION     "0.1.1"
+#define DRV_VERSION     "0.1.1ac1"
 
-static void ixp4xx_set_mode(struct ata_port *ap)
+static int ixp4xx_set_mode(struct ata_port *ap, struct ata_device *adev)
 {
         int i;
 
@@ -38,6 +38,7 @@ static void ixp4xx_set_mode(struct ata_port *ap)
                         dev->flags |= ATA_DFLAG_PIO;
                 }
         }
+        return 0;
 }
 
 static void ixp4xx_phy_reset(struct ata_port *ap)
diff --git a/drivers/ata/pata_legacy.c b/drivers/ata/pata_legacy.c
index e7bf9d89c8ee..581cb33c6f45 100644
--- a/drivers/ata/pata_legacy.c
+++ b/drivers/ata/pata_legacy.c
@@ -96,6 +96,7 @@ static int pio_mask = 0x1F;		/* PIO range for autospeed devices */
 /**
  *      legacy_set_mode         -       mode setting
  *      @ap: IDE interface
+ *      @unused: Device that failed when error is returned
  *
  *      Use a non standard set_mode function. We don't want to be tuned.
  *
@@ -105,7 +106,7 @@ static int pio_mask = 0x1F;		/* PIO range for autospeed devices */
  *      expand on this as per hdparm in the base kernel.
  */
 
-static void legacy_set_mode(struct ata_port *ap)
+static int legacy_set_mode(struct ata_port *ap, struct ata_device **unused)
 {
         int i;
 
@@ -118,6 +119,7 @@ static void legacy_set_mode(struct ata_port *ap)
                         dev->flags |= ATA_DFLAG_PIO;
                 }
         }
+        return 0;
 }
 
 static struct scsi_host_template legacy_sht = {
diff --git a/drivers/ata/pata_platform.c b/drivers/ata/pata_platform.c
index 443b1d85c6c4..40ae11cbfda4 100644
--- a/drivers/ata/pata_platform.c
+++ b/drivers/ata/pata_platform.c
@@ -30,7 +30,7 @@ static int pio_mask = 1;
  * Provide our own set_mode() as we don't want to change anything that has
  * already been configured..
  */
-static void pata_platform_set_mode(struct ata_port *ap)
+static int pata_platform_set_mode(struct ata_port *ap, struct ata_device **unused)
 {
         int i;
 
@@ -44,6 +44,7 @@ static void pata_platform_set_mode(struct ata_port *ap)
                         dev->flags |= ATA_DFLAG_PIO;
                 }
         }
+        return 0;
 }
 
 static void pata_platform_host_stop(struct ata_host *host)
diff --git a/drivers/ata/pata_rz1000.c b/drivers/ata/pata_rz1000.c
index adf4cc134f25..cec0729225e1 100644
--- a/drivers/ata/pata_rz1000.c
+++ b/drivers/ata/pata_rz1000.c
@@ -52,19 +52,20 @@ static void rz1000_error_handler(struct ata_port *ap)
 /**
  *      rz1000_set_mode         -       mode setting function
  *      @ap: ATA interface
+ *      @unused: returned device on set_mode failure
  *
  *      Use a non standard set_mode function. We don't want to be tuned. We
  *      would prefer to be BIOS generic but for the fact our hardware is
  *      whacked out.
  */
 
-static void rz1000_set_mode(struct ata_port *ap)
+static int rz1000_set_mode(struct ata_port *ap, struct ata_device **unused)
 {
         int i;
 
         for (i = 0; i < ATA_MAX_DEVICES; i++) {
                 struct ata_device *dev = &ap->device[i];
-                if (ata_dev_enabled(dev)) {
+                if (ata_dev_ready(dev)) {
                         /* We don't really care */
                         dev->pio_mode = XFER_PIO_0;
                         dev->xfer_mode = XFER_PIO_0;
@@ -72,6 +73,7 @@ static void rz1000_set_mode(struct ata_port *ap)
                         dev->flags |= ATA_DFLAG_PIO;
                 }
         }
+        return 0;
 }
 
 
diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
index 32cf0bfa8921..e8dfd8fc3ff7 100644
--- a/drivers/ata/pata_sil680.c
+++ b/drivers/ata/pata_sil680.c
@@ -135,7 +135,7 @@ static void sil680_error_handler(struct ata_port *ap)
 static void sil680_set_piomode(struct ata_port *ap, struct ata_device *adev)
 {
         static u16 speed_p[5] = { 0x328A, 0x2283, 0x1104, 0x10C3, 0x10C1 };
-        static u16 speed_t[5] = { 0x328A, 0x1281, 0x1281, 0x10C3, 0x10C1 };
+        static u16 speed_t[5] = { 0x328A, 0x2283, 0x1281, 0x10C3, 0x10C1 };
 
         unsigned long tfaddr = sil680_selreg(ap, 0x02);
         unsigned long addr = sil680_seldev(ap, adev, 0x04);
diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index f0d4f7e9ed31..0219419cae97 100644
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -95,6 +95,7 @@ static const struct via_isa_bridge {
         u8 rev_max;
         u16 flags;
 } via_isa_bridges[] = {
+        { "vt8237s",    PCI_DEVICE_ID_VIA_8237S,    0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
         { "vt8251",     PCI_DEVICE_ID_VIA_8251,     0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
         { "cx700",      PCI_DEVICE_ID_VIA_CX700,    0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
         { "vt6410",     PCI_DEVICE_ID_VIA_6410,     0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST | VIA_NO_ENABLES},
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index 1b8e0eb9e032..aae0b5201c1e 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -523,8 +523,7 @@ static const struct ata_port_info mv_port_info[] = {
         },
         {  /* chip_7042 */
                 .sht            = &mv_sht,
-                .flags          = (MV_COMMON_FLAGS | MV_6XXX_FLAGS |
-                                   MV_FLAG_DUAL_HC),
+                .flags          = (MV_COMMON_FLAGS | MV_6XXX_FLAGS),
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = 0x7f, /* udma0-6 */
                 .port_ops       = &mv_iie_ops,
@@ -545,6 +544,8 @@ static const struct pci_device_id mv_pci_tbl[] = {
 
         { PCI_VDEVICE(ADAPTEC2, 0x0241), chip_604x },
 
+        { PCI_VDEVICE(TTI, 0x2310), chip_7042 },
+
         { }                     /* terminate list */
 };
 
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index f6d498e1cf80..f7a963eb1f02 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -700,7 +700,6 @@ static void nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
 static int nv_host_intr(struct ata_port *ap, u8 irq_stat)
 {
         struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
-        int handled;
 
         /* freeze if hotplugged */
         if (unlikely(irq_stat & (NV_INT_ADDED | NV_INT_REMOVED))) {
@@ -719,13 +718,7 @@ static int nv_host_intr(struct ata_port *ap, u8 irq_stat)
         }
 
         /* handle interrupt */
-        handled = ata_host_intr(ap, qc);
-        if (unlikely(!handled)) {
-                /* spurious, clear it */
-                ata_check_status(ap);
-        }
-
-        return 1;
+        return ata_host_intr(ap, qc);
 }
 
 static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
@@ -752,6 +745,11 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                         if (pp->flags & NV_ADMA_PORT_REGISTER_MODE) {
                                 u8 irq_stat = readb(host->mmio_base + NV_INT_STATUS_CK804)
                                         >> (NV_INT_PORT_SHIFT * i);
+                                if(ata_tag_valid(ap->active_tag))
+                                        /** NV_INT_DEV indication seems unreliable at times
+                                            at least in ADMA mode. Force it on always when a
+                                            command is active, to prevent losing interrupts. */
+                                        irq_stat |= NV_INT_DEV;
                                 handled += nv_host_intr(ap, irq_stat);
                                 continue;
                         }
diff --git a/drivers/ata/sata_uli.c b/drivers/ata/sata_uli.c
index 5c603ca3a50a..a43aec62d505 100644
--- a/drivers/ata/sata_uli.c
+++ b/drivers/ata/sata_uli.c
@@ -128,7 +128,8 @@ static const struct ata_port_operations uli_ops = {
 
 static struct ata_port_info uli_port_info = {
         .sht            = &uli_sht,
-        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
+        .flags          = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                          ATA_FLAG_IGN_SIMPLEX,
         .pio_mask       = 0x1f,         /* pio0-4 */
         .udma_mask      = 0x7f,         /* udma0-6 */
         .port_ops       = &uli_ops,
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index 1c7f19aecc25..d3d5c0d57032 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -74,9 +74,11 @@ enum {
 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
 static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg);
 static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static void svia_noop_freeze(struct ata_port *ap);
 static void vt6420_error_handler(struct ata_port *ap);
 
 static const struct pci_device_id svia_pci_tbl[] = {
+        { PCI_VDEVICE(VIA, 0x5337), vt6420 },
         { PCI_VDEVICE(VIA, 0x0591), vt6420 },
         { PCI_VDEVICE(VIA, 0x3149), vt6420 },
         { PCI_VDEVICE(VIA, 0x3249), vt6421 },
@@ -127,7 +129,7 @@ static const struct ata_port_operations vt6420_sata_ops = {
         .qc_issue               = ata_qc_issue_prot,
         .data_xfer              = ata_pio_data_xfer,
 
-        .freeze                 = ata_bmdma_freeze,
+        .freeze                 = svia_noop_freeze,
         .thaw                   = ata_bmdma_thaw,
         .error_handler          = vt6420_error_handler,
         .post_internal_cmd      = ata_bmdma_post_internal_cmd,
@@ -203,6 +205,15 @@ static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
         outl(val, ap->ioaddr.scr_addr + (4 * sc_reg));
 }
 
+static void svia_noop_freeze(struct ata_port *ap)
+{
+        /* Some VIA controllers choke if ATA_NIEN is manipulated in
+         * certain way.  Leave it alone and just clear pending IRQ.
+         */
+        ata_chk_status(ap);
+        ata_bmdma_irq_clear(ap);
+}
+
 /**
  *      vt6420_prereset - prereset for vt6420
  *      @ap: target ATA port