Merge branch 'master'

36 files changed, 339 insertions, 156 deletions

diff --git a/drivers/scsi/NCR5380.c b/drivers/scsi/NCR5380.c
index d40ba0bd68a3..23392ae7df8b 100644
--- a/drivers/scsi/NCR5380.c
+++ b/drivers/scsi/NCR5380.c
@@ -91,7 +91,7 @@
 #ifndef NDEBUG
 #define NDEBUG 0
 #endif
-#ifndef NDEBUG
+#ifndef NDEBUG_ABORT
 #define NDEBUG_ABORT 0
 #endif
 
diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
index 4a99d2f000f4..d54b1cc88d0d 100644
--- a/drivers/scsi/aacraid/aacraid.h
+++ b/drivers/scsi/aacraid/aacraid.h
@@ -19,7 +19,7 @@
 #define AAC_MAX_LUN             (8)
 
 #define AAC_MAX_HOSTPHYSMEMPAGES (0xfffff)
-#define AAC_MAX_32BIT_SGBCOUNT  ((unsigned short)512)
+#define AAC_MAX_32BIT_SGBCOUNT  ((unsigned short)256)
 
 /*
  * These macros convert from physical channels to virtual channels
diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index f0d8f89b5d40..cbab5868ffdf 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -216,7 +216,7 @@ static Scsi_Host_Template ahci_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations ahci_ops = {
+static const struct ata_port_operations ahci_ops = {
         .port_disable           = ata_port_disable,
 
         .check_status           = ahci_check_status,
@@ -415,7 +415,7 @@ static u32 ahci_scr_read (struct ata_port *ap, unsigned int sc_reg_in)
                 return 0xffffffffU;
         }
 
-        return readl((void *) ap->ioaddr.scr_addr + (sc_reg * 4));
+        return readl((void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
 }
 
 
@@ -433,7 +433,7 @@ static void ahci_scr_write (struct ata_port *ap, unsigned int sc_reg_in,
                 return;
         }
 
-        writel(val, (void *) ap->ioaddr.scr_addr + (sc_reg * 4));
+        writel(val, (void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
 }
 
 static void ahci_phy_reset(struct ata_port *ap)
@@ -461,14 +461,14 @@ static void ahci_phy_reset(struct ata_port *ap)
 
 static u8 ahci_check_status(struct ata_port *ap)
 {
-        void *mmio = (void *) ap->ioaddr.cmd_addr;
+        void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr;
 
         return readl(mmio + PORT_TFDATA) & 0xFF;
 }
 
 static u8 ahci_check_err(struct ata_port *ap)
 {
-        void *mmio = (void *) ap->ioaddr.cmd_addr;
+        void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr;
 
         return (readl(mmio + PORT_TFDATA) >> 8) & 0xFF;
 }
diff --git a/drivers/scsi/ata_piix.c b/drivers/scsi/ata_piix.c
index d71cef767cec..be021478f416 100644
--- a/drivers/scsi/ata_piix.c
+++ b/drivers/scsi/ata_piix.c
@@ -147,7 +147,7 @@ static Scsi_Host_Template piix_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations piix_pata_ops = {
+static const struct ata_port_operations piix_pata_ops = {
         .port_disable           = ata_port_disable,
         .set_piomode            = piix_set_piomode,
         .set_dmamode            = piix_set_dmamode,
@@ -177,7 +177,7 @@ static struct ata_port_operations piix_pata_ops = {
         .host_stop              = ata_host_stop,
 };
 
-static struct ata_port_operations piix_sata_ops = {
+static const struct ata_port_operations piix_sata_ops = {
         .port_disable           = ata_port_disable,
 
         .tf_load                = ata_tf_load,
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index c10e45b94b62..3d13fdee4fc2 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -1357,7 +1357,7 @@ static int port_detect(unsigned long port_base, unsigned int j,
 
         for (i = 0; i < shost->can_queue; i++) {
                 size_t sz = shost->sg_tablesize *sizeof(struct sg_list);
-                unsigned int gfp_mask = (shost->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC;
+                gfp_t gfp_mask = (shost->unchecked_isa_dma ? GFP_DMA : 0) | GFP_ATOMIC;
                 ha->cp[i].sglist = kmalloc(sz, gfp_mask);
                 if (!ha->cp[i].sglist) {
                         printk
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 02fe371b0ab8..f24d84538fd5 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -287,7 +287,8 @@ static void scsi_host_dev_release(struct device *dev)
 struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
 {
         struct Scsi_Host *shost;
-        int gfp_mask = GFP_KERNEL, rval;
+        gfp_t gfp_mask = GFP_KERNEL;
+        int rval;
 
         if (sht->unchecked_isa_dma && privsize)
                 gfp_mask |= __GFP_DMA;
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index c5e663fefdf7..64f30bf59315 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -67,9 +67,9 @@ static void ata_dev_reread_id(struct ata_port *ap, struct ata_device *dev);
 static void 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_get_mode_mask(struct ata_port *ap, int shift);
+static unsigned int ata_get_mode_mask(const struct ata_port *ap, int shift);
 static int fgb(u32 bitmap);
-static int ata_choose_xfer_mode(struct ata_port *ap,
+static int ata_choose_xfer_mode(const struct ata_port *ap,
                                 u8 *xfer_mode_out,
                                 unsigned int *xfer_shift_out);
 static void __ata_qc_complete(struct ata_queued_cmd *qc);
@@ -87,7 +87,7 @@ MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
 /**
- *      ata_tf_load - send taskfile registers to host controller
+ *      ata_tf_load_pio - send taskfile registers to host controller
  *      @ap: Port to which output is sent
  *      @tf: ATA taskfile register set
  *
@@ -97,7 +97,7 @@ MODULE_VERSION(DRV_VERSION);
  *      Inherited from caller.
  */
 
-static void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_tf_load_pio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
@@ -155,7 +155,7 @@ static void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf)
  *      Inherited from caller.
  */
 
-static void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
@@ -224,7 +224,7 @@ static void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
  *      LOCKING:
  *      Inherited from caller.
  */
-void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
+void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         if (ap->flags & ATA_FLAG_MMIO)
                 ata_tf_load_mmio(ap, tf);
@@ -244,7 +244,7 @@ void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
  *      spin_lock_irqsave(host_set lock)
  */
 
-static void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_exec_command_pio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
 
@@ -265,7 +265,7 @@ static void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf)
  *      spin_lock_irqsave(host_set lock)
  */
 
-static void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
 
@@ -285,7 +285,7 @@ static void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
  *      LOCKING:
  *      spin_lock_irqsave(host_set lock)
  */
-void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
+void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         if (ap->flags & ATA_FLAG_MMIO)
                 ata_exec_command_mmio(ap, tf);
@@ -305,7 +305,7 @@ void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
  *      Obtains host_set lock.
  */
 
