Merge branch 'upstream'

Conflicts:

	drivers/scsi/libata-core.c

16 files changed, 309 insertions, 268 deletions

diff --git a/drivers/scsi/ata_piix.c b/drivers/scsi/ata_piix.c
index a74e23d39ba9..2d5be84d8bd4 100644
--- a/drivers/scsi/ata_piix.c
+++ b/drivers/scsi/ata_piix.c
@@ -742,7 +742,7 @@ static int piix_disable_ahci(struct pci_dev *pdev)
 /**
  *      piix_check_450nx_errata -       Check for problem 450NX setup
  *      @ata_dev: the PCI device to check
- *      
+ *
  *      Check for the present of 450NX errata #19 and errata #25. If
  *      they are found return an error code so we can turn off DMA
  */
@@ -753,7 +753,7 @@ static int __devinit piix_check_450nx_errata(struct pci_dev *ata_dev)
         u16 cfg;
         u8 rev;
         int no_piix_dma = 0;
-        
+
         while((pdev = pci_get_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82454NX, pdev)) != NULL)
         {
                 /* Look for 450NX PXB. Check for problem configurations
@@ -772,7 +772,7 @@ static int __devinit piix_check_450nx_errata(struct pci_dev *ata_dev)
         if(no_piix_dma == 2)
                 dev_printk(KERN_WARNING, &ata_dev->dev, "A BIOS update may resolve this.\n");
         return no_piix_dma;
-}               
+}
 
 static void __devinit piix_init_sata_map(struct pci_dev *pdev,
                                          struct ata_port_info *pinfo)
diff --git a/drivers/scsi/g_NCR5380.c b/drivers/scsi/g_NCR5380.c
index 45756fa90777..e6bcfe949340 100644
--- a/drivers/scsi/g_NCR5380.c
+++ b/drivers/scsi/g_NCR5380.c
@@ -127,7 +127,7 @@ static int ncr_53c400a = NCR_NOT_SET;
 static int dtc_3181e = NCR_NOT_SET;
 
 static struct override {
-        NCR5380_implementation_fields;
+        NCR5380_map_type NCR5380_map_name;
         int irq;
         int dma;
         int board;              /* Use NCR53c400, Ricoh, etc. extensions ? */
@@ -299,6 +299,10 @@ int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
         };
         int flags = 0;
         struct Scsi_Host *instance;
+#ifdef CONFIG_SCSI_G_NCR5380_MEM
+        unsigned long base;
+        void __iomem *iomem;
+#endif
 
         if (ncr_irq != NCR_NOT_SET)
                 overrides[0].irq = ncr_irq;
@@ -424,15 +428,22 @@ int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
                         region_size = NCR5380_region_size;
                 }
 #else
-                if(!request_mem_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size, "ncr5380"))
+                base = overrides[current_override].NCR5380_map_name;
+                if (!request_mem_region(base, NCR5380_region_size, "ncr5380"))
+                        continue;
+                iomem = ioremap(base, NCR5380_region_size);
+                if (!iomem) {
+                        release_mem_region(base, NCR5380_region_size);
                         continue;
+                }
 #endif
                 instance = scsi_register(tpnt, sizeof(struct NCR5380_hostdata));
                 if (instance == NULL) {
 #ifndef CONFIG_SCSI_G_NCR5380_MEM
                         release_region(overrides[current_override].NCR5380_map_name, region_size);
 #else
-                        release_mem_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size);
+                        iounmap(iomem);
+                        release_mem_region(base, NCR5380_region_size);
 #endif
                         continue;
                 }
@@ -440,6 +451,8 @@ int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
                 instance->NCR5380_instance_name = overrides[current_override].NCR5380_map_name;
 #ifndef CONFIG_SCSI_G_NCR5380_MEM
                 instance->n_io_port = region_size;
+#else
+                ((struct NCR5380_hostdata *)instance->hostdata).iomem = iomem;
 #endif
 
                 NCR5380_init(instance, flags);
@@ -509,6 +522,7 @@ int generic_NCR5380_release_resources(struct Scsi_Host *instance)
 #ifndef CONFIG_SCSI_G_NCR5380_MEM
         release_region(instance->NCR5380_instance_name, instance->n_io_port);
 #else
+        iounmap(((struct NCR5380_hostdata *)instance->hostdata).iomem);
         release_mem_region(instance->NCR5380_instance_name, NCR5380_region_size);
 #endif
 
@@ -586,7 +600,7 @@ static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst,
                 }
 #else
                 /* implies CONFIG_SCSI_G_NCR5380_MEM */
-                isa_memcpy_fromio(dst + start, NCR53C400_host_buffer + NCR5380_map_name, 128);
+                memcpy_fromio(dst + start, iomem + NCR53C400_host_buffer, 128);
 #endif
                 start += 128;
                 blocks--;
@@ -606,7 +620,7 @@ static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst,
                 }
 #else
                 /* implies CONFIG_SCSI_G_NCR5380_MEM */
-                isa_memcpy_fromio(dst + start, NCR53C400_host_buffer + NCR5380_map_name, 128);
+                memcpy_fromio(dst + start, iomem + NCR53C400_host_buffer, 128);
 #endif
                 start += 128;
                 blocks--;
@@ -671,7 +685,7 @@ static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src,
                 }
 #else
                 /* implies CONFIG_SCSI_G_NCR5380_MEM */
-                isa_memcpy_toio(NCR53C400_host_buffer + NCR5380_map_name, src + start, 128);
+                memcpy_toio(iomem + NCR53C400_host_buffer, src + start, 128);
 #endif
                 start += 128;
                 blocks--;
@@ -687,7 +701,7 @@ static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src,
                 }
 #else
                 /* implies CONFIG_SCSI_G_NCR5380_MEM */
-                isa_memcpy_toio(NCR53C400_host_buffer + NCR5380_map_name, src + start, 128);
+                memcpy_toio(iomem + NCR53C400_host_buffer, src + start, 128);
 #endif
                 start += 128;
                 blocks--;
diff --git a/drivers/scsi/g_NCR5380.h b/drivers/scsi/g_NCR5380.h
index 656fbe2f91f6..d60a89cb8052 100644
--- a/drivers/scsi/g_NCR5380.h
+++ b/drivers/scsi/g_NCR5380.h
@@ -82,6 +82,15 @@ static const char* generic_NCR5380_info(struct Scsi_Host *);
 #define NCR5380_read(reg) (inb(NCR5380_map_name + (reg)))
 #define NCR5380_write(reg, value) (outb((value), (NCR5380_map_name + (reg))))
 
