Merge branch 'upstream'

4 files changed, 189 insertions, 139 deletions

diff --git a/drivers/scsi/esp.c b/drivers/scsi/esp.c
index f6900538be90..87a8c3d2072c 100644
--- a/drivers/scsi/esp.c
+++ b/drivers/scsi/esp.c
@@ -2068,14 +2068,12 @@ static int esp_reset(struct scsi_cmnd *SCptr)
 {
         struct esp *esp = (struct esp *) SCptr->device->host->hostdata;
 
+        spin_lock_irq(esp->ehost->host_lock);
         (void) esp_do_resetbus(esp);
-
         spin_unlock_irq(esp->ehost->host_lock);
 
         wait_event(esp->reset_queue, (esp->resetting_bus == 0));
 
-        spin_lock_irq(esp->ehost->host_lock);
-
         return SUCCESS;
 }
 
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index 8b83c4e45208..9de1e285e0b2 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -61,7 +61,6 @@
 
 #include "libata.h"
 
-static void ata_dev_reread_id(struct ata_port *ap, struct ata_device *dev);
 static unsigned int ata_dev_init_params(struct ata_port *ap,
                                         struct ata_device *dev);
 static void ata_set_mode(struct ata_port *ap);
@@ -896,42 +895,36 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
 }
 
 /**
- *      ata_dev_identify - obtain IDENTIFY x DEVICE page
- *      @ap: port on which device we wish to probe resides
- *      @device: device bus address, starting at zero
- *
- *      Following bus reset, we issue the IDENTIFY [PACKET] DEVICE
- *      command, and read back the 512-byte device information page.
- *      The device information page is fed to us via the standard
- *      PIO-IN protocol, but we hand-code it here. (TODO: investigate
- *      using standard PIO-IN paths)
- *
- *      After reading the device information page, we use several
- *      bits of information from it to initialize data structures
- *      that will be used during the lifetime of the ata_device.
- *      Other data from the info page is used to disqualify certain
- *      older ATA devices we do not wish to support.
+ *      ata_dev_read_id - Read ID data from the specified device
+ *      @ap: port on which target device resides
+ *      @dev: target device
+ *      @p_class: pointer to class of the target device (may be changed)
+ *      @post_reset: is this read ID post-reset?
+ *      @id: buffer to fill IDENTIFY page into
+ *
+ *      Read ID data from the specified device.  ATA_CMD_ID_ATA is
+ *      performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
+ *      devices.  This function also takes care of EDD signature
+ *      misreporting (to be removed once EDD support is gone) and
+ *      issues ATA_CMD_INIT_DEV_PARAMS for pre-ATA4 drives.
  *
  *      LOCKING:
- *      Inherited from caller.  Some functions called by this function
- *      obtain the host_set lock.
+ *      Kernel thread context (may sleep)
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
  */
-
-static void ata_dev_identify(struct ata_port *ap, unsigned int device)
+static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
+                           unsigned int *p_class, int post_reset, u16 *id)
 {
-        struct ata_device *dev = &ap->device[device];
-        unsigned int major_version;
-        unsigned long xfer_modes;
+        unsigned int class = *p_class;
         unsigned int using_edd;
         struct ata_taskfile tf;
-        unsigned int err_mask;
-        int i, rc;
+        unsigned int err_mask = 0;
+        const char *reason;
+        int rc;
 
-        if (!ata_dev_present(dev)) {
-                DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
-                        ap->id, device);
-                return;
-        }
+        DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
 
         if (ap->ops->probe_reset ||
             ap->flags & (ATA_FLAG_SRST | ATA_FLAG_SATA_RESET))
@@ -939,30 +932,33 @@ static void ata_dev_identify(struct ata_port *ap, unsigned int device)
         else
                 using_edd = 1;
 
-        DPRINTK("ENTER, host %u, dev %u\n", ap->id, device);
-
-        WARN_ON(dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ATAPI &&
-                dev->class != ATA_DEV_NONE);
-
-        ata_dev_select(ap, device, 1, 1); /* select device 0/1 */
+        ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
 