-static inline void ata_exec(struct ata_port *ap, struct ata_taskfile *tf)
+static inline void ata_exec(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         unsigned long flags;
 
@@ -328,7 +328,7 @@ static inline void ata_exec(struct ata_port *ap, struct ata_taskfile *tf)
  *      Obtains host_set lock.
  */
 
-static void ata_tf_to_host(struct ata_port *ap, struct ata_taskfile *tf)
+static void ata_tf_to_host(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         ap->ops->tf_load(ap, tf);
 
@@ -348,7 +348,7 @@ static void ata_tf_to_host(struct ata_port *ap, struct ata_taskfile *tf)
  *      spin_lock_irqsave(host_set lock)
  */
 
-void ata_tf_to_host_nolock(struct ata_port *ap, struct ata_taskfile *tf)
+void ata_tf_to_host_nolock(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         ap->ops->tf_load(ap, tf);
         ap->ops->exec_command(ap, tf);
@@ -558,7 +558,7 @@ u8 ata_chk_err(struct ata_port *ap)
  *      Inherited from caller.
  */
 
-void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp)
+void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
 {
         fis[0] = 0x27;  /* Register - Host to Device FIS */
         fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
@@ -599,7 +599,7 @@ void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp)
  *      Inherited from caller.
  */
 
-void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf)
+void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
 {
         tf->command     = fis[2];       /* status */
         tf->feature     = fis[3];       /* error */
@@ -845,7 +845,7 @@ static unsigned int ata_devchk(struct ata_port *ap,
  *      the event of failure.
  */
 
-unsigned int ata_dev_classify(struct ata_taskfile *tf)
+unsigned int ata_dev_classify(const struct ata_taskfile *tf)
 {
         /* Apple's open source Darwin code hints that some devices only
          * put a proper signature into the LBA mid/high registers,
@@ -937,7 +937,7 @@ static u8 ata_dev_try_classify(struct ata_port *ap, unsigned int device)
  *      caller.
  */
 
-void ata_dev_id_string(u16 *id, unsigned char *s,
+void ata_dev_id_string(const u16 *id, unsigned char *s,
                        unsigned int ofs, unsigned int len)
 {
         unsigned int c;
@@ -1054,7 +1054,7 @@ void ata_dev_select(struct ata_port *ap, unsigned int device,
  *      caller.
  */
 
-static inline void ata_dump_id(struct ata_device *dev)
+static inline void ata_dump_id(const struct ata_device *dev)
 {
         DPRINTK("49==0x%04x  "
                 "53==0x%04x  "
@@ -1082,6 +1082,31 @@ static inline void ata_dump_id(struct ata_device *dev)
                 dev->id[93]);
 }
 
+/*
+ *      Compute the PIO modes available for this device. This is not as
+ *      trivial as it seems if we must consider early devices correctly.
+ *
+ *      FIXME: pre IDE drive timing (do we care ?). 
+ */
+
+static unsigned int ata_pio_modes(const struct ata_device *adev)
+{
+        u16 modes;
+
+        /* Usual case. Word 53 indicates word 88 is valid */
+        if (adev->id[ATA_ID_FIELD_VALID] & (1 << 2)) {
+                modes = adev->id[ATA_ID_PIO_MODES] & 0x03;
+                modes <<= 3;
+                modes |= 0x7;
+                return modes;
+        }
+
+        /* If word 88 isn't valid then Word 51 holds the PIO timing number
+           for the maximum. Turn it into a mask and return it */
+        modes = (2 << (adev->id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
+        return modes;
+}
+
 /**
  *      ata_dev_identify - obtain IDENTIFY x DEVICE page
  *      @ap: port on which device we wish to probe resides
@@ -1215,10 +1240,8 @@ retry:
         xfer_modes = dev->id[ATA_ID_UDMA_MODES];
         if (!xfer_modes)
                 xfer_modes = (dev->id[ATA_ID_MWDMA_MODES]) << ATA_SHIFT_MWDMA;
-        if (!xfer_modes) {
-                xfer_modes = (dev->id[ATA_ID_PIO_MODES]) << (ATA_SHIFT_PIO + 3);
-                xfer_modes |= (0x7 << ATA_SHIFT_PIO);
-        }
+        if (!xfer_modes)
+                xfer_modes = ata_pio_modes(dev);
 
         ata_dump_id(dev);
 
@@ -1329,7 +1352,7 @@ err_out:
 }
 
 
-static inline u8 ata_dev_knobble(struct ata_port *ap)
+static inline u8 ata_dev_knobble(const struct ata_port *ap)
 {
         return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(ap->device->id)));
 }
@@ -1515,7 +1538,153 @@ void ata_port_disable(struct ata_port *ap)
         ap->flags |= ATA_FLAG_PORT_DISABLED;
 }
 
-static struct {
+/*
+ * This mode timing computation functionality is ported over from
+ * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
+ */
+/*
+ * 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. 
+ */
+
+static const struct ata_timing ata_timing[] = {
+
+        { XFER_UDMA_6,     0,   0,   0,   0,   0,   0,   0,  15 },
+        { XFER_UDMA_5,     0,   0,   0,   0,   0,   0,   0,  20 },
+        { XFER_UDMA_4,     0,   0,   0,   0,   0,   0,   0,  30 },
+        { XFER_UDMA_3,     0,   0,   0,   0,   0,   0,   0,  45 },
+
+        { XFER_UDMA_2,     0,   0,   0,   0,   0,   0,   0,  60 },
+        { XFER_UDMA_1,     0,   0,   0,   0,   0,   0,   0,  80 },
+        { 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 },
+
+/*      { XFER_PIO_5,     20,  50,  30, 100,  50,  30, 100,   0 }, */
+        { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 120,   0 },
+        { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 180,   0 },
+
+        { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 240,   0 },
+        { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 383,   0 },
+        { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 600,   0 },
+
+/*      { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960,   0 }, */
+
+        { 0xFF }
+};
+
+#define ENOUGH(v,unit)          (((v)-1)/(unit)+1)
+#define EZ(v,unit)              ((v)?ENOUGH(v,unit):0)
+
+static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
+{
+        q->setup   = EZ(t->setup   * 1000,  T);
+        q->act8b   = EZ(t->act8b   * 1000,  T);
+        q->rec8b   = EZ(t->rec8b   * 1000,  T);
+        q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
+        q->active  = EZ(t->active  * 1000,  T);
+        q->recover = EZ(t->recover * 1000,  T);
+        q->cycle   = EZ(t->cycle   * 1000,  T);
+        q->udma    = EZ(t->udma    * 1000, UT);
+}
+
+void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
+                      struct ata_timing *m, unsigned int what)
+{
+        if (what & ATA_TIMING_SETUP  ) m->setup   = max(a->setup,   b->setup);
+        if (what & ATA_TIMING_ACT8B  ) m->act8b   = max(a->act8b,   b->act8b);
+        if (what & ATA_TIMING_REC8B  ) m->rec8b   = max(a->rec8b,   b->rec8b);
+        if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
+        if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
+        if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
+        if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
+        if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
+}
+
+static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
+{
+        const struct ata_timing *t;
+
+        for (t = ata_timing; t->mode != speed; t++)
+                if (t->mode == 0xFF)
+                        return NULL;
+        return t; 
+}
+
+int ata_timing_compute(struct ata_device *adev, unsigned short speed,
+                       struct ata_timing *t, int T, int UT)
+{
+        const struct ata_timing *s;
+        struct ata_timing p;
+
+        /*
+         * Find the mode. 
+        */
+
+        if (!(s = ata_timing_find_mode(speed)))
+                return -EINVAL;
+
+        /*
+         * If the drive is an EIDE drive, it can tell us it needs extended
+         * PIO/MW_DMA cycle timing.
+         */
+
+        if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
+                memset(&p, 0, sizeof(p));
+                if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
+                        if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
+                                            else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
+                } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
+                        p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
+                }
+                ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
+        }
+
+        /*
+         * Convert the timing to bus clock counts.
+         */
+
+        ata_timing_quantize(s, t, T, UT);
+
+        /*
+         * Even in DMA/UDMA modes we still use PIO access for IDENTIFY, S.M.A.R.T
+         * and some other commands. We have to ensure that the DMA cycle timing is
+         * slower/equal than the fastest PIO timing.
+         */
+
+        if (speed > XFER_PIO_4) {
+                ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
+                ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
+        }
+
+        /*
+         * Lenghten active & recovery time so that cycle time is correct.
+         */
+
+        if (t->act8b + t->rec8b < t->cyc8b) {
+                t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
+                t->rec8b = t->cyc8b - t->act8b;
+        }
+
+        if (t->active + t->recover < t->cycle) {
+                t->active += (t->cycle - (t->active + t->recover)) / 2;
+                t->recover = t->cycle - t->active;
+        }
+
+        return 0;
+}
+
+static const struct {
         unsigned int shift;
         u8 base;
 } xfer_mode_classes[] = {
@@ -1924,7 +2093,8 @@ err_out:
         DPRINTK("EXIT\n");
 }
 
-static void ata_pr_blacklisted(struct ata_port *ap, struct ata_device *dev)
+static void ata_pr_blacklisted(const struct ata_port *ap,
+                               const struct ata_device *dev)
 {
         printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, disabling DMA\n",
                 ap->id, dev->devno);
@@ -1962,7 +2132,7 @@ static const char * ata_dma_blacklist [] = {
         "_NEC DV5800A",
 };
 
-static int ata_dma_blacklisted(struct ata_port *ap, struct ata_device *dev)
+static int ata_dma_blacklisted(const struct ata_device *dev)
 {
         unsigned char model_num[40];
         char *s;
@@ -1987,9 +2157,9 @@ static int ata_dma_blacklisted(struct ata_port *ap, struct ata_device *dev)
         return 0;
 }
 
-static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift)
+static unsigned int ata_get_mode_mask(const struct ata_port *ap, int shift)
 {
-        struct ata_device *master, *slave;
+        const struct ata_device *master, *slave;
         unsigned int mask;
 
         master = &ap->device[0];
@@ -2001,14 +2171,14 @@ static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift)
                 mask = ap->udma_mask;
                 if (ata_dev_present(master)) {
                         mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
-                        if (ata_dma_blacklisted(ap, master)) {
+                        if (ata_dma_blacklisted(master)) {
                                 mask = 0;
                                 ata_pr_blacklisted(ap, master);
                         }
                 }
                 if (ata_dev_present(slave)) {
                         mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
-                        if (ata_dma_blacklisted(ap, slave)) {
+                        if (ata_dma_blacklisted(slave)) {
                                 mask = 0;
                                 ata_pr_blacklisted(ap, slave);
                         }
@@ -2018,14 +2188,14 @@ static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift)
                 mask = ap->mwdma_mask;
                 if (ata_dev_present(master)) {
                         mask &= (master->id[ATA_ID_MWDMA_MODES] & 0x07);
-                        if (ata_dma_blacklisted(ap, master)) {
+                        if (ata_dma_blacklisted(master)) {
                                 mask = 0;
                                 ata_pr_blacklisted(ap, master);
                         }
                 }
                 if (ata_dev_present(slave)) {
                         mask &= (slave->id[ATA_ID_MWDMA_MODES] & 0x07);
-                        if (ata_dma_blacklisted(ap, slave)) {
+                        if (ata_dma_blacklisted(slave)) {
                                 mask = 0;
                                 ata_pr_blacklisted(ap, slave);
                         }
@@ -2089,7 +2259,7 @@ static int fgb(u32 bitmap)
  *      Zero on success, negative on error.
  */
 
-static int ata_choose_xfer_mode(struct ata_port *ap,
+static int ata_choose_xfer_mode(const struct ata_port *ap,
                                 u8 *xfer_mode_out,
                                 unsigned int *xfer_shift_out)
 {
@@ -2613,13 +2783,13 @@ void ata_poll_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
 
 /**
  *      ata_pio_poll -
- *      @ap:
+ *      @ap: the target ata_port
  *
  *      LOCKING:
  *      None.  (executing in kernel thread context)
  *
  *      RETURNS:
- *
+ *      timeout value to use
  */
 
 static unsigned long ata_pio_poll(struct ata_port *ap)
@@ -2660,8 +2830,8 @@ static unsigned long ata_pio_poll(struct ata_port *ap)
 }
 
 /**
- *      ata_pio_complete -
- *      @ap:
+ *      ata_pio_complete - check if drive is busy or idle
+ *      @ap: the target ata_port
  *
  *      LOCKING:
  *      None.  (executing in kernel thread context)
@@ -2713,7 +2883,7 @@ static int ata_pio_complete (struct ata_port *ap)
 
 
 /**
- *      swap_buf_le16 -
+ *      swap_buf_le16 - swap halves of 16-words in place
  *      @buf:  Buffer to swap
  *      @buf_words:  Number of 16-bit words in buffer.
  *
@@ -2722,6 +2892,7 @@ static int ata_pio_complete (struct ata_port *ap)
  *      vice-versa.
  *
  *      LOCKING:
+ *      Inherited from caller.
  */
 void swap_buf_le16(u16 *buf, unsigned int buf_words)
 {
@@ -2744,7 +2915,6 @@ void swap_buf_le16(u16 *buf, unsigned int buf_words)
  *
  *      LOCKING:
  *      Inherited from caller.
- *
  */
 
 static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
@@ -2790,7 +2960,6 @@ static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
  *
  *      LOCKING:
  *      Inherited from caller.
- *
  */
 
 static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
@@ -2830,7 +2999,6 @@ static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
  *
  *      LOCKING:
  *      Inherited from caller.
- *
  */
 
 static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
@@ -2983,7 +3151,6 @@ next_sg:
  *
  *      LOCKING:
  *      Inherited from caller.
- *
  */
 
 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
@@ -3019,8 +3186,8 @@ err_out:
 }
 
 /**
- *      ata_pio_sector -
- *      @ap:
+ *      ata_pio_block - start PIO on a block
+ *      @ap: the target ata_port
  *
  *      LOCKING:
  *      None.  (executing in kernel thread context)
@@ -3032,7 +3199,7 @@ static void ata_pio_block(struct ata_port *ap)
         u8 status;
 
         /*
-         * This is purely hueristic.  This is a fast path.
+         * This is purely heuristic.  This is a fast path.
          * Sometimes when we enter, BSY will be cleared in
          * a chk-status or two.  If not, the drive is probably seeking
          * or something.  Snooze for a couple msecs, then
@@ -3352,7 +3519,6 @@ static void __ata_qc_complete(struct ata_queued_cmd *qc)
  *
  *      LOCKING:
  *      spin_lock_irqsave(host_set lock)
- *
  */
 void ata_qc_free(struct ata_queued_cmd *qc)
 {
@@ -3372,7 +3538,6 @@ void ata_qc_free(struct ata_queued_cmd *qc)
  *
  *      LOCKING:
  *      spin_lock_irqsave(host_set lock)
- *
  */
 
 void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
@@ -3866,7 +4031,6 @@ idle_irq:
  *
  *      RETURNS:
  *      IRQ_NONE or IRQ_HANDLED.
- *
  */
 
 irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
@@ -3978,6 +4142,7 @@ err_out:
  *      May be used as the port_start() entry in ata_port_operations.
  *
  *      LOCKING:
+ *      Inherited from caller.
  */
 
 int ata_port_start (struct ata_port *ap)
@@ -4009,6 +4174,7 @@ int ata_port_start (struct ata_port *ap)
  *      May be used as the port_stop() entry in ata_port_operations.
  *
  *      LOCKING:
+ *      Inherited from caller.
  */
 
 void ata_port_stop (struct ata_port *ap)
@@ -4032,6 +4198,7 @@ void ata_host_stop (struct ata_host_set *host_set)
  *      @do_unregister: 1 if we fully unregister, 0 to just stop the port
  *
  *      LOCKING:
+ *      Inherited from caller.
  */
 
 static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
@@ -4059,12 +4226,11 @@ static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
  *
  *      LOCKING:
  *      Inherited from caller.
- *
  */
 
 static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
                           struct ata_host_set *host_set,
-                          struct ata_probe_ent *ent, unsigned int port_no)
+                          const struct ata_probe_ent *ent, unsigned int port_no)
 {
         unsigned int i;
 
@@ -4120,10 +4286,9 @@ static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
  *
  *      RETURNS:
  *      New ata_port on success, for NULL on error.
- *
  */
 
-static struct ata_port * ata_host_add(struct ata_probe_ent *ent,
+static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
                                       struct ata_host_set *host_set,
                                       unsigned int port_no)
 {
@@ -4168,10 +4333,9 @@ err_out:
  *
  *      RETURNS:
  *      Number of ports registered.  Zero on error (no ports registered).
- *
  */
 
-int ata_device_add(struct ata_probe_ent *ent)
+int ata_device_add(const struct ata_probe_ent *ent)
 {
         unsigned int count = 0, i;
         struct device *dev = ent->dev;
@@ -4300,7 +4464,6 @@ err_out:
  *      Inherited from calling layer (may sleep).
  */
 
-
 void ata_host_set_remove(struct ata_host_set *host_set)
 {
         struct ata_port *ap;
@@ -4390,7 +4553,7 @@ void ata_std_ports(struct ata_ioports *ioaddr)
 }
 
 static struct ata_probe_ent *
-ata_probe_ent_alloc(struct device *dev, struct ata_port_info *port)
+ata_probe_ent_alloc(struct device *dev, const struct ata_port_info *port)
 {
         struct ata_probe_ent *probe_ent;
 
@@ -4490,7 +4653,6 @@ static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev, stru
         if (!probe_ent)
                 return NULL;
 
-        
         probe_ent->legacy_mode = 1;
         probe_ent->n_ports = 1;
         probe_ent->hard_port_no = port_num;
@@ -4534,7 +4696,6 @@ static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev, stru
  *
  *      RETURNS:
  *      Zero on success, negative on errno-based value on error.
- *
  */
 
 int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
@@ -4682,7 +4843,7 @@ err_out:
  *      @pdev: PCI device that was removed
  *
  *      PCI layer indicates to libata via this hook that
- *      hot-unplug or module unload event has occured.
+ *      hot-unplug or module unload event has occurred.
  *      Handle this by unregistering all objects associated
  *      with this PCI device.  Free those objects.  Then finally
  *      release PCI resources and disable device.
@@ -4703,7 +4864,7 @@ void ata_pci_remove_one (struct pci_dev *pdev)
 }
 
 /* move to PCI subsystem */
-int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits)
+int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
 {
         unsigned long tmp = 0;
 
@@ -4830,6 +4991,9 @@ EXPORT_SYMBOL_GPL(ata_dev_id_string);
 EXPORT_SYMBOL_GPL(ata_dev_config);
 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
 
+EXPORT_SYMBOL_GPL(ata_timing_compute);
+EXPORT_SYMBOL_GPL(ata_timing_merge);
+
 #ifdef CONFIG_PCI
 EXPORT_SYMBOL_GPL(pci_test_config_bits);
 EXPORT_SYMBOL_GPL(ata_pci_host_stop);
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index 9944adbe5a1d..a68c0341dc82 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -44,9 +44,9 @@
 
 #include "libata.h"
 
-typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc, u8 *scsicmd);
+typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc, const u8 *scsicmd);
 static struct ata_device *
-ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev);
+ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev);
 
 
 static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
@@ -428,7 +428,7 @@ int ata_scsi_error(struct Scsi_Host *host)
  */
 
 static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc,
-                                             u8 *scsicmd)
+                                             const u8 *scsicmd)
 {
         struct ata_taskfile *tf = &qc->tf;
 
@@ -495,7 +495,7 @@ invalid_fld:
  *      Zero on success, non-zero on error.
  */
 
-static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
+static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, const u8 *scsicmd)
 {
         struct ata_taskfile *tf = &qc->tf;
 
@@ -522,7 +522,7 @@ static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
  *      @plen: the transfer length
  */
 
-static void scsi_6_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
+static void scsi_6_lba_len(const u8 *scsicmd, u64 *plba, u32 *plen)
 {
         u64 lba = 0;
         u32 len = 0;
@@ -549,7 +549,7 @@ static void scsi_6_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
  *      @plen: the transfer length
  */
 
-static void scsi_10_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
+static void scsi_10_lba_len(const u8 *scsicmd, u64 *plba, u32 *plen)
 {
         u64 lba = 0;
         u32 len = 0;
@@ -579,7 +579,7 @@ static void scsi_10_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
  *      @plen: the transfer length
  */
 
-static void scsi_16_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
+static void scsi_16_lba_len(const u8 *scsicmd, u64 *plba, u32 *plen)
 {
         u64 lba = 0;
         u32 len = 0;
@@ -618,7 +618,7 @@ static void scsi_16_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
  *      Zero on success, non-zero on error.
  */
 
-static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
+static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, const u8 *scsicmd)
 {
         struct ata_taskfile *tf = &qc->tf;
         struct ata_device *dev = qc->dev;
@@ -744,7 +744,7 @@ nothing_to_do:
  *      Zero on success, non-zero on error.
  */
 
-static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
+static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicmd)
 {
         struct ata_taskfile *tf = &qc->tf;
         struct ata_device *dev = qc->dev;
@@ -1698,7 +1698,7 @@ static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
  *      Zero on success, non-zero on failure.
  */
 
-static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
+static unsigned int atapi_xlat(struct ata_queued_cmd *qc, const u8 *scsicmd)
 {
         struct scsi_cmnd *cmd = qc->scsicmd;
         struct ata_device *dev = qc->dev;
@@ -1767,7 +1767,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
  */
 
 static struct ata_device *
-ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
+ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
 {
         struct ata_device *dev;
 
@@ -1924,7 +1924,7 @@ void ata_scsi_simulate(u16 *id,
                       void (*done)(struct scsi_cmnd *))
 {
         struct ata_scsi_args args;
-        u8 *scsicmd = cmd->cmnd;
+        const u8 *scsicmd = cmd->cmnd;
 
         args.id = id;
         args.cmd = cmd;
diff --git a/drivers/scsi/libata.h b/drivers/scsi/libata.h
index 67d752ca8ae2..3d60190584ba 100644
--- a/drivers/scsi/libata.h
+++ b/drivers/scsi/libata.h
@@ -48,7 +48,7 @@ extern int ata_qc_issue(struct ata_queued_cmd *qc);
 extern int ata_check_atapi_dma(struct ata_queued_cmd *qc);
 extern void ata_dev_select(struct ata_port *ap, unsigned int device,
                            unsigned int wait, unsigned int can_sleep);
-extern void ata_tf_to_host_nolock(struct ata_port *ap, struct ata_taskfile *tf);
+extern void ata_tf_to_host_nolock(struct ata_port *ap, const struct ata_taskfile *tf);
 extern void swap_buf_le16(u16 *buf, unsigned int buf_words);
 
 
diff --git a/drivers/scsi/lpfc/lpfc_mem.c b/drivers/scsi/lpfc/lpfc_mem.c
index 0aba13ceaacf..352df47bcaca 100644
--- a/drivers/scsi/lpfc/lpfc_mem.c
+++ b/drivers/scsi/lpfc/lpfc_mem.c
@@ -39,7 +39,7 @@
 #define LPFC_MEM_POOL_SIZE      64      /* max elem in non-DMA safety pool */
 
 static void *
-lpfc_pool_kmalloc(unsigned int gfp_flags, void *data)
+lpfc_pool_kmalloc(gfp_t gfp_flags, void *data)
 {
         return kmalloc((unsigned long)data, gfp_flags);
 }
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index 3f2f2464fa63..af1133104b3f 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -5146,7 +5146,8 @@ static long osst_compat_ioctl(struct file * file, unsigned int cmd_in, unsigned
 /* Try to allocate a new tape buffer skeleton. Caller must not hold os_scsi_tapes_lock */
 static struct osst_buffer * new_tape_buffer( int from_initialization, int need_dma, int max_sg )
 {
-        int i, priority;
+        int i;
+        gfp_t priority;
         struct osst_buffer *tb;
 
         if (from_initialization)
@@ -5178,7 +5179,8 @@ static struct osst_buffer * new_tape_buffer( int from_initialization, int need_d
 /* Try to allocate a temporary (while a user has the device open) enlarged tape buffer */
 static int enlarge_buffer(struct osst_buffer *STbuffer, int need_dma)
 {
-        int segs, nbr, max_segs, b_size, priority, order, got;
+        int segs, nbr, max_segs, b_size, order, got;
+        gfp_t priority;
 
         if (STbuffer->buffer_size >= OS_FRAME_SIZE)
                 return 1;
diff --git a/drivers/scsi/pdc_adma.c b/drivers/scsi/pdc_adma.c
index c6825da6ae20..85ec5b1d7aa9 100644
--- a/drivers/scsi/pdc_adma.c
+++ b/drivers/scsi/pdc_adma.c
@@ -158,7 +158,7 @@ static Scsi_Host_Template adma_ata_sht = {
         .bios_param             = ata_std_bios_param,
 };
 
-static struct ata_port_operations adma_ata_ops = {
+static const struct ata_port_operations adma_ata_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 1ed32e7b5472..e451941ad81d 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -52,7 +52,7 @@ extern int qla2x00_load_risc(struct scsi_qla_host *, uint32_t *);
 extern int qla24xx_load_risc_flash(scsi_qla_host_t *, uint32_t *);
 extern int qla24xx_load_risc_hotplug(scsi_qla_host_t *, uint32_t *);
 
-extern fc_port_t *qla2x00_alloc_fcport(scsi_qla_host_t *, int);
+extern fc_port_t *qla2x00_alloc_fcport(scsi_qla_host_t *, gfp_t);
 
 extern int qla2x00_loop_resync(scsi_qla_host_t *);
 
@@ -277,7 +277,7 @@ extern int qla2x00_fdmi_register(scsi_qla_host_t *);
 /*
  * Global Function Prototypes in qla_rscn.c source file.
  */
-extern fc_port_t *qla2x00_alloc_rscn_fcport(scsi_qla_host_t *, int);
+extern fc_port_t *qla2x00_alloc_rscn_fcport(scsi_qla_host_t *, gfp_t);
 extern int qla2x00_handle_port_rscn(scsi_qla_host_t *, uint32_t, fc_port_t *,
     int);
 extern void qla2x00_process_iodesc(scsi_qla_host_t *, struct mbx_entry *);
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 23d095d3817b..fbb6feee40cf 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1685,7 +1685,7 @@ qla2x00_nvram_config(scsi_qla_host_t *ha)
  * Returns a pointer to the allocated fcport, or NULL, if none available.
  */
 fc_port_t *
-qla2x00_alloc_fcport(scsi_qla_host_t *ha, int flags)
+qla2x00_alloc_fcport(scsi_qla_host_t *ha, gfp_t flags)
 {
         fc_port_t *fcport;
 
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 8982978c42fd..7aec93f9d423 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1325,6 +1325,8 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
         ha->brd_info = brd_info;
         sprintf(ha->host_str, "%s_%ld", ha->brd_info->drv_name, ha->host_no);
 
+        ha->dpc_pid = -1;
+
         /* Configure PCI I/O space */
         ret = qla2x00_iospace_config(ha);
         if (ret)
@@ -1448,7 +1450,6 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
          */
         spin_lock_init(&ha->mbx_reg_lock);
 
-        ha->dpc_pid = -1;
         init_completion(&ha->dpc_inited);
         init_completion(&ha->dpc_exited);
 
diff --git a/drivers/scsi/qla2xxx/qla_rscn.c b/drivers/scsi/qla2xxx/qla_rscn.c
index 1eba98828636..7534efcc8918 100644
--- a/drivers/scsi/qla2xxx/qla_rscn.c
+++ b/drivers/scsi/qla2xxx/qla_rscn.c
@@ -1066,7 +1066,7 @@ qla2x00_send_login_iocb_cb(scsi_qla_host_t *ha, struct io_descriptor *iodesc,
  * Returns a pointer to the allocated RSCN fcport, or NULL, if none available.
  */
 fc_port_t *
-qla2x00_alloc_rscn_fcport(scsi_qla_host_t *ha, int flags)
+qla2x00_alloc_rscn_fcport(scsi_qla_host_t *ha, gfp_t flags)
 {
         fc_port_t *fcport;
 
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index be7c378dcd36..1d6d0c9e76f6 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -35,7 +35,7 @@
 #include <asm/io.h>
 
 #define DRV_NAME        "sata_mv"
-#define DRV_VERSION     "0.24"
+#define DRV_VERSION     "0.25"
 
 enum {
         /* BAR's are enumerated in terms of pci_resource_start() terms */
@@ -290,7 +290,7 @@ static Scsi_Host_Template mv_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations mv_ops = {
+static const struct ata_port_operations mv_ops = {
         .port_disable           = ata_port_disable,
 
         .tf_load                = ata_tf_load,
diff --git a/drivers/scsi/sata_nv.c b/drivers/scsi/sata_nv.c
index 9fa2535dd937..1a56d6c79ddd 100644
--- a/drivers/scsi/sata_nv.c
+++ b/drivers/scsi/sata_nv.c
@@ -238,7 +238,7 @@ static Scsi_Host_Template nv_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations nv_ops = {
+static const struct ata_port_operations nv_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
@@ -331,7 +331,7 @@ static u32 nv_scr_read (struct ata_port *ap, unsigned int sc_reg)
                 return 0xffffffffU;
 
         if (host->host_flags & NV_HOST_FLAGS_SCR_MMIO)
-                return readl((void*)ap->ioaddr.scr_addr + (sc_reg * 4));
+                return readl((void __iomem *)ap->ioaddr.scr_addr + (sc_reg * 4));
         else
                 return inl(ap->ioaddr.scr_addr + (sc_reg * 4));
 }
@@ -345,7 +345,7 @@ static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
                 return;
 
         if (host->host_flags & NV_HOST_FLAGS_SCR_MMIO)
-                writel(val, (void*)ap->ioaddr.scr_addr + (sc_reg * 4));
+                writel(val, (void __iomem *)ap->ioaddr.scr_addr + (sc_reg * 4));
         else
                 outl(val, ap->ioaddr.scr_addr + (sc_reg * 4));
 }
diff --git a/drivers/scsi/sata_promise.c b/drivers/scsi/sata_promise.c
index def7e0d9dacb..eee93b0016df 100644
--- a/drivers/scsi/sata_promise.c
+++ b/drivers/scsi/sata_promise.c
@@ -87,8 +87,8 @@ static void pdc_port_stop(struct ata_port *ap);
 static void pdc_pata_phy_reset(struct ata_port *ap);
 static void pdc_sata_phy_reset(struct ata_port *ap);
 static void pdc_qc_prep(struct ata_queued_cmd *qc);
-static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf);
-static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
+static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
+static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
 static void pdc_irq_clear(struct ata_port *ap);
 static int pdc_qc_issue_prot(struct ata_queued_cmd *qc);
 
@@ -113,7 +113,7 @@ static Scsi_Host_Template pdc_ata_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations pdc_sata_ops = {
+static const struct ata_port_operations pdc_sata_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
@@ -136,7 +136,7 @@ static struct ata_port_operations pdc_sata_ops = {
         .host_stop              = ata_pci_host_stop,
 };
 
-static struct ata_port_operations pdc_pata_ops = {
+static const struct ata_port_operations pdc_pata_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
@@ -324,7 +324,7 @@ static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
 {
         if (sc_reg > SCR_CONTROL)
                 return 0xffffffffU;
-        return readl((void *) ap->ioaddr.scr_addr + (sc_reg * 4));
+        return readl((void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
 }
 
 
@@ -333,7 +333,7 @@ static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
 {
         if (sc_reg > SCR_CONTROL)
                 return;
-        writel(val, (void *) ap->ioaddr.scr_addr + (sc_reg * 4));
+        writel(val, (void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
 }
 
 static void pdc_qc_prep(struct ata_queued_cmd *qc)
@@ -523,8 +523,8 @@ static inline void pdc_packet_start(struct ata_queued_cmd *qc)
 
         pp->pkt[2] = seq;
         wmb();                  /* flush PRD, pkt writes */
-        writel(pp->pkt_dma, (void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
-        readl((void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT); /* flush */
+        writel(pp->pkt_dma, (void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
+        readl((void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT); /* flush */
 }
 
 static int pdc_qc_issue_prot(struct ata_queued_cmd *qc)
@@ -546,7 +546,7 @@ static int pdc_qc_issue_prot(struct ata_queued_cmd *qc)
         return ata_qc_issue_prot(qc);
 }
 
-static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         WARN_ON (tf->protocol == ATA_PROT_DMA ||
                  tf->protocol == ATA_PROT_NODATA);
@@ -554,7 +554,7 @@ static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
 }
 
 
-static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         WARN_ON (tf->protocol == ATA_PROT_DMA ||
                  tf->protocol == ATA_PROT_NODATA);
diff --git a/drivers/scsi/sata_qstor.c b/drivers/scsi/sata_qstor.c
index 69a9b1cf6f9c..de3f266d67b3 100644
--- a/drivers/scsi/sata_qstor.c
+++ b/drivers/scsi/sata_qstor.c
@@ -51,8 +51,6 @@ enum {
         QS_PRD_BYTES            = QS_MAX_PRD * 16,
         QS_PKT_BYTES            = QS_CPB_BYTES + QS_PRD_BYTES,
 
-        QS_DMA_BOUNDARY         = ~0UL,
-
         /* global register offsets */
         QS_HCF_CNFG3            = 0x0003, /* host configuration offset */
         QS_HID_HPHY             = 0x0004, /* host physical interface info */
@@ -101,6 +99,10 @@ enum {
         board_2068_idx          = 0,    /* QStor 4-port SATA/RAID */
 };
 
+enum {
+        QS_DMA_BOUNDARY         = ~0UL
+};
+
 typedef enum { qs_state_idle, qs_state_pkt, qs_state_mmio } qs_state_t;
 
 struct qs_port_priv {
@@ -145,7 +147,7 @@ static Scsi_Host_Template qs_ata_sht = {
         .bios_param             = ata_std_bios_param,
 };
 
-static struct ata_port_operations qs_ata_ops = {
+static const struct ata_port_operations qs_ata_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index ba98a175ee3a..3a056173fb95 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -150,7 +150,7 @@ static Scsi_Host_Template sil_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations sil_ops = {
+static const struct ata_port_operations sil_ops = {
         .port_disable           = ata_port_disable,
         .dev_config             = sil_dev_config,
         .tf_load                = ata_tf_load,
@@ -289,7 +289,7 @@ static inline unsigned long sil_scr_addr(struct ata_port *ap, unsigned int sc_re
 
 static u32 sil_scr_read (struct ata_port *ap, unsigned int sc_reg)
 {
-        void *mmio = (void *) sil_scr_addr(ap, sc_reg);
+        void __iomem *mmio = (void __iomem *) sil_scr_addr(ap, sc_reg);
         if (mmio)
                 return readl(mmio);
         return 0xffffffffU;
@@ -297,7 +297,7 @@ static u32 sil_scr_read (struct ata_port *ap, unsigned int sc_reg)
 
 static void sil_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
-        void *mmio = (void *) sil_scr_addr(ap, sc_reg);
+        void *mmio = (void __iomem *) sil_scr_addr(ap, sc_reg);
         if (mmio)
                 writel(val, mmio);
 }
diff --git a/drivers/scsi/sata_sil24.c b/drivers/scsi/sata_sil24.c
index e16d1815cda0..e0d27a0fbad0 100644
--- a/drivers/scsi/sata_sil24.c
+++ b/drivers/scsi/sata_sil24.c
@@ -275,7 +275,7 @@ static Scsi_Host_Template sil24_sht = {
         .ordered_flush          = 1, /* NCQ not supported yet */
 };
 
-static struct ata_port_operations sil24_ops = {
+static const struct ata_port_operations sil24_ops = {
         .port_disable           = ata_port_disable,
 
         .check_status           = sil24_check_status,
diff --git a/drivers/scsi/sata_sis.c b/drivers/scsi/sata_sis.c
index 0761a3234fcf..057f7b98b6c4 100644
--- a/drivers/scsi/sata_sis.c
+++ b/drivers/scsi/sata_sis.c
@@ -102,7 +102,7 @@ static Scsi_Host_Template sis_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations sis_ops = {
+static const struct ata_port_operations sis_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = ata_tf_load,
         .tf_read                = ata_tf_read,
diff --git a/drivers/scsi/sata_svw.c b/drivers/scsi/sata_svw.c
index d89d968bedac..e0f9570bc6dd 100644
--- a/drivers/scsi/sata_svw.c
+++ b/drivers/scsi/sata_svw.c
@@ -102,7 +102,7 @@ static void k2_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
 }
 
 
-static void k2_sata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
+static void k2_sata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
@@ -297,7 +297,7 @@ static Scsi_Host_Template k2_sata_sht = {
 };
 
 
-static struct ata_port_operations k2_sata_ops = {
+static const struct ata_port_operations k2_sata_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = k2_sata_tf_load,
         .tf_read                = k2_sata_tf_read,
diff --git a/drivers/scsi/sata_sx4.c b/drivers/scsi/sata_sx4.c
index 79fdbbab513e..8710d0f14f93 100644
--- a/drivers/scsi/sata_sx4.c
+++ b/drivers/scsi/sata_sx4.c
@@ -137,7 +137,7 @@ struct pdc_port_priv {
 };
 
 struct pdc_host_priv {
-        void                    *dimm_mmio;
+        void                    __iomem *dimm_mmio;
 
         unsigned int            doing_hdma;
         unsigned int            hdma_prod;
@@ -157,8 +157,8 @@ static void pdc_20621_phy_reset (struct ata_port *ap);
 static int pdc_port_start(struct ata_port *ap);
 static void pdc_port_stop(struct ata_port *ap);
 static void pdc20621_qc_prep(struct ata_queued_cmd *qc);
-static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf);
-static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
+static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
+static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
 static void pdc20621_host_stop(struct ata_host_set *host_set);
 static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe);
 static int pdc20621_detect_dimm(struct ata_probe_ent *pe);
@@ -196,7 +196,7 @@ static Scsi_Host_Template pdc_sata_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations pdc_20621_ops = {
+static const struct ata_port_operations pdc_20621_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = pdc_tf_load_mmio,
         .tf_read                = ata_tf_read,
@@ -247,7 +247,7 @@ static void pdc20621_host_stop(struct ata_host_set *host_set)
 {
         struct pci_dev *pdev = to_pci_dev(host_set->dev);
         struct pdc_host_priv *hpriv = host_set->private_data;
-        void *dimm_mmio = hpriv->dimm_mmio;
+        void __iomem *dimm_mmio = hpriv->dimm_mmio;
 
         pci_iounmap(pdev, dimm_mmio);
         kfree(hpriv);
@@ -668,8 +668,8 @@ static void pdc20621_packet_start(struct ata_queued_cmd *qc)
                 readl(mmio + PDC_20621_SEQCTL + (seq * 4));     /* flush */
 
                 writel(port_ofs + PDC_DIMM_ATA_PKT,
-                       (void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
-                readl((void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
+                       (void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
+                readl((void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
                 VPRINTK("submitted ofs 0x%x (%u), seq %u\n",
                         port_ofs + PDC_DIMM_ATA_PKT,
                         port_ofs + PDC_DIMM_ATA_PKT,
@@ -746,8 +746,8 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap,
                         writel(0x00000001, mmio + PDC_20621_SEQCTL + (seq * 4));
                         readl(mmio + PDC_20621_SEQCTL + (seq * 4));
                         writel(port_ofs + PDC_DIMM_ATA_PKT,
-                               (void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
-                        readl((void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
+                               (void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
+                        readl((void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
                 }
 
                 /* step two - execute ATA command */
@@ -898,7 +898,7 @@ out:
         DPRINTK("EXIT\n");
 }
 
-static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         WARN_ON (tf->protocol == ATA_PROT_DMA ||
                  tf->protocol == ATA_PROT_NODATA);
@@ -906,7 +906,7 @@ static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
 }
 
 
-static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         WARN_ON (tf->protocol == ATA_PROT_DMA ||
                  tf->protocol == ATA_PROT_NODATA);
@@ -1013,7 +1013,7 @@ static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource,
         idx++;
         dist = ((long)(s32)(window_size - (offset + size))) >= 0 ? size :
                 (long) (window_size - offset);
-        memcpy_toio((char *) (dimm_mmio + offset / 4), (char *) psource, dist);
+        memcpy_toio(dimm_mmio + offset / 4, psource, dist);
         writel(0x01, mmio + PDC_GENERAL_CTLR);
         readl(mmio + PDC_GENERAL_CTLR);
 
@@ -1022,8 +1022,7 @@ static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource,
         for (; (long) size >= (long) window_size ;) {
                 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
                 readl(mmio + PDC_DIMM_WINDOW_CTLR);
-                memcpy_toio((char *) (dimm_mmio), (char *) psource,
-                            window_size / 4);
+                memcpy_toio(dimm_mmio, psource, window_size / 4);
                 writel(0x01, mmio + PDC_GENERAL_CTLR);
                 readl(mmio + PDC_GENERAL_CTLR);
                 psource += window_size;
@@ -1034,7 +1033,7 @@ static void pdc20621_put_to_dimm(struct ata_probe_ent *pe, void *psource,
         if (size) {
                 writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
                 readl(mmio + PDC_DIMM_WINDOW_CTLR);
-                memcpy_toio((char *) (dimm_mmio), (char *) psource, size / 4);
+                memcpy_toio(dimm_mmio, psource, size / 4);
                 writel(0x01, mmio + PDC_GENERAL_CTLR);
                 readl(mmio + PDC_GENERAL_CTLR);
         }
diff --git a/drivers/scsi/sata_uli.c b/drivers/scsi/sata_uli.c
index 9c06f2abe7f7..d68dc7d3422c 100644
--- a/drivers/scsi/sata_uli.c
+++ b/drivers/scsi/sata_uli.c
@@ -90,7 +90,7 @@ static Scsi_Host_Template uli_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations uli_ops = {
+static const struct ata_port_operations uli_ops = {
         .port_disable           = ata_port_disable,
 
         .tf_load                = ata_tf_load,
diff --git a/drivers/scsi/sata_via.c b/drivers/scsi/sata_via.c
index 565872479b9a..80e291a909a9 100644
--- a/drivers/scsi/sata_via.c
+++ b/drivers/scsi/sata_via.c
@@ -109,7 +109,7 @@ static Scsi_Host_Template svia_sht = {
         .ordered_flush          = 1,
 };
 
-static struct ata_port_operations svia_sata_ops = {
+static const struct ata_port_operations svia_sata_ops = {
         .port_disable           = ata_port_disable,
 
         .tf_load                = ata_tf_load,
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index cf94e0158a8d..5af05fdf8544 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -86,7 +86,7 @@ static u32 vsc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
 {
         if (sc_reg > SCR_CONTROL)
                 return 0xffffffffU;
-        return readl((void *) ap->ioaddr.scr_addr + (sc_reg * 4));
+        return readl((void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
 }
 
 
@@ -95,16 +95,16 @@ static void vsc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
 {
         if (sc_reg > SCR_CONTROL)
                 return;
-        writel(val, (void *) ap->ioaddr.scr_addr + (sc_reg * 4));
+        writel(val, (void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
 }
 
 
 static void vsc_intr_mask_update(struct ata_port *ap, u8 ctl)
 {
-        unsigned long mask_addr;
+        void __iomem *mask_addr;
         u8 mask;
 
-        mask_addr = (unsigned long) ap->host_set->mmio_base +
+        mask_addr = ap->host_set->mmio_base +
                 VSC_SATA_INT_MASK_OFFSET + ap->port_no;
         mask = readb(mask_addr);
         if (ctl & ATA_NIEN)
@@ -115,7 +115,7 @@ static void vsc_intr_mask_update(struct ata_port *ap, u8 ctl)
 }
 
 
-static void vsc_sata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
+static void vsc_sata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
 {
         struct ata_ioports *ioaddr = &ap->ioaddr;
         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
@@ -231,7 +231,7 @@ static Scsi_Host_Template vsc_sata_sht = {
 };
 
 
-static struct ata_port_operations vsc_sata_ops = {
+static const struct ata_port_operations vsc_sata_ops = {
         .port_disable           = ata_port_disable,
         .tf_load                = vsc_sata_tf_load,
         .tf_read                = vsc_sata_tf_read,
@@ -283,7 +283,7 @@ static int __devinit vsc_sata_init_one (struct pci_dev *pdev, const struct pci_d
         struct ata_probe_ent *probe_ent = NULL;
         unsigned long base;
         int pci_dev_busy = 0;
-        void *mmio_base;
+        void __iomem *mmio_base;
         int rc;
 
         if (!printed_version++)
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 1f0ebabf6d47..a5711d545d71 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -130,7 +130,7 @@ EXPORT_SYMBOL(scsi_device_types);
  * Returns:     Pointer to request block.
  */
 struct scsi_request *scsi_allocate_request(struct scsi_device *sdev,
-                                           int gfp_mask)
+                                           gfp_t gfp_mask)
 {
         const int offset = ALIGN(sizeof(struct scsi_request), 4);
         const int size = offset + sizeof(struct request);
@@ -196,7 +196,7 @@ struct scsi_host_cmd_pool {
         unsigned int    users;
         char            *name;
         unsigned int    slab_flags;
-        unsigned int    gfp_mask;
+        gfp_t           gfp_mask;
 };
 
 static struct scsi_host_cmd_pool scsi_cmd_pool = {
@@ -213,7 +213,7 @@ static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
 static DECLARE_MUTEX(host_cmd_pool_mutex);
 
 static struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost,
-                                            int gfp_mask)
+                                            gfp_t gfp_mask)
 {
         struct scsi_cmnd *cmd;
 
@@ -245,7 +245,7 @@ static struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost,
  *
  * Returns:     The allocated scsi command structure.
  */
-struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, int gfp_mask)
+struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
 {
         struct scsi_cmnd *cmd;
 
diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c
index 64fc9e21f35b..e69477d1889b 100644
--- a/drivers/scsi/scsi_devinfo.c
+++ b/drivers/scsi/scsi_devinfo.c
@@ -185,6 +185,7 @@ static struct {
         {"PIONEER", "CD-ROM DRM-600", NULL, BLIST_FORCELUN | BLIST_SINGLELUN},
         {"PIONEER", "CD-ROM DRM-602X", NULL, BLIST_FORCELUN | BLIST_SINGLELUN},
         {"PIONEER", "CD-ROM DRM-604X", NULL, BLIST_FORCELUN | BLIST_SINGLELUN},
+        {"PIONEER", "CD-ROM DRM-624X", NULL, BLIST_FORCELUN | BLIST_SINGLELUN},
         {"REGAL", "CDC-4X", NULL, BLIST_MAX5LUN | BLIST_SINGLELUN},
         {"SanDisk", "ImageMate CF-SD1", NULL, BLIST_FORCELUN},
         {"SEAGATE", "ST34555N", "0930", BLIST_NOTQ},    /* Chokes on tagged INQUIRY */
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index ad5342165079..52b348c36d56 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1645,6 +1645,8 @@ int scsi_error_handler(void *data)
                 set_current_state(TASK_INTERRUPTIBLE);
         }
 
+        __set_current_state(TASK_RUNNING);
+
         SCSI_LOG_ERROR_RECOVERY(1, printk("Error handler scsi_eh_%d"
                                           " exiting\n",shost->host_no));
 
diff --git a/drivers/scsi/scsi_ioctl.c b/drivers/scsi/scsi_ioctl.c
index de7f98cc38fe..6a3f6aae8a97 100644
--- a/drivers/scsi/scsi_ioctl.c
+++ b/drivers/scsi/scsi_ioctl.c
@@ -205,7 +205,8 @@ int scsi_ioctl_send_command(struct scsi_device *sdev,
         unsigned int inlen, outlen, cmdlen;
         unsigned int needed, buf_needed;
         int timeout, retries, result;
-        int data_direction, gfp_mask = GFP_KERNEL;
+        int data_direction;
+        gfp_t gfp_mask = GFP_KERNEL;
 
         if (!sic)
                 return -EINVAL;
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index dc9c772bc874..3ff538809786 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -97,7 +97,6 @@ int scsi_insert_special_req(struct scsi_request *sreq, int at_head)
 }
 
 static void scsi_run_queue(struct request_queue *q);
-static void scsi_release_buffers(struct scsi_cmnd *cmd);
 
 /*
  * Function:    scsi_unprep_request()
@@ -678,7 +677,7 @@ static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int uptodate,
         return NULL;
 }
 
-static struct scatterlist *scsi_alloc_sgtable(struct scsi_cmnd *cmd, int gfp_mask)
+static struct scatterlist *scsi_alloc_sgtable(struct scsi_cmnd *cmd, gfp_t gfp_mask)
 {
         struct scsi_host_sg_pool *sgp;
         struct scatterlist *sgl;
@@ -1040,8 +1039,10 @@ static int scsi_init_io(struct scsi_cmnd *cmd)
          * if sg table allocation fails, requeue request later.
          */
         sgpnt = scsi_alloc_sgtable(cmd, GFP_ATOMIC);
-        if (unlikely(!sgpnt))
+        if (unlikely(!sgpnt)) {
+                scsi_unprep_request(req);
                 return BLKPREP_DEFER;
+        }
 
         cmd->request_buffer = (char *) sgpnt;
         cmd->request_bufflen = req->nr_sectors << 9;
@@ -1245,8 +1246,8 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
                  */
                 ret = scsi_init_io(cmd);
                 switch(ret) {
+                        /* For BLKPREP_KILL/DEFER the cmd was released */
                 case BLKPREP_KILL:
-                        /* BLKPREP_KILL return also releases the command */
                         goto kill;
                 case BLKPREP_DEFER:
                         goto defer;
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 2cab556b6e82..771e97ef136e 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -819,12 +819,15 @@ show_fc_private_host_tgtid_bind_type(struct class_device *cdev, char *buf)
         return snprintf(buf, FC_BINDTYPE_MAX_NAMELEN, "%s\n", name);
 }
 
+#define get_list_head_entry(pos, head, member)          \
+        pos = list_entry((head)->next, typeof(*pos), member)
+
 static ssize_t
 store_fc_private_host_tgtid_bind_type(struct class_device *cdev,
         const char *buf, size_t count)
 {
         struct Scsi_Host *shost = transport_class_to_shost(cdev);
-        struct fc_rport *rport, *next_rport;
+        struct fc_rport *rport;
         enum fc_tgtid_binding_type val;
         unsigned long flags;
 
@@ -834,9 +837,13 @@ store_fc_private_host_tgtid_bind_type(struct class_device *cdev,
         /* if changing bind type, purge all unused consistent bindings */
         if (val != fc_host_tgtid_bind_type(shost)) {
                 spin_lock_irqsave(shost->host_lock, flags);
-                list_for_each_entry_safe(rport, next_rport,
-                                &fc_host_rport_bindings(shost), peers)
+                while (!list_empty(&fc_host_rport_bindings(shost))) {
+                        get_list_head_entry(rport,
+                                &fc_host_rport_bindings(shost), peers);
+                        spin_unlock_irqrestore(shost->host_lock, flags);
                         fc_rport_terminate(rport);
+                        spin_lock_irqsave(shost->host_lock, flags);
+                }
                 spin_unlock_irqrestore(shost->host_lock, flags);
         }
 
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index ad94367df430..fd56b7ec88b6 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -2644,7 +2644,7 @@ static char *
 sg_page_malloc(int rqSz, int lowDma, int *retSzp)
 {
         char *resp = NULL;
-        int page_mask;
+        gfp_t page_mask;
         int order, a_size;
         int resSz = rqSz;
 
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index d001c046551b..927d700f0073 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -3577,7 +3577,8 @@ static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long a
 static struct st_buffer *
  new_tape_buffer(int from_initialization, int need_dma, int max_sg)
 {
-        int i, priority, got = 0, segs = 0;
+        int i, got = 0, segs = 0;
+        gfp_t priority;
         struct st_buffer *tb;
 
         if (from_initialization)
@@ -3610,7 +3611,8 @@ static struct st_buffer *
 /* Try to allocate enough space in the tape buffer */
 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
 {
-        int segs, nbr, max_segs, b_size, priority, order, got;
+        int segs, nbr, max_segs, b_size, order, got;
+        gfp_t priority;
 
         if (new_size <= STbuffer->buffer_size)
                 return 1;