+#define NCR5380_implementation_fields \
+    NCR5380_map_type NCR5380_map_name
+
+#define NCR5380_local_declare() \
+    register NCR5380_implementation_fields
+
+#define NCR5380_setup(instance) \
+    NCR5380_map_name = (NCR5380_map_type)((instance)->NCR5380_instance_name)
+
 #else 
 /* therefore CONFIG_SCSI_G_NCR5380_MEM */
 
@@ -95,18 +104,20 @@ static const char* generic_NCR5380_info(struct Scsi_Host *);
 #define NCR53C400_host_buffer 0x3900
 #define NCR5380_region_size 0x3a00
 
-#define NCR5380_read(reg) isa_readb(NCR5380_map_name + NCR53C400_mem_base + (reg))
-#define NCR5380_write(reg, value) isa_writeb(value, NCR5380_map_name + NCR53C400_mem_base + (reg))
-#endif
+#define NCR5380_read(reg) readb(iomem + NCR53C400_mem_base + (reg))
+#define NCR5380_write(reg, value) writeb(value, iomem + NCR53C400_mem_base + (reg))
 
 #define NCR5380_implementation_fields \
-    NCR5380_map_type NCR5380_map_name
+    NCR5380_map_type NCR5380_map_name; \
+    void __iomem *iomem;
 
 #define NCR5380_local_declare() \
-    register NCR5380_implementation_fields
+    register void __iomem *iomem
 
 #define NCR5380_setup(instance) \
-    NCR5380_map_name = (NCR5380_map_type)((instance)->NCR5380_instance_name)
+    iomem = (((struct NCR5380_hostdata *)(instance)->hostdata).iomem)
+
+#endif
 
 #define NCR5380_intr generic_NCR5380_intr
 #define NCR5380_queue_command generic_NCR5380_queue_command
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 0cf0e4c7ac0c..39b760a24241 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -47,6 +47,7 @@
 #include <linux/ide.h>
 #include <linux/scatterlist.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
 
 #include <asm/io.h>
 #include <asm/bitops.h>
@@ -109,7 +110,7 @@ typedef struct ide_scsi_obj {
         unsigned long log;                      /* log flags */
 } idescsi_scsi_t;
 
-static DECLARE_MUTEX(idescsi_ref_sem);
+static DEFINE_MUTEX(idescsi_ref_mutex);
 
 #define ide_scsi_g(disk) \
         container_of((disk)->private_data, struct ide_scsi_obj, driver)
@@ -118,19 +119,19 @@ static struct ide_scsi_obj *ide_scsi_get(struct gendisk *disk)
 {
         struct ide_scsi_obj *scsi = NULL;
 
-        down(&idescsi_ref_sem);
+        mutex_lock(&idescsi_ref_mutex);
         scsi = ide_scsi_g(disk);
         if (scsi)
                 scsi_host_get(scsi->host);
-        up(&idescsi_ref_sem);
+        mutex_unlock(&idescsi_ref_mutex);
         return scsi;
 }
 
 static void ide_scsi_put(struct ide_scsi_obj *scsi)
 {
-        down(&idescsi_ref_sem);
+        mutex_lock(&idescsi_ref_mutex);
         scsi_host_put(scsi->host);
-        up(&idescsi_ref_sem);
+        mutex_unlock(&idescsi_ref_mutex);
 }
 
 static inline idescsi_scsi_t *scsihost_to_idescsi(struct Scsi_Host *host)
diff --git a/drivers/scsi/in2000.c b/drivers/scsi/in2000.c
index 34daa3e068de..9c519876f8a0 100644
--- a/drivers/scsi/in2000.c
+++ b/drivers/scsi/in2000.c
@@ -1898,6 +1898,21 @@ static int int_tab[] in2000__INITDATA = {
         10
 };
 