-retry:
-        ata_tf_init(ap, &tf, device);
+ retry:
+        ata_tf_init(ap, &tf, dev->devno);
 
-        if (dev->class == ATA_DEV_ATA) {
+        switch (class) {
+        case ATA_DEV_ATA:
                 tf.command = ATA_CMD_ID_ATA;
-                DPRINTK("do ATA identify\n");
-        } else {
+                break;
+        case ATA_DEV_ATAPI:
                 tf.command = ATA_CMD_ID_ATAPI;
-                DPRINTK("do ATAPI identify\n");
+                break;
+        default:
+                rc = -ENODEV;
+                reason = "unsupported class";
+                goto err_out;
         }
 
         tf.protocol = ATA_PROT_PIO;
 
         err_mask = ata_exec_internal(ap, dev, &tf, DMA_FROM_DEVICE,
-                                     dev->id, sizeof(dev->id));
+                                     id, sizeof(id[0]) * ATA_ID_WORDS);
 
         if (err_mask) {
+                rc = -EIO;
+                reason = "I/O error";
+
                 if (err_mask & ~AC_ERR_DEV)
                         goto err_out;
 
@@ -977,25 +973,105 @@ retry:
                  * ATA software reset (SRST, the default) does not appear
                  * to have this problem.
                  */
-                if ((using_edd) && (dev->class == ATA_DEV_ATA)) {
+                if ((using_edd) && (class == ATA_DEV_ATA)) {
                         u8 err = tf.feature;
                         if (err & ATA_ABORTED) {
-                                dev->class = ATA_DEV_ATAPI;
+                                class = ATA_DEV_ATAPI;
                                 goto retry;
                         }
                 }
                 goto err_out;
         }
 
-        swap_buf_le16(dev->id, ATA_ID_WORDS);
+        swap_buf_le16(id, ATA_ID_WORDS);
 
         /* print device capabilities */
         printk(KERN_DEBUG "ata%u: dev %u cfg "
                "49:%04x 82:%04x 83:%04x 84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
-               ap->id, device, dev->id[49],
-               dev->id[82], dev->id[83], dev->id[84],
-               dev->id[85], dev->id[86], dev->id[87],
-               dev->id[88]);
+               ap->id, dev->devno,
+               id[49], id[82], id[83], id[84], id[85], id[86], id[87], id[88]);
+
+        /* sanity check */
+        if ((class == ATA_DEV_ATA) != ata_id_is_ata(id)) {
+                rc = -EINVAL;
+                reason = "device reports illegal type";
+                goto err_out;
+        }
+
+        if (post_reset && class == ATA_DEV_ATA) {
+                /*
+                 * The exact sequence expected by certain pre-ATA4 drives is:
+                 * SRST RESET
+                 * IDENTIFY
+                 * INITIALIZE DEVICE PARAMETERS
+                 * anything else..
+                 * Some drives were very specific about that exact sequence.
+                 */
+                if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
+                        err_mask = ata_dev_init_params(ap, dev);
+                        if (err_mask) {
+                                rc = -EIO;
+                                reason = "INIT_DEV_PARAMS failed";
+                                goto err_out;
+                        }
+
+                        /* current CHS translation info (id[53-58]) might be
+                         * changed. reread the identify device info.
+                         */
+                        post_reset = 0;
+                        goto retry;
+                }
+        }
+
+        *p_class = class;
+        return 0;
+
+ err_out:
+        printk(KERN_WARNING "ata%u: dev %u failed to IDENTIFY (%s)\n",
+               ap->id, dev->devno, reason);
+        kfree(id);
+        return rc;
+}
+
+/**
+ *      ata_dev_identify - obtain IDENTIFY x DEVICE page
+ *      @ap: port on which device we wish to probe resides
+ *      @device: device bus address, starting at zero
+ *
+ *      Following bus reset, we issue the IDENTIFY [PACKET] DEVICE
+ *      command, and read back the 512-byte device information page.
+ *      The device information page is fed to us via the standard
+ *      PIO-IN protocol, but we hand-code it here. (TODO: investigate
+ *      using standard PIO-IN paths)
+ *
+ *      After reading the device information page, we use several
+ *      bits of information from it to initialize data structures
+ *      that will be used during the lifetime of the ata_device.
+ *      Other data from the info page is used to disqualify certain
+ *      older ATA devices we do not wish to support.
+ *
+ *      LOCKING:
+ *      Inherited from caller.  Some functions called by this function
+ *      obtain the host_set lock.
+ */
+
+static void ata_dev_identify(struct ata_port *ap, unsigned int device)
+{
+        struct ata_device *dev = &ap->device[device];
+        unsigned long xfer_modes;
+        int i, rc;
+
+        if (!ata_dev_present(dev)) {
+                DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
+                        ap->id, device);
+                return;
+        }
+
+        DPRINTK("ENTER, host %u, dev %u\n", ap->id, device);
+
+        rc = ata_dev_read_id(ap, dev, &dev->class, 1, dev->id);
+        if (rc)
+                goto err_out;
 
         /*
          * common ATA, ATAPI feature tests
@@ -1020,34 +1096,6 @@ retry:
         if (dev->class == ATA_DEV_ATA) {
                 dev->n_sectors = ata_id_n_sectors(dev->id);
 
-                if (!ata_id_is_ata(dev->id))    /* sanity check */
-                        goto err_out_nosup;
-
-                /* get major version */
-                major_version = ata_id_major_version(dev->id);
-
-                /*
-                 * The exact sequence expected by certain pre-ATA4 drives is:
-                 * SRST RESET
-                 * IDENTIFY
-                 * INITIALIZE DEVICE PARAMETERS
-                 * anything else..
-                 * Some drives were very specific about that exact sequence.
-                 */
-                if (major_version < 4 || (!ata_id_has_lba(dev->id))) {
-                        err_mask = ata_dev_init_params(ap, dev);
-                        if (err_mask) {
-                                printk(KERN_ERR "ata%u: failed to init "
-                                       "parameters, disabled\n", ap->id);
-                                goto err_out;
-                        }
-
-                        /* current CHS translation info (id[53-58]) might be
-                         * changed. reread the identify device info.
-                         */
-                        ata_dev_reread_id(ap, dev);
-                }
-
                 if (ata_id_has_lba(dev->id)) {
                         dev->flags |= ATA_DFLAG_LBA;
 
@@ -1057,7 +1105,7 @@ retry:
                         /* print device info to dmesg */
                         printk(KERN_INFO "ata%u: dev %u ATA-%d, max %s, %Lu sectors:%s\n",
                                ap->id, device,
-                               major_version,
+                               ata_id_major_version(dev->id),
                                ata_mode_string(xfer_modes),
                                (unsigned long long)dev->n_sectors,
                                dev->flags & ATA_DFLAG_LBA48 ? " LBA48" : " LBA");
@@ -1079,7 +1127,7 @@ retry:
                         /* print device info to dmesg */
                         printk(KERN_INFO "ata%u: dev %u ATA-%d, max %s, %Lu sectors: CHS %d/%d/%d\n",
                                ap->id, device,
-                               major_version,
+                               ata_id_major_version(dev->id),
                                ata_mode_string(xfer_modes),
                                (unsigned long long)dev->n_sectors,
                                (int)dev->cylinders, (int)dev->heads, (int)dev->sectors);
@@ -1096,9 +1144,6 @@ retry:
 
         /* ATAPI-specific feature tests */
         else if (dev->class == ATA_DEV_ATAPI) {
-                if (ata_id_is_ata(dev->id))             /* sanity check */
-                        goto err_out_nosup;
-
                 rc = atapi_cdb_len(dev->id);
                 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
                         printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
@@ -2490,47 +2535,6 @@ static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
 }
 
 /**
- *      ata_dev_reread_id - Reread the device identify device info
- *      @ap: port where the device is
- *      @dev: device to reread the identify device info
- *
- *      LOCKING:
- */
-
-static void ata_dev_reread_id(struct ata_port *ap, struct ata_device *dev)
-{
-        struct ata_taskfile tf;
-
-        ata_tf_init(ap, &tf, dev->devno);
-
-        if (dev->class == ATA_DEV_ATA) {
-                tf.command = ATA_CMD_ID_ATA;
-                DPRINTK("do ATA identify\n");
-        } else {
-                tf.command = ATA_CMD_ID_ATAPI;
-                DPRINTK("do ATAPI identify\n");
-        }
-
-        tf.flags |= ATA_TFLAG_DEVICE;
-        tf.protocol = ATA_PROT_PIO;
-
-        if (ata_exec_internal(ap, dev, &tf, DMA_FROM_DEVICE,
-                              dev->id, sizeof(dev->id)))
-                goto err_out;
-
-        swap_buf_le16(dev->id, ATA_ID_WORDS);
-
-        ata_dump_id(dev->id);
-
-        DPRINTK("EXIT\n");
-
-        return;
-err_out:
-        printk(KERN_ERR "ata%u: failed to reread ID, disabled\n", ap->id);
-        ata_port_disable(ap);
-}
-
-/**
  *      ata_dev_init_params - Issue INIT DEV PARAMS command
  *      @ap: Port associated with device @dev
  *      @dev: Device to which command will be sent
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index e14ed4ebbeed..91ecf527bb8a 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -49,11 +49,13 @@
 #define DRV_VERSION     "0.9"
 
 enum {
+        SIL_FLAG_RERR_ON_DMA_ACT = (1 << 29),
         SIL_FLAG_MOD15WRITE     = (1 << 30),
 
         sil_3112                = 0,
         sil_3112_m15w           = 1,
-        sil_3114                = 2,
+        sil_3512                = 2,
+        sil_3114                = 3,
 
         SIL_FIFO_R0             = 0x40,
         SIL_FIFO_W0             = 0x41,
@@ -90,7 +92,7 @@ static void sil_post_set_mode (struct ata_port *ap);
 static const struct pci_device_id sil_pci_tbl[] = {
         { 0x1095, 0x3112, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
         { 0x1095, 0x0240, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
-        { 0x1095, 0x3512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
+        { 0x1095, 0x3512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3512 },
         { 0x1095, 0x3114, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3114 },
         { 0x1002, 0x436e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
         { 0x1002, 0x4379, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_m15w },
@@ -185,7 +187,8 @@ static const struct ata_port_info sil_port_info[] = {
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
                 .port_ops       = &sil_ops,
-        }, /* sil_3112_15w - keep it sync'd w/ sil_3112 */
+        },
+        /* sil_3112_15w - keep it sync'd w/ sil_3112 */
         {
                 .sht            = &sil_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
@@ -194,11 +197,24 @@ static const struct ata_port_info sil_port_info[] = {
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
                 .port_ops       = &sil_ops,
-        }, /* sil_3114 */
+        },
+        /* sil_3512 */
         {
                 .sht            = &sil_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_MMIO,
+                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
+                                  SIL_FLAG_RERR_ON_DMA_ACT,
+                .pio_mask       = 0x1f,                 /* pio0-4 */
+                .mwdma_mask     = 0x07,                 /* mwdma0-2 */
+                .udma_mask      = 0x3f,                 /* udma0-5 */
+                .port_ops       = &sil_ops,
+        },
+        /* sil_3114 */
+        {
+                .sht            = &sil_sht,
+                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
+                                  ATA_FLAG_MMIO |
+                                  SIL_FLAG_RERR_ON_DMA_ACT,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
@@ -215,12 +231,13 @@ static const struct {
         unsigned long scr;      /* SATA control register block */
         unsigned long sien;     /* SATA Interrupt Enable register */
         unsigned long xfer_mode;/* data transfer mode register */
+        unsigned long sfis_cfg; /* SATA FIS reception config register */
 } sil_port[] = {
         /* port 0 ... */
-        { 0x80, 0x8A, 0x00, 0x100, 0x148, 0xb4 },
-        { 0xC0, 0xCA, 0x08, 0x180, 0x1c8, 0xf4 },
-        { 0x280, 0x28A, 0x200, 0x300, 0x348, 0x2b4 },
-        { 0x2C0, 0x2CA, 0x208, 0x380, 0x3c8, 0x2f4 },
+        { 0x80, 0x8A, 0x00, 0x100, 0x148, 0xb4, 0x14c },
+        { 0xC0, 0xCA, 0x08, 0x180, 0x1c8, 0xf4, 0x1cc },
+        { 0x280, 0x28A, 0x200, 0x300, 0x348, 0x2b4, 0x34c },
+        { 0x2C0, 0x2CA, 0x208, 0x380, 0x3c8, 0x2f4, 0x3cc },
         /* ... port 3 */
 };
 
@@ -458,6 +475,23 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 dev_printk(KERN_WARNING, &pdev->dev,
                          "cache line size not set.  Driver may not function\n");
 
+        /* Apply R_ERR on DMA activate FIS errata workaround */
+        if (probe_ent->host_flags & SIL_FLAG_RERR_ON_DMA_ACT) {
+                int cnt;
+
+                for (i = 0, cnt = 0; i < probe_ent->n_ports; i++) {
+                        tmp = readl(mmio_base + sil_port[i].sfis_cfg);
+                        if ((tmp & 0x3) != 0x01)
+                                continue;
+                        if (!cnt)
+                                dev_printk(KERN_INFO, &pdev->dev,
+                                           "Applying R_ERR on DMA activate "
+                                           "FIS errata fix\n");
+                        writel(tmp & ~0x3, mmio_base + sil_port[i].sfis_cfg);
+                        cnt++;
+                }
+        }
+
         if (ent->driver_data == sil_3114) {
                 irq_mask = SIL_MASK_4PORT;
 
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 930db398d107..9d9872347f56 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -89,6 +89,11 @@
 #define SD_MAX_RETRIES          5
 #define SD_PASSTHROUGH_RETRIES  1
 
+/*
+ * Size of the initial data buffer for mode and read capacity data
+ */
+#define SD_BUF_SIZE             512
+
 static void scsi_disk_release(struct kref *kref);
 
 struct scsi_disk {
@@ -1239,7 +1244,7 @@ sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
 
 /*
  * read write protect setting, if possible - called only in sd_revalidate_disk()
- * called with buffer of length 512
+ * called with buffer of length SD_BUF_SIZE
  */
 static void
 sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
@@ -1297,7 +1302,7 @@ sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
 
 /*
  * sd_read_cache_type - called only from sd_revalidate_disk()
- * called with buffer of length 512
+ * called with buffer of length SD_BUF_SIZE
  */
 static void
 sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
@@ -1342,6 +1347,8 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
 
         /* Take headers and block descriptors into account */
         len += data.header_length + data.block_descriptor_length;
+        if (len > SD_BUF_SIZE)
+                goto bad_sense;
 
         /* Get the data */
         res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr);
@@ -1354,6 +1361,12 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
                 int ct = 0;
                 int offset = data.header_length + data.block_descriptor_length;
 
+                if (offset >= SD_BUF_SIZE - 2) {
+                        printk(KERN_ERR "%s: malformed MODE SENSE response",
+                                diskname);
+                        goto defaults;
+                }
+
                 if ((buffer[offset] & 0x3f) != modepage) {
                         printk(KERN_ERR "%s: got wrong page\n", diskname);
                         goto defaults;
@@ -1398,6 +1411,7 @@ defaults:
                diskname);
         sdkp->WCE = 0;
         sdkp->RCD = 0;
+        sdkp->DPOFUA = 0;
 }
 
 /**
@@ -1421,7 +1435,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
         if (!scsi_device_online(sdp))
                 goto out;
 
-        buffer = kmalloc(512, GFP_KERNEL | __GFP_DMA);
+        buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL | __GFP_DMA);
         if (!buffer) {
                 printk(KERN_WARNING "(sd_revalidate_disk:) Memory allocation "
                        "failure.\n");