+static int probe_bios(u32 addr, u32 *s1, uchar *switches)
+{
+        void __iomem *p = ioremap(addr, 0x34);
+        if (!p)
+                return 0;
+        *s1 = readl(p + 0x10);
+        if (*s1 == 0x41564f4e || readl(p + 0x30) == 0x61776c41) {
+                /* Read the switch image that's mapped into EPROM space */
+                *switches = ~readb(p + 0x20);
+                iounmap(p);
+                return 1;
+        }
+        iounmap(p);
+        return 0;
+}
 
 static int __init in2000_detect(struct scsi_host_template * tpnt)
 {
@@ -1930,6 +1945,7 @@ static int __init in2000_detect(struct scsi_host_template * tpnt)
 
         detect_count = 0;
         for (bios = 0; bios_tab[bios]; bios++) {
+                u32 s1 = 0;
                 if (check_setup_args("ioport", &val, buf)) {
                         base = val;
                         switches = ~inb(base + IO_SWITCHES) & 0xff;
@@ -1941,13 +1957,9 @@ static int __init in2000_detect(struct scsi_host_template * tpnt)
  * for the obvious ID strings. We look for the 2 most common ones and
  * hope that they cover all the cases...
  */
-                else if (isa_readl(bios_tab[bios] + 0x10) == 0x41564f4e || isa_readl(bios_tab[bios] + 0x30) == 0x61776c41) {
+                else if (probe_bios(bios_tab[bios], &s1, &switches)) {
                         printk("Found IN2000 BIOS at 0x%x ", (unsigned int) bios_tab[bios]);
 
-/* Read the switch image that's mapped into EPROM space */
-
-                        switches = ~((isa_readb(bios_tab[bios] + 0x20) & 0xff));
-
 /* Find out where the IO space is */
 
                         x = switches & (SW_ADDR0 | SW_ADDR1);
@@ -2037,7 +2049,7 @@ static int __init in2000_detect(struct scsi_host_template * tpnt)
 
 /* Older BIOS's had a 'sync on/off' switch - use its setting */
 
-                if (isa_readl(bios_tab[bios] + 0x10) == 0x41564f4e && (switches & SW_SYNC_DOS5))
+                if (s1 == 0x41564f4e && (switches & SW_SYNC_DOS5))
                         hostdata->sync_off = 0x00;      /* sync defaults to on */
                 else
                         hostdata->sync_off = 0xff;      /* sync defaults to off */
diff --git a/drivers/scsi/libata-bmdma.c b/drivers/scsi/libata-bmdma.c
index a00a78b30836..95d81d86d8b7 100644
--- a/drivers/scsi/libata-bmdma.c
+++ b/drivers/scsi/libata-bmdma.c
@@ -941,7 +941,7 @@ err_out:
  *      @pdev: PCI device
  *
  *      Some PCI ATA devices report simplex mode but in fact can be told to
- *      enter non simplex mode. This implements the neccessary logic to 
+ *      enter non simplex mode. This implements the neccessary logic to
  *      perform the task on such devices. Calling it on other devices will
  *      have -undefined- behaviour.
  */
@@ -966,7 +966,7 @@ unsigned long ata_pci_default_filter(const struct ata_port *ap, struct ata_devic
 {
         /* Filter out DMA modes if the device has been configured by
            the BIOS as PIO only */
-           
+
         if (ap->ioaddr.bmdma_addr == 0)
                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
         return xfer_mask;
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index dcce0f494d4a..c3c4263fdb12 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -64,10 +64,10 @@
 static unsigned int ata_dev_init_params(struct ata_port *ap,
                                         struct ata_device *dev);
 static void ata_set_mode(struct ata_port *ap);
-static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
+static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
+                                         struct ata_device *dev);
+static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev);
 static void ata_pio_error(struct ata_port *ap);
-static unsigned int ata_dev_xfermask(struct ata_port *ap,
-                                     struct ata_device *dev);
 
 static unsigned int ata_unique_id = 1;
 static struct workqueue_struct *ata_wq;
@@ -191,7 +191,7 @@ static const u8 ata_rw_cmds[] = {
  *      ata_rwcmd_protocol - set taskfile r/w commands and protocol
  *      @qc: command to examine and configure
  *
- *      Examine the device configuration and tf->flags to calculate 
+ *      Examine the device configuration and tf->flags to calculate
  *      the proper read/write commands and protocol to use.
  *
  *      LOCKING:
@@ -204,7 +204,7 @@ int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
         u8 cmd;
 
         int index, fua, lba48, write;
- 
+
         fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
         lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
         write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
@@ -253,6 +253,29 @@ static unsigned int ata_pack_xfermask(unsigned int pio_mask,
                 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
 }
 
+/**
+ *      ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
+ *      @xfer_mask: xfer_mask to unpack
+ *      @pio_mask: resulting pio_mask
+ *      @mwdma_mask: resulting mwdma_mask
+ *      @udma_mask: resulting udma_mask
+ *
+ *      Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
+ *      Any NULL distination masks will be ignored.
+ */
+static void ata_unpack_xfermask(unsigned int xfer_mask,
+                                unsigned int *pio_mask,
+                                unsigned int *mwdma_mask,
+                                unsigned int *udma_mask)
+{
+        if (pio_mask)
+                *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
+        if (mwdma_mask)
+                *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
+        if (udma_mask)
+                *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
+}
+
 static const struct ata_xfer_ent {
         unsigned int shift, bits;
         u8 base;
@@ -373,6 +396,15 @@ static const char *ata_mode_string(unsigned int xfer_mask)
         return "<n/a>";
 }
 
+static void ata_dev_disable(struct ata_port *ap, struct ata_device *dev)
+{
+        if (ata_dev_present(dev)) {
+                printk(KERN_WARNING "ata%u: dev %u disabled\n",
+                       ap->id, dev->devno);
+                dev->class++;
+        }
+}
+
 /**
  *      ata_pio_devchk - PATA device presence detection
  *      @ap: ATA channel to examine
@@ -988,6 +1020,22 @@ ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
 
         ata_qc_free(qc);
 
+        /* XXX - Some LLDDs (sata_mv) disable port on command failure.
+         * Until those drivers are fixed, we detect the condition
+         * here, fail the command with AC_ERR_SYSTEM and reenable the
+         * port.
+         *
+         * Note that this doesn't change any behavior as internal
+         * command failure results in disabling the device in the
+         * higher layer for LLDDs without new reset/EH callbacks.
+         *
+         * Kill the following code as soon as those drivers are fixed.
+         */
+        if (ap->flags & ATA_FLAG_PORT_DISABLED) {
+                err_mask |= AC_ERR_SYSTEM;
+                ata_port_probe(ap);
+        }
+
         return err_mask;
 }
 
@@ -1008,7 +1056,7 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
                 return 0;
         if (speed > 2)
                 return 1;
-                
+
         /* If we have no drive specific rule, then PIO 2 is non IORDY */
 
         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
@@ -1034,9 +1082,8 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
  *
  *      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.
+ *      devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
+ *      for pre-ATA4 drives.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep)
@@ -1048,7 +1095,6 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
                            unsigned int *p_class, int post_reset, u16 **p_id)
 {
         unsigned int class = *p_class;
-        unsigned int using_edd;
         struct ata_taskfile tf;
         unsigned int err_mask = 0;
         u16 *id;
@@ -1057,12 +1103,6 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
 
         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))
-                using_edd = 0;
-        else
-                using_edd = 1;
-
         ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
 
         id = kmalloc(sizeof(id[0]) * ATA_ID_WORDS, GFP_KERNEL);
@@ -1092,32 +1132,9 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
 
         err_mask = ata_exec_internal(ap, dev, &tf, DMA_FROM_DEVICE,
                                      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;
-
-                /*
-                 * arg!  EDD works for all test cases, but seems to return
-                 * the ATA signature for some ATAPI devices.  Until the
-                 * reason for this is found and fixed, we fix up the mess
-                 * here.  If IDENTIFY DEVICE returns command aborted
-                 * (as ATAPI devices do), then we issue an
-                 * IDENTIFY PACKET DEVICE.
-                 *
-                 * ATA software reset (SRST, the default) does not appear
-                 * to have this problem.
-                 */
-                if ((using_edd) && (class == ATA_DEV_ATA)) {
-                        u8 err = tf.feature;
-                        if (err & ATA_ABORTED) {
-                                class = ATA_DEV_ATAPI;
-                                goto retry;
-                        }
-                }
                 goto err_out;
         }
 
@@ -1314,7 +1331,7 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
                 if (print_info)
                         printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
                                ap->id, dev->devno);
-                ap->udma_mask &= ATA_UDMA5;
+                dev->udma_mask &= ATA_UDMA5;
                 dev->max_sectors = ATA_MAX_SECTORS;
         }
 
@@ -1325,8 +1342,6 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
         return 0;
 
 err_out_nosup:
-        printk(KERN_WARNING "ata%u: dev %u not supported, ignoring\n",
-               ap->id, dev->devno);
         DPRINTK("EXIT, err\n");
         return rc;
 }
@@ -1393,7 +1408,7 @@ static int ata_bus_probe(struct ata_port *ap)
                 }
 
                 if (ata_dev_configure(ap, dev, 1)) {
-                        dev->class++;   /* disable device */
+                        ata_dev_disable(ap, dev);
                         continue;
                 }
 
@@ -1539,6 +1554,23 @@ void sata_phy_reset(struct ata_port *ap)
 }
 
 /**
+ *      ata_dev_pair            -       return other device on cable
+ *      @ap: port
+ *      @adev: device
+ *
+ *      Obtain the other device on the same cable, or if none is
+ *      present NULL is returned
+ */
+
+struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
+{
+        struct ata_device *pair = &ap->device[1 - adev->devno];
+        if (!ata_dev_present(pair))
+                return NULL;
+        return pair;
+}
+
+/**
  *      ata_port_disable - Disable port.
  *      @ap: Port to be disabled.
  *
@@ -1566,7 +1598,7 @@ void ata_port_disable(struct ata_port *ap)
  * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
  * These were taken from ATA/ATAPI-6 standard, rev 0a, except
  * for PIO 5, which is a nonstandard extension and UDMA6, which
- * is currently supported only by Maxtor drives. 
+ * is currently supported only by Maxtor drives.
  */
 
 static const struct ata_timing ata_timing[] = {
@@ -1581,11 +1613,11 @@ static const struct ata_timing ata_timing[] = {
         { XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },
 
 /*      { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
-                                          
+
         { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
         { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
         { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
-                                          
+
         { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
         { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
         { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },
@@ -1638,7 +1670,7 @@ static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
         for (t = ata_timing; t->mode != speed; t++)
                 if (t->mode == 0xFF)
                         return NULL;
-        return t; 
+        return t;
 }
 
 int ata_timing_compute(struct ata_device *adev, unsigned short speed,
@@ -1648,7 +1680,7 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
         struct ata_timing p;
 
         /*
-         * Find the mode. 
+         * Find the mode.
          */
 
         if (!(s = ata_timing_find_mode(speed)))
@@ -1706,20 +1738,28 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
         return 0;
 }
 
-static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
+static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
 {
-        if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
-                return;
+        unsigned int err_mask;
+        int rc;
 
         if (dev->xfer_shift == ATA_SHIFT_PIO)
                 dev->flags |= ATA_DFLAG_PIO;
 
-        ata_dev_set_xfermode(ap, dev);
+        err_mask = ata_dev_set_xfermode(ap, dev);
+        if (err_mask) {
+                printk(KERN_ERR
+                       "ata%u: failed to set xfermode (err_mask=0x%x)\n",
+                       ap->id, err_mask);
+                return -EIO;
+        }
 
-        if (ata_dev_revalidate(ap, dev, 0)) {
-                printk(KERN_ERR "ata%u: failed to revalidate after set "
-                       "xfermode, disabled\n", ap->id);
-                ata_port_disable(ap);
+        rc = ata_dev_revalidate(ap, dev, 0);
+        if (rc) {
+                printk(KERN_ERR
+                       "ata%u: failed to revalidate after set xfermode\n",
+                       ap->id);
+                return rc;
         }
 
         DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
@@ -1728,6 +1768,7 @@ static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
         printk(KERN_INFO "ata%u: dev %u configured for %s\n",
                ap->id, dev->devno,
                ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
+        return 0;
 }
 
 static int ata_host_set_pio(struct ata_port *ap)
@@ -1787,16 +1828,19 @@ static void ata_set_mode(struct ata_port *ap)
         /* step 1: calculate xfer_mask */
         for (i = 0; i < ATA_MAX_DEVICES; i++) {
                 struct ata_device *dev = &ap->device[i];
-                unsigned int xfer_mask;
+                unsigned int pio_mask, dma_mask;
 
                 if (!ata_dev_present(dev))
                         continue;
 
-                xfer_mask = ata_dev_xfermask(ap, dev);
+                ata_dev_xfermask(ap, dev);
+
+                /* TODO: let LLDD filter dev->*_mask here */
 
-                dev->pio_mode = ata_xfer_mask2mode(xfer_mask & ATA_MASK_PIO);
-                dev->dma_mode = ata_xfer_mask2mode(xfer_mask & (ATA_MASK_MWDMA |
-                                                                ATA_MASK_UDMA));
+                pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
+                dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
+                dev->pio_mode = ata_xfer_mask2mode(pio_mask);
+                dev->dma_mode = ata_xfer_mask2mode(dma_mask);
         }
 
         /* step 2: always set host PIO timings */
@@ -1808,11 +1852,15 @@ static void ata_set_mode(struct ata_port *ap)
         ata_host_set_dma(ap);
 
         /* step 4: update devices' xfer mode */
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ata_dev_set_mode(ap, &ap->device[i]);
+        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                struct ata_device *dev = &ap->device[i];
 
-        if (ap->flags & ATA_FLAG_PORT_DISABLED)
-                return;
+                if (!ata_dev_present(dev))
+                        continue;
+
+                if (ata_dev_set_mode(ap, dev))
+                        goto err_out;
+        }
 
         if (ap->ops->post_set_mode)
                 ap->ops->post_set_mode(ap);
@@ -1935,45 +1983,6 @@ static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
                 ap->ops->dev_select(ap, 0);
 }
 
-/**
- *      ata_bus_edd - Issue EXECUTE DEVICE DIAGNOSTIC command.
- *      @ap: Port to reset and probe
- *
- *      Use the EXECUTE DEVICE DIAGNOSTIC command to reset and
- *      probe the bus.  Not often used these days.
- *
- *      LOCKING:
- *      PCI/etc. bus probe sem.
- *      Obtains host_set lock.
- *
- */
-
-static unsigned int ata_bus_edd(struct ata_port *ap)
-{
-        struct ata_taskfile tf;
-        unsigned long flags;
-
-        /* set up execute-device-diag (bus reset) taskfile */
-        /* also, take interrupts to a known state (disabled) */
-        DPRINTK("execute-device-diag\n");
-        ata_tf_init(ap, &tf, 0);
-        tf.ctl |= ATA_NIEN;
-        tf.command = ATA_CMD_EDD;
-        tf.protocol = ATA_PROT_NODATA;
-
-        /* do bus reset */
-        spin_lock_irqsave(&ap->host_set->lock, flags);
-        ata_tf_to_host(ap, &tf);
-        spin_unlock_irqrestore(&ap->host_set->lock, flags);
-
-        /* spec says at least 2ms.  but who knows with those
-         * crazy ATAPI devices...
-         */
-        msleep(150);
-
-        return ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
-}
-
 static unsigned int ata_bus_softreset(struct ata_port *ap,
                                       unsigned int devmask)
 {
@@ -2008,11 +2017,11 @@ static unsigned int ata_bus_softreset(struct ata_port *ap,
          */
         msleep(150);
 
-        
-        /* Before we perform post reset processing we want to see if 
+
+        /* Before we perform post reset processing we want to see if
            the bus shows 0xFF because the odd clown forgets the D7 pulldown
            resistor */
-        
+
         if (ata_check_status(ap) == 0xFF)
                 return 1;       /* Positive is failure for some reason */
 
@@ -2046,7 +2055,7 @@ void ata_bus_reset(struct ata_port *ap)
         struct ata_ioports *ioaddr = &ap->ioaddr;
         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
         u8 err;
-        unsigned int dev0, dev1 = 0, rc = 0, devmask = 0;
+        unsigned int dev0, dev1 = 0, devmask = 0;
 
         DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
 
@@ -2069,18 +2078,8 @@ void ata_bus_reset(struct ata_port *ap)
 
         /* issue bus reset */
         if (ap->flags & ATA_FLAG_SRST)
-                rc = ata_bus_softreset(ap, devmask);
-        else if ((ap->flags & ATA_FLAG_SATA_RESET) == 0) {
-                /* set up device control */
-                if (ap->flags & ATA_FLAG_MMIO)
-                        writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
-                else
-                        outb(ap->ctl, ioaddr->ctl_addr);
-                rc = ata_bus_edd(ap);
-        }
-
-        if (rc)
-                goto err_out;
+                if (ata_bus_softreset(ap, devmask))
+                        goto err_out;
 
         /*
          * determine by signature whether we have ATA or ATAPI devices
@@ -2581,22 +2580,22 @@ static const char * const ata_dma_blacklist [] = {
         "SanDisk SDP3B-64", NULL,
         "SANYO CD-ROM CRD", NULL,
         "HITACHI CDR-8", NULL,
-        "HITACHI CDR-8335", NULL, 
+        "HITACHI CDR-8335", NULL,
         "HITACHI CDR-8435", NULL,
-        "Toshiba CD-ROM XM-6202B", NULL, 
-        "TOSHIBA CD-ROM XM-1702BC", NULL, 
-        "CD-532E-A", NULL, 
-        "E-IDE CD-ROM CR-840", NULL, 
-        "CD-ROM Drive/F5A", NULL, 
-        "WPI CDD-820", NULL, 
+        "Toshiba CD-ROM XM-6202B", NULL,
+        "TOSHIBA CD-ROM XM-1702BC", NULL,
+        "CD-532E-A", NULL,
+        "E-IDE CD-ROM CR-840", NULL,
+        "CD-ROM Drive/F5A", NULL,
+        "WPI CDD-820", NULL,
         "SAMSUNG CD-ROM SC-148C", NULL,
-        "SAMSUNG CD-ROM SC", NULL, 
+        "SAMSUNG CD-ROM SC", NULL,
         "SanDisk SDP3B-64", NULL,
         "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,
         "_NEC DV5800A", NULL,
         "SAMSUNG CD-ROM SN-124", "N001"
 };
- 
+
 static int ata_strim(char *s, size_t len)
 {
         len = strnlen(s, len);
@@ -2639,18 +2638,15 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
  *      @ap: Port on which the device to compute xfermask for resides
  *      @dev: Device to compute xfermask for
  *
- *      Compute supported xfermask of @dev.  This function is
- *      responsible for applying all known limits including host
- *      controller limits, device blacklist, etc...
+ *      Compute supported xfermask of @dev and store it in
+ *      dev->*_mask.  This function is responsible for applying all
+ *      known limits including host controller limits, device
+ *      blacklist, etc...
  *
  *      LOCKING:
  *      None.
- *
- *      RETURNS:
- *      Computed xfermask.
  */
-static unsigned int ata_dev_xfermask(struct ata_port *ap,
-                                     struct ata_device *dev)
+static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
 {
         unsigned long xfer_mask;
         int i;
@@ -2663,6 +2659,8 @@ static unsigned int ata_dev_xfermask(struct ata_port *ap,
                 struct ata_device *d = &ap->device[i];
                 if (!ata_dev_present(d))
                         continue;
+                xfer_mask &= ata_pack_xfermask(d->pio_mask, d->mwdma_mask,
+                                               d->udma_mask);
                 xfer_mask &= ata_id_xfermask(d->id);
                 if (ata_dma_blacklisted(d))
                         xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
@@ -2672,7 +2670,8 @@ static unsigned int ata_dev_xfermask(struct ata_port *ap,
                 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, "
                        "disabling DMA\n", ap->id, dev->devno);
 
-        return xfer_mask;
+        ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
+                            &dev->udma_mask);
 }
 
 /**
@@ -2685,11 +2684,16 @@ static unsigned int ata_dev_xfermask(struct ata_port *ap,
  *
  *      LOCKING:
  *      PCI/etc. bus probe sem.
+ *
+ *      RETURNS:
+ *      0 on success, AC_ERR_* mask otherwise.
  */
 
-static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
+static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
+                                         struct ata_device *dev)
 {
         struct ata_taskfile tf;
+        unsigned int err_mask;
 
         /* set up set-features taskfile */
         DPRINTK("set features - xfer mode\n");
@@ -2701,13 +2705,10 @@ static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
         tf.protocol = ATA_PROT_NODATA;
         tf.nsect = dev->xfer_mode;
 
-        if (ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0)) {
-                printk(KERN_ERR "ata%u: failed to set xfermode, disabled\n",
-                       ap->id);
-                ata_port_disable(ap);
-        }
+        err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
 
-        DPRINTK("EXIT\n");
+        DPRINTK("EXIT, err_mask=%x\n", err_mask);
+        return err_mask;
 }
 
 /**
@@ -2784,7 +2785,7 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
 
         if (qc->flags & ATA_QCFLAG_SG) {
                 if (qc->n_elem)
-                        dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
+                        dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
                 /* restore last sg */
                 sg[qc->orig_n_elem - 1].length += qc->pad_len;
                 if (pad_buf) {
@@ -2795,7 +2796,7 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
                 }
         } else {
                 if (qc->n_elem)
-                        dma_unmap_single(ap->host_set->dev,
+                        dma_unmap_single(ap->dev,
                                 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
                                 dir);
                 /* restore sg */
@@ -3006,7 +3007,7 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
                 goto skip_map;
         }
 
-        dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
+        dma_address = dma_map_single(ap->dev, qc->buf_virt,
                                      sg->length, dir);
         if (dma_mapping_error(dma_address)) {
                 /* restore sg */
@@ -3094,7 +3095,7 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
         }
 
         dir = qc->dma_dir;
-        n_elem = dma_map_sg(ap->host_set->dev, sg, pre_n_elem, dir);
+        n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
         if (n_elem < 1) {
                 /* restore last sg */
                 lsg->length += qc->pad_len;
@@ -3793,7 +3794,7 @@ static void ata_pio_error(struct ata_port *ap)
         if (qc->tf.command != ATA_CMD_PACKET)
                 printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
 
-        /* make sure qc->err_mask is available to 
+        /* make sure qc->err_mask is available to
          * know what's wrong and recover
          */
         WARN_ON(qc->err_mask == 0);
@@ -4630,14 +4631,15 @@ int ata_device_resume(struct ata_port *ap, struct ata_device *dev)
  *      Flush the cache on the drive, if appropriate, then issue a
  *      standbynow command.
  */
-int ata_device_suspend(struct ata_port *ap, struct ata_device *dev)
+int ata_device_suspend(struct ata_port *ap, struct ata_device *dev, pm_message_t state)
 {
         if (!ata_dev_present(dev))
                 return 0;
         if (dev->class == ATA_DEV_ATA)
                 ata_flush_cache(ap, dev);
 
-        ata_standby_drive(ap, dev);
+        if (state.event != PM_EVENT_FREEZE)
+                ata_standby_drive(ap, dev);
         ap->flags |= ATA_FLAG_SUSPENDED;
         return 0;
 }
@@ -4657,7 +4659,7 @@ int ata_device_suspend(struct ata_port *ap, struct ata_device *dev)
 
 int ata_port_start (struct ata_port *ap)
 {
-        struct device *dev = ap->host_set->dev;
+        struct device *dev = ap->dev;
         int rc;
 
         ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
@@ -4690,7 +4692,7 @@ int ata_port_start (struct ata_port *ap)
 
 void ata_port_stop (struct ata_port *ap)
 {
-        struct device *dev = ap->host_set->dev;
+        struct device *dev = ap->dev;
 
         dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
         ata_pad_free(ap, dev);
@@ -4756,6 +4758,7 @@ static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
         ap->host = host;
         ap->ctl = ATA_DEVCTL_OBS;
         ap->host_set = host_set;
+        ap->dev = ent->dev;
         ap->port_no = port_no;
         ap->hard_port_no =
                 ent->legacy_mode ? ent->hard_port_no : port_no;
@@ -4771,8 +4774,13 @@ static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
         INIT_WORK(&ap->port_task, NULL, NULL);
         INIT_LIST_HEAD(&ap->eh_done_q);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ap->device[i].devno = i;
+        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                struct ata_device *dev = &ap->device[i];
+                dev->devno = i;
+                dev->pio_mask = UINT_MAX;
+                dev->mwdma_mask = UINT_MAX;
+                dev->udma_mask = UINT_MAX;
+        }
 
 #ifdef ATA_IRQ_TRAP
         ap->stats.unhandled_irq = 1;
@@ -4806,6 +4814,14 @@ static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
         int rc;
 
         DPRINTK("ENTER\n");
+
+        if (!ent->port_ops->probe_reset &&
+            !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
+                printk(KERN_ERR "ata%u: no reset mechanism available\n",
+                       port_no);
+                return NULL;
+        }
+
         host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
         if (!host)
                 return NULL;
@@ -4966,7 +4982,7 @@ err_free_ret:
  *      ata_host_set_remove - PCI layer callback for device removal
  *      @host_set: ATA host set that was removed
  *
- *      Unregister all objects associated with this host set. Free those 
+ *      Unregister all objects associated with this host set. Free those
  *      objects.
  *
  *      LOCKING:
@@ -5238,6 +5254,8 @@ EXPORT_SYMBOL_GPL(ata_std_postreset);
 EXPORT_SYMBOL_GPL(ata_std_probe_reset);
 EXPORT_SYMBOL_GPL(ata_drive_probe_reset);
 EXPORT_SYMBOL_GPL(ata_dev_revalidate);
+EXPORT_SYMBOL_GPL(ata_dev_classify);
+EXPORT_SYMBOL_GPL(ata_dev_pair);
 EXPORT_SYMBOL_GPL(ata_port_disable);
 EXPORT_SYMBOL_GPL(ata_ratelimit);
 EXPORT_SYMBOL_GPL(ata_busy_sleep);
@@ -5248,7 +5266,6 @@ EXPORT_SYMBOL_GPL(ata_scsi_error);
 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
 EXPORT_SYMBOL_GPL(ata_scsi_release);
 EXPORT_SYMBOL_GPL(ata_host_intr);
-EXPORT_SYMBOL_GPL(ata_dev_classify);
 EXPORT_SYMBOL_GPL(ata_id_string);
 EXPORT_SYMBOL_GPL(ata_id_c_string);
 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index a1259b242b8e..628191bfd990 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -256,7 +256,7 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
         scsi_cmd[14] = args[0];
 
         /* Good values for timeout and retries?  Values below
-           from scsi_ioctl_send_command() for default case... */        
+           from scsi_ioctl_send_command() for default case... */
         if (scsi_execute_req(scsidev, scsi_cmd, DMA_NONE, NULL, 0, &sshdr,
                              (10*HZ), 5))
                 rc = -EIO;
@@ -267,20 +267,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
 
 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
 {
-        struct ata_port *ap;
-        struct ata_device *dev;
         int val = -EINVAL, rc = -EINVAL;
 
-        ap = (struct ata_port *) &scsidev->host->hostdata[0];
-        if (!ap)
-                goto out;
-
-        dev = ata_scsi_find_dev(ap, scsidev);
-        if (!dev) {
-                rc = -ENODEV;
-                goto out;
-        }
-
         switch (cmd) {
         case ATA_IOC_GET_IO32:
                 val = 0;
@@ -309,7 +297,6 @@ int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
                 break;
         }
 
-out:
         return rc;
 }
 
@@ -414,12 +401,12 @@ int ata_scsi_device_resume(struct scsi_device *sdev)
         return ata_device_resume(ap, dev);
 }
 
-int ata_scsi_device_suspend(struct scsi_device *sdev)
+int ata_scsi_device_suspend(struct scsi_device *sdev, pm_message_t state)
 {
         struct ata_port *ap = (struct ata_port *) &sdev->host->hostdata[0];
         struct ata_device *dev = &ap->device[sdev->id];
 
-        return ata_device_suspend(ap, dev);
+        return ata_device_suspend(ap, dev, state);
 }
 
 /**
@@ -438,7 +425,7 @@ int ata_scsi_device_suspend(struct scsi_device *sdev)
  *      LOCKING:
  *      spin_lock_irqsave(host_set lock)
  */
-void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc, 
+void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
                         u8 *ascq)
 {
         int i;
@@ -495,7 +482,7 @@ void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
                 /* Look for drv_err */
                 for (i = 0; sense_table[i][0] != 0xFF; i++) {
                         /* Look for best matches first */
-                        if ((sense_table[i][0] & drv_err) == 
+                        if ((sense_table[i][0] & drv_err) ==
                             sense_table[i][0]) {
                                 *sk = sense_table[i][1];
                                 *asc = sense_table[i][2];
@@ -518,7 +505,7 @@ void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
                 }
         }
         /* No error?  Undecoded? */
-        printk(KERN_WARNING "ata%u: no sense translation for status: 0x%02x\n", 
+        printk(KERN_WARNING "ata%u: no sense translation for status: 0x%02x\n",
                id, drv_stat);
 
         /* We need a sensible error return here, which is tricky, and one
@@ -1150,14 +1137,14 @@ static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, const u8 *sc
 
                 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
                         (u32)block, track, cyl, head, sect);
-                
-                /* Check whether the converted CHS can fit. 
-                   Cylinder: 0-65535 
+
+                /* Check whether the converted CHS can fit.
+                   Cylinder: 0-65535
                    Head: 0-15
                    Sector: 1-255*/
-                if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect)) 
+                if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
                         goto out_of_range;
-                
+
                 tf->command = ATA_CMD_VERIFY;
                 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
                 tf->lbal = sect;
@@ -1289,7 +1276,7 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
                 tf->lbal = block & 0xff;
 
                 tf->device |= ATA_LBA;
-        } else { 
+        } else {
                 /* CHS */
                 u32 sect, head, cyl, track;
 
@@ -1309,8 +1296,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
                 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
                         (u32)block, track, cyl, head, sect);
 
-                /* Check whether the converted CHS can fit. 
-                   Cylinder: 0-65535 
+                /* Check whether the converted CHS can fit.
+                   Cylinder: 0-65535
                    Head: 0-15
                    Sector: 1-255*/
                 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
@@ -1697,7 +1684,7 @@ unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
 
         if (buflen > (ATA_SERNO_LEN + num + 3)) {
                 /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
-                rbuf[num + 0] = 2;      
+                rbuf[num + 0] = 2;
                 rbuf[num + 3] = ATA_SERNO_LEN;
                 num += 4;
                 ata_id_string(args->id, (unsigned char *) rbuf + num,
@@ -1707,8 +1694,8 @@ unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
         if (buflen > (sat_model_serial_desc_len + num + 3)) {
                 /* SAT defined lu model and serial numbers descriptor */
                 /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
-                rbuf[num + 0] = 2;      
-                rbuf[num + 1] = 1;      
+                rbuf[num + 0] = 2;
+                rbuf[num + 1] = 1;
                 rbuf[num + 3] = sat_model_serial_desc_len;
                 num += 4;
                 memcpy(rbuf + num, "ATA     ", 8);
@@ -2597,6 +2584,21 @@ static inline void ata_scsi_dump_cdb(struct ata_port *ap,
 #endif
 }
 
+static inline void __ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
+                                       struct ata_port *ap, struct ata_device *dev)
+{
+        if (dev->class == ATA_DEV_ATA) {
+                ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
+                                                              cmd->cmnd[0]);
+
+                if (xlat_func)
+                        ata_scsi_translate(ap, dev, cmd, done, xlat_func);
+                else
+                        ata_scsi_simulate(ap, dev, cmd, done);
+        } else
+                ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
+}
+
 /**
  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
  *      @cmd: SCSI command to be sent
@@ -2631,24 +2633,13 @@ int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
         ata_scsi_dump_cdb(ap, cmd);
 
         dev = ata_scsi_find_dev(ap, scsidev);
-        if (unlikely(!dev)) {
+        if (likely(dev))
+                __ata_scsi_queuecmd(cmd, done, ap, dev);
+        else {
                 cmd->result = (DID_BAD_TARGET << 16);
                 done(cmd);
-                goto out_unlock;
         }
 
-        if (dev->class == ATA_DEV_ATA) {
-                ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
-                                                              cmd->cmnd[0]);
-
-                if (xlat_func)
-                        ata_scsi_translate(ap, dev, cmd, done, xlat_func);
-                else
-                        ata_scsi_simulate(ap, dev, cmd, done);
-        } else
-                ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
-
-out_unlock:
         spin_unlock(&ap->host_set->lock);
         spin_lock(shost->host_lock);
         return 0;
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index bf9f7f7ba354..c11e5ce6865e 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -2797,7 +2797,7 @@ mbox_post_sync_cmd(adapter_t *adapter, uint8_t raw_mbox[])
         // available within 1 second, assume FW is initializing and wait
         // for an extended amount of time
         if (mbox->numstatus == 0xFF) {  // status not yet available
-                udelay(25);;
+                udelay(25);
 
                 for (i = 0; mbox->numstatus == 0xFF && i < 1000; i++) {
                         rmb();
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index 3e75d6733239..18c296c56899 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -371,7 +371,7 @@ static void sil_dev_config(struct ata_port *ap, struct ata_device *dev)
         if (quirks & SIL_QUIRK_UDMA5MAX) {
                 printk(KERN_INFO "ata%u(%u): applying Maxtor errata fix %s\n",
                        ap->id, dev->devno, model_num);
-                ap->udma_mask &= ATA_UDMA5;
+                dev->udma_mask &= ATA_UDMA5;
                 return;
         }
 }
diff --git a/drivers/scsi/sata_sil24.c b/drivers/scsi/sata_sil24.c
index 3efebea211f2..068c98a4111b 100644
--- a/drivers/scsi/sata_sil24.c
+++ b/drivers/scsi/sata_sil24.c
@@ -342,7 +342,7 @@ static struct ata_port_info sil24_port_info[] = {
                 .udma_mask      = 0x3f,                 /* udma0-5 */
                 .port_ops       = &sil24_ops,
         },
-        /* sil_3132 */ 
+        /* sil_3132 */
         {
                 .sht            = &sil24_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index 9f621a97c977..5af6d5f9f4bd 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -237,11 +237,11 @@ static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance,
                                         handled += ata_host_intr(ap, qc);
                                 else if (is_vsc_sata_int_err(i, int_status)) {
                                         /*
-                                         * On some chips (i.e. Intel 31244), an error 
+                                         * On some chips (i.e. Intel 31244), an error
                                          * interrupt will sneak in at initialization
                                          * time (phy state changes).  Clearing the SCR
                                          * error register is not required, but it prevents
-                                         * the phy state change interrupts from recurring 
+                                         * the phy state change interrupts from recurring
                                          * later.
                                          */
                                         u32 err_status;
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 89055494dfee..a6fde52946d6 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -286,7 +286,7 @@ static int scsi_bus_suspend(struct device * dev, pm_message_t state)
                 return err;
 
         if (sht->suspend)
-                err = sht->suspend(sdev);
+                err = sht->suspend(sdev, state);
 
         return err;
 }
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index f9c1192dc15e..7c80711e18ed 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -71,7 +71,7 @@ MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_CDROM_MAJOR);
 #define SR_CAPABILITIES \
         (CDC_CLOSE_TRAY|CDC_OPEN_TRAY|CDC_LOCK|CDC_SELECT_SPEED| \
          CDC_SELECT_DISC|CDC_MULTI_SESSION|CDC_MCN|CDC_MEDIA_CHANGED| \
-         CDC_PLAY_AUDIO|CDC_RESET|CDC_IOCTLS|CDC_DRIVE_STATUS| \
+         CDC_PLAY_AUDIO|CDC_RESET|CDC_DRIVE_STATUS| \
          CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_DVD_RAM|CDC_GENERIC_PACKET| \
          CDC_MRW|CDC_MRW_W|CDC_RAM)
 
@@ -118,7 +118,6 @@ static struct cdrom_device_ops sr_dops = {
         .get_mcn                = sr_get_mcn,
         .reset                  = sr_reset,
         .audio_ioctl            = sr_audio_ioctl,
-        .dev_ioctl              = sr_dev_ioctl,
         .capability             = SR_CAPABILITIES,
         .generic_packet         = sr_packet,
 };
@@ -456,17 +455,33 @@ static int sr_block_ioctl(struct inode *inode, struct file *file, unsigned cmd,
 {
         struct scsi_cd *cd = scsi_cd(inode->i_bdev->bd_disk);
         struct scsi_device *sdev = cd->device;
+        void __user *argp = (void __user *)arg;
+        int ret;
 
-        /*
-         * Send SCSI addressing ioctls directly to mid level, send other
-         * ioctls to cdrom/block level.
-         */
-        switch (cmd) {
-                case SCSI_IOCTL_GET_IDLUN:
-                case SCSI_IOCTL_GET_BUS_NUMBER:
-                        return scsi_ioctl(sdev, cmd, (void __user *)arg);
+        /*
+         * Send SCSI addressing ioctls directly to mid level, send other
+         * ioctls to cdrom/block level.
+         */
+        switch (cmd) {
+        case SCSI_IOCTL_GET_IDLUN:
+        case SCSI_IOCTL_GET_BUS_NUMBER:
+                return scsi_ioctl(sdev, cmd, argp);
         }
-        return cdrom_ioctl(file, &cd->cdi, inode, cmd, arg);
+
+        ret = cdrom_ioctl(file, &cd->cdi, inode, cmd, arg);
+        if (ret != ENOSYS)
+                return ret;
+
+        /*
+         * ENODEV means that we didn't recognise the ioctl, or that we
+         * cannot execute it in the current device state.  In either
+         * case fall through to scsi_ioctl, which will return ENDOEV again
+         * if it doesn't recognise the ioctl
+         */
+        ret = scsi_nonblockable_ioctl(sdev, cmd, argp, NULL);
+        if (ret != -ENODEV)
+                return ret;
+        return scsi_ioctl(sdev, cmd, argp);
 }
 
 static int sr_block_media_changed(struct gendisk *disk)
diff --git a/drivers/scsi/sr.h b/drivers/scsi/sr.h
index d2bcd99c272f..d65de9621b27 100644
--- a/drivers/scsi/sr.h
+++ b/drivers/scsi/sr.h
@@ -55,7 +55,6 @@ int sr_get_mcn(struct cdrom_device_info *, struct cdrom_mcn *);
 int sr_reset(struct cdrom_device_info *);
 int sr_select_speed(struct cdrom_device_info *cdi, int speed);
 int sr_audio_ioctl(struct cdrom_device_info *, unsigned int, void *);
-int sr_dev_ioctl(struct cdrom_device_info *, unsigned int, unsigned long);
 
 int sr_is_xa(Scsi_CD *);
 
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index b65462f76484..d1268cb46837 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -562,22 +562,3 @@ int sr_is_xa(Scsi_CD *cd)
 #endif
         return is_xa;
 }
-
-int sr_dev_ioctl(struct cdrom_device_info *cdi,
-                 unsigned int cmd, unsigned long arg)
-{
-        Scsi_CD *cd = cdi->handle;
-        int ret;
-        
-        ret = scsi_nonblockable_ioctl(cd->device, cmd,
-                                      (void __user *)arg, NULL);
-        /*
-         * ENODEV means that we didn't recognise the ioctl, or that we
-         * cannot execute it in the current device state.  In either
-         * case fall through to scsi_ioctl, which will return ENDOEV again
-         * if it doesn't recognise the ioctl
-         */
-        if (ret != -ENODEV)
-                return ret;
-        return scsi_ioctl(cd->device, cmd, (void __user *)arg);
-}