69 files changed, 620 insertions, 459 deletions

diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index d592dbb1d12a..b7f2963693a7 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -272,6 +272,8 @@ static atomic_t c3_cpu_count;
 /* Common C-state entry for C2, C3, .. */
 static void acpi_cstate_enter(struct acpi_processor_cx *cstate)
 {
+        /* Don't trace irqs off for idle */
+        stop_critical_timings();
         if (cstate->entry_method == ACPI_CSTATE_FFH) {
                 /* Call into architectural FFH based C-state */
                 acpi_processor_ffh_cstate_enter(cstate);
@@ -284,6 +286,7 @@ static void acpi_cstate_enter(struct acpi_processor_cx *cstate)
                    gets asserted in time to freeze execution properly. */
                 unused = inl(acpi_gbl_FADT.xpm_timer_block.address);
         }
+        start_critical_timings();
 }
 #endif /* !CONFIG_CPU_IDLE */
 
@@ -1418,6 +1421,8 @@ static inline void acpi_idle_update_bm_rld(struct acpi_processor *pr,
  */
 static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
 {
+        /* Don't trace irqs off for idle */
+        stop_critical_timings();
         if (cx->entry_method == ACPI_CSTATE_FFH) {
                 /* Call into architectural FFH based C-state */
                 acpi_processor_ffh_cstate_enter(cx);
@@ -1432,6 +1437,7 @@ static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
                    gets asserted in time to freeze execution properly. */
                 unused = inl(acpi_gbl_FADT.xpm_timer_block.address);
         }
+        start_critical_timings();
 }
 
 /**
diff --git a/drivers/base/core.c b/drivers/base/core.c
index 7d5c63c81a59..068aa1c9538c 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -116,12 +116,10 @@ static void device_release(struct kobject *kobj)
                 dev->type->release(dev);
         else if (dev->class && dev->class->dev_release)
                 dev->class->dev_release(dev);
-        else {
-                printk(KERN_ERR "Device '%s' does not have a release() "
+        else
+                WARN(1, KERN_ERR "Device '%s' does not have a release() "
                         "function, it is broken and must be fixed.\n",
                         dev->bus_id);
-                WARN_ON(1);
-        }
 }
 
 static struct kobj_type device_ktype = {
diff --git a/drivers/base/isa.c b/drivers/base/isa.c
index d2222397a401..efd577574948 100644
--- a/drivers/base/isa.c
+++ b/drivers/base/isa.c
@@ -7,6 +7,7 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/dma-mapping.h>
 #include <linux/isa.h>
 
 static struct device isa_bus = {
@@ -141,6 +142,9 @@ int isa_register_driver(struct isa_driver *isa_driver, unsigned int ndev)
                 isa_dev->dev.release            = isa_dev_release;
                 isa_dev->id                     = id;
 
+                isa_dev->dev.coherent_dma_mask = DMA_24BIT_MASK;
+                isa_dev->dev.dma_mask = &isa_dev->dev.coherent_dma_mask;
+
                 error = device_register(&isa_dev->dev);
                 if (error) {
                         put_device(&isa_dev->dev);
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 855ed1a9f97b..3ad49a00029f 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -204,9 +204,8 @@ memory_block_action(struct memory_block *mem, unsigned long action)
                         }
                         break;
                 default:
-                        printk(KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
+                        WARN(1, KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
                                         __func__, mem, action, action);
-                        WARN_ON(1);
                         ret = -EINVAL;
         }
 
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 40fc14f03540..75dd6e22faff 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -168,19 +168,16 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
         int err = 0;
 
         if (!cls) {
-                printk(KERN_WARNING "sysdev: invalid class passed to "
+                WARN(1, KERN_WARNING "sysdev: invalid class passed to "
                         "sysdev_driver_register!\n");
-                WARN_ON(1);
                 return -EINVAL;
         }
 
         /* Check whether this driver has already been added to a class. */
-        if (drv->entry.next && !list_empty(&drv->entry)) {
-                printk(KERN_WARNING "sysdev: class %s: driver (%p) has already"
+        if (drv->entry.next && !list_empty(&drv->entry))
+                WARN(1, KERN_WARNING "sysdev: class %s: driver (%p) has already"
                         " been registered to a class, something is wrong, but "
                         "will forge on!\n", cls->name, drv);
-                WARN_ON(1);
-        }
 
         mutex_lock(&sysdev_drivers_lock);
         if (cls && kset_get(&cls->kset)) {
@@ -194,8 +191,7 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
                 }
         } else {
                 err = -EINVAL;
-                printk(KERN_ERR "%s: invalid device class\n", __func__);
-                WARN_ON(1);
+                WARN(1, KERN_ERR "%s: invalid device class\n", __func__);
         }
         mutex_unlock(&sysdev_drivers_lock);
         return err;
diff --git a/drivers/char/dsp56k.c b/drivers/char/dsp56k.c
index 19b88504e960..ca7c72a486b2 100644
--- a/drivers/char/dsp56k.c
+++ b/drivers/char/dsp56k.c
@@ -304,9 +304,9 @@ static ssize_t dsp56k_write(struct file *file, const char __user *buf, size_t co
 }
 
 static long dsp56k_ioctl(struct file *file, unsigned int cmd,
-                                                        unsigned long arg)
+                         unsigned long arg)
 {
-        int dev = iminor(inode) & 0x0f;
+        int dev = iminor(file->f_path.dentry->d_inode) & 0x0f;
         void __user *argp = (void __user *)arg;
 
         switch(dev)
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index dbefbb30ed44..d9799e2bcfbf 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -144,6 +144,7 @@ static ssize_t rtc_read(struct file *file, char __user *buf,
                         size_t count, loff_t *ppos);
 
 static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
+static void rtc_get_rtc_time(struct rtc_time *rtc_tm);
 
 #ifdef RTC_IRQ
 static unsigned int rtc_poll(struct file *file, poll_table *wait);
@@ -235,7 +236,7 @@ static inline unsigned char rtc_is_updating(void)
  *      (See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.)
  */
 
-irqreturn_t rtc_interrupt(int irq, void *dev_id)
+static irqreturn_t rtc_interrupt(int irq, void *dev_id)
 {
         /*
          *      Can be an alarm interrupt, update complete interrupt,
@@ -1303,7 +1304,7 @@ static int rtc_proc_open(struct inode *inode, struct file *file)
 }
 #endif
 
-void rtc_get_rtc_time(struct rtc_time *rtc_tm)
+static void rtc_get_rtc_time(struct rtc_time *rtc_tm)
 {
         unsigned long uip_watchdog = jiffies, flags;
         unsigned char ctrl;
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index e1fc193d9396..ae766d868454 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -580,91 +580,133 @@ void tpm_continue_selftest(struct tpm_chip *chip)
 }
 EXPORT_SYMBOL_GPL(tpm_continue_selftest);
 
+#define  TPM_INTERNAL_RESULT_SIZE 200
+
 ssize_t tpm_show_enabled(struct device * dev, struct device_attribute * attr,
                         char *buf)
 {
-        u8 data[max_t(int, ARRAY_SIZE(tpm_cap), 35)];
+        u8 *data;
         ssize_t rc;
 
         struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
+        data = kzalloc(TPM_INTERNAL_RESULT_SIZE, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
         memcpy(data, tpm_cap, sizeof(tpm_cap));
         data[TPM_CAP_IDX] = TPM_CAP_FLAG;
         data[TPM_CAP_SUBCAP_IDX] = TPM_CAP_FLAG_PERM;
 
-        rc = transmit_cmd(chip, data, sizeof(data),
-                        "attemtping to determine the permanent state");
-        if (rc)
+        rc = transmit_cmd(chip, data, TPM_INTERNAL_RESULT_SIZE,
+                        "attemtping to determine the permanent enabled state");
+        if (rc) {
+                kfree(data);
                 return 0;
-        return sprintf(buf, "%d\n", !data[TPM_GET_CAP_PERM_DISABLE_IDX]);
+        }
+
+        rc = sprintf(buf, "%d\n", !data[TPM_GET_CAP_PERM_DISABLE_IDX]);
+
+        kfree(data);
+        return rc;
 }
 EXPORT_SYMBOL_GPL(tpm_show_enabled);
 
 ssize_t tpm_show_active(struct device * dev, struct device_attribute * attr,
                         char *buf)
 {
-        u8 data[max_t(int, ARRAY_SIZE(tpm_cap), 35)];
+        u8 *data;
         ssize_t rc;
 
         struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
+        data = kzalloc(TPM_INTERNAL_RESULT_SIZE, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
         memcpy(data, tpm_cap, sizeof(tpm_cap));
         data[TPM_CAP_IDX] = TPM_CAP_FLAG;
         data[TPM_CAP_SUBCAP_IDX] = TPM_CAP_FLAG_PERM;
 
-        rc = transmit_cmd(chip, data, sizeof(data),
-                        "attemtping to determine the permanent state");
-        if (rc)
+        rc = transmit_cmd(chip, data, TPM_INTERNAL_RESULT_SIZE,
+                        "attemtping to determine the permanent active state");
+        if (rc) {
+                kfree(data);
                 return 0;
-        return sprintf(buf, "%d\n", !data[TPM_GET_CAP_PERM_INACTIVE_IDX]);
+        }
+
+        rc = sprintf(buf, "%d\n", !data[TPM_GET_CAP_PERM_INACTIVE_IDX]);
+
+        kfree(data);
+        return rc;
 }
 EXPORT_SYMBOL_GPL(tpm_show_active);
 
 ssize_t tpm_show_owned(struct device * dev, struct device_attribute * attr,
                         char *buf)
 {
-        u8 data[sizeof(tpm_cap)];
+        u8 *data;
         ssize_t rc;
 
         struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
+        data = kzalloc(TPM_INTERNAL_RESULT_SIZE, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
         memcpy(data, tpm_cap, sizeof(tpm_cap));
         data[TPM_CAP_IDX] = TPM_CAP_PROP;
         data[TPM_CAP_SUBCAP_IDX] = TPM_CAP_PROP_OWNER;
 
-        rc = transmit_cmd(chip, data, sizeof(data),
+        rc = transmit_cmd(chip, data, TPM_INTERNAL_RESULT_SIZE,
                         "attempting to determine the owner state");
-        if (rc)
+        if (rc) {
+                kfree(data);
                 return 0;
-        return sprintf(buf, "%d\n", data[TPM_GET_CAP_RET_BOOL_1_IDX]);
+        }
+
+        rc = sprintf(buf, "%d\n", data[TPM_GET_CAP_RET_BOOL_1_IDX]);
+
+        kfree(data);
+        return rc;
 }
 EXPORT_SYMBOL_GPL(tpm_show_owned);
 
 ssize_t tpm_show_temp_deactivated(struct device * dev,
                                 struct device_attribute * attr, char *buf)
 {
-        u8 data[sizeof(tpm_cap)];
+        u8 *data;
         ssize_t rc;
 
         struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
+        data = kzalloc(TPM_INTERNAL_RESULT_SIZE, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
         memcpy(data, tpm_cap, sizeof(tpm_cap));
         data[TPM_CAP_IDX] = TPM_CAP_FLAG;
         data[TPM_CAP_SUBCAP_IDX] = TPM_CAP_FLAG_VOL;
 
-        rc = transmit_cmd(chip, data, sizeof(data),
+        rc = transmit_cmd(chip, data, TPM_INTERNAL_RESULT_SIZE,
                         "attempting to determine the temporary state");
-        if (rc)
+        if (rc) {
+                kfree(data);
                 return 0;
-        return sprintf(buf, "%d\n", data[TPM_GET_CAP_TEMP_INACTIVE_IDX]);
+        }
+
+        rc = sprintf(buf, "%d\n", data[TPM_GET_CAP_TEMP_INACTIVE_IDX]);
+
+        kfree(data);
+        return rc;
 }
 EXPORT_SYMBOL_GPL(tpm_show_temp_deactivated);
 
@@ -678,7 +720,7 @@ static const u8 pcrread[] = {
 ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
                       char *buf)
 {
-        u8 data[max_t(int, max(ARRAY_SIZE(tpm_cap), ARRAY_SIZE(pcrread)), 30)];
+        u8 *data;
         ssize_t rc;
         int i, j, num_pcrs;
         __be32 index;
@@ -688,21 +730,27 @@ ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
         if (chip == NULL)
                 return -ENODEV;
 
+        data = kzalloc(TPM_INTERNAL_RESULT_SIZE, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
         memcpy(data, tpm_cap, sizeof(tpm_cap));
         data[TPM_CAP_IDX] = TPM_CAP_PROP;
         data[TPM_CAP_SUBCAP_IDX] = TPM_CAP_PROP_PCR;
 
-        rc = transmit_cmd(chip, data, sizeof(data),
+        rc = transmit_cmd(chip, data, TPM_INTERNAL_RESULT_SIZE,
                         "attempting to determine the number of PCRS");
-        if (rc)
+        if (rc) {
+                kfree(data);
                 return 0;
+        }
 
         num_pcrs = be32_to_cpu(*((__be32 *) (data + 14)));
         for (i = 0; i < num_pcrs; i++) {
                 memcpy(data, pcrread, sizeof(pcrread));
                 index = cpu_to_be32(i);
                 memcpy(data + 10, &index, 4);
-                rc = transmit_cmd(chip, data, sizeof(data),
+                rc = transmit_cmd(chip, data, TPM_INTERNAL_RESULT_SIZE,
                                 "attempting to read a PCR");
                 if (rc)
                         goto out;
@@ -712,6 +760,7 @@ ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
                 str += sprintf(str, "\n");
         }
 out:
+        kfree(data);
         return str - buf;
 }
 EXPORT_SYMBOL_GPL(tpm_show_pcrs);
@@ -795,7 +844,7 @@ static const u8 cap_version[] = {
 ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr,
                       char *buf)
 {
-        u8 data[max_t(int, max(ARRAY_SIZE(tpm_cap), ARRAY_SIZE(cap_version)), 30)];
+        u8 *data;
         ssize_t rc;
         char *str = buf;
 
@@ -803,21 +852,27 @@ ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr,
         if (chip == NULL)
                 return -ENODEV;
 
+        data = kzalloc(TPM_INTERNAL_RESULT_SIZE, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
         memcpy(data, tpm_cap, sizeof(tpm_cap));
         data[TPM_CAP_IDX] = TPM_CAP_PROP;
         data[TPM_CAP_SUBCAP_IDX] = TPM_CAP_PROP_MANUFACTURER;
 
-        rc = transmit_cmd(chip, data, sizeof(data),
+        rc = transmit_cmd(chip, data, TPM_INTERNAL_RESULT_SIZE,
                         "attempting to determine the manufacturer");
-        if (rc)
+        if (rc) {
+                kfree(data);
                 return 0;
+        }
 
         str += sprintf(str, "Manufacturer: 0x%x\n",
                        be32_to_cpu(*((__be32 *) (data + TPM_GET_CAP_RET_UINT32_1_IDX))));
 
         memcpy(data, cap_version, sizeof(cap_version));
         data[CAP_VERSION_IDX] = CAP_VERSION_1_1;
-        rc = transmit_cmd(chip, data, sizeof(data),
+        rc = transmit_cmd(chip, data, TPM_INTERNAL_RESULT_SIZE,
                         "attempting to determine the 1.1 version");
         if (rc)
                 goto out;
@@ -828,6 +883,7 @@ ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr,
                        (int) data[17]);
 
 out:
+        kfree(data);
         return str - buf;
 }
 EXPORT_SYMBOL_GPL(tpm_show_caps);
@@ -835,7 +891,7 @@ EXPORT_SYMBOL_GPL(tpm_show_caps);
 ssize_t tpm_show_caps_1_2(struct device * dev,
                           struct device_attribute * attr, char *buf)
 {
-        u8 data[max_t(int, max(ARRAY_SIZE(tpm_cap), ARRAY_SIZE(cap_version)), 30)];
+        u8 *data;
         ssize_t len;
         char *str = buf;
 
@@ -843,15 +899,20 @@ ssize_t tpm_show_caps_1_2(struct device * dev,
         if (chip == NULL)
                 return -ENODEV;
 
+        data = kzalloc(TPM_INTERNAL_RESULT_SIZE, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
         memcpy(data, tpm_cap, sizeof(tpm_cap));
         data[TPM_CAP_IDX] = TPM_CAP_PROP;
         data[TPM_CAP_SUBCAP_IDX] = TPM_CAP_PROP_MANUFACTURER;
 
-        if ((len = tpm_transmit(chip, data, sizeof(data))) <=
-            TPM_ERROR_SIZE) {
+        len = tpm_transmit(chip, data, TPM_INTERNAL_RESULT_SIZE);
+        if (len <= TPM_ERROR_SIZE) {
                 dev_dbg(chip->dev, "A TPM error (%d) occurred "
                         "attempting to determine the manufacturer\n",
                         be32_to_cpu(*((__be32 *) (data + TPM_RET_CODE_IDX))));
+                kfree(data);
                 return 0;
         }
 
@@ -861,8 +922,8 @@ ssize_t tpm_show_caps_1_2(struct device * dev,
         memcpy(data, cap_version, sizeof(cap_version));
         data[CAP_VERSION_IDX] = CAP_VERSION_1_2;
 
-        if ((len = tpm_transmit(chip, data, sizeof(data))) <=
-            TPM_ERROR_SIZE) {
+        len = tpm_transmit(chip, data, TPM_INTERNAL_RESULT_SIZE);
+        if (len <= TPM_ERROR_SIZE) {
                 dev_err(chip->dev, "A TPM error (%d) occurred "
                         "attempting to determine the 1.2 version\n",
                         be32_to_cpu(*((__be32 *) (data + TPM_RET_CODE_IDX))));
@@ -874,6 +935,7 @@ ssize_t tpm_show_caps_1_2(struct device * dev,
                        (int) data[19]);
 
 out:
+        kfree(data);
         return str - buf;
 }
 EXPORT_SYMBOL_GPL(tpm_show_caps_1_2);
@@ -966,7 +1028,7 @@ ssize_t tpm_write(struct file *file, const char __user *buf,
                   size_t size, loff_t *off)
 {
         struct tpm_chip *chip = file->private_data;
-        int in_size = size, out_size;
+        size_t in_size = size, out_size;
 
         /* cannot perform a write until the read has cleared
            either via tpm_read or a user_read_timer timeout */
@@ -1001,7 +1063,7 @@ ssize_t tpm_read(struct file *file, char __user *buf,
                  size_t size, loff_t *off)
 {
         struct tpm_chip *chip = file->private_data;
-        int ret_size;
+        ssize_t ret_size;
 
         del_singleshot_timer_sync(&chip->user_read_timer);
         flush_scheduled_work();
diff --git a/drivers/char/tpm/tpm_bios.c b/drivers/char/tpm/tpm_bios.c
index 60a2d2630e36..68f052b42ed7 100644
--- a/drivers/char/tpm/tpm_bios.c
+++ b/drivers/char/tpm/tpm_bios.c
@@ -448,7 +448,7 @@ out_free:
         goto out;
 }
 
-const struct file_operations tpm_ascii_bios_measurements_ops = {
+static const struct file_operations tpm_ascii_bios_measurements_ops = {
         .open = tpm_ascii_bios_measurements_open,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -486,7 +486,7 @@ out_free:
         goto out;
 }
 
-const struct file_operations tpm_binary_bios_measurements_ops = {
+static const struct file_operations tpm_binary_bios_measurements_ops = {
         .open = tpm_binary_bios_measurements_open,
         .read = seq_read,
         .llseek = seq_lseek,
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index c7a977bc03e8..ed1879c0dd8d 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -622,6 +622,7 @@ static struct pnp_device_id tpm_pnp_tbl[] __devinitdata = {
         {"ATM1200", 0},         /* Atmel */
         {"IFX0102", 0},         /* Infineon */
         {"BCM0101", 0},         /* Broadcom */
+        {"BCM0102", 0},         /* Broadcom */
         {"NSC1200", 0},         /* National */
         {"ICO0102", 0},         /* Intel */
         /* Add new here */
diff --git a/drivers/firewire/fw-iso.c b/drivers/firewire/fw-iso.c
index bcbe794a3ea5..e14c03dc0065 100644
--- a/drivers/firewire/fw-iso.c
+++ b/drivers/firewire/fw-iso.c
@@ -50,7 +50,7 @@ fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card,
 
                 address = dma_map_page(card->device, buffer->pages[i],
                                        0, PAGE_SIZE, direction);
-                if (dma_mapping_error(address)) {
+                if (dma_mapping_error(card->device, address)) {
                         __free_page(buffer->pages[i]);
                         goto out_pages;
                 }
diff --git a/drivers/firewire/fw-ohci.c b/drivers/firewire/fw-ohci.c
index 333b12544dd1..566672e0bcff 100644
--- a/drivers/firewire/fw-ohci.c
+++ b/drivers/firewire/fw-ohci.c
@@ -953,7 +953,7 @@ at_context_queue_packet(struct context *ctx, struct fw_packet *packet)
                 payload_bus =
                         dma_map_single(ohci->card.device, packet->payload,
                                        packet->payload_length, DMA_TO_DEVICE);
-                if (dma_mapping_error(payload_bus)) {
+                if (dma_mapping_error(ohci->card.device, payload_bus)) {
                         packet->ack = RCODE_SEND_ERROR;
                         return -1;
                 }
diff --git a/drivers/firewire/fw-sbp2.c b/drivers/firewire/fw-sbp2.c
index 53fc5a641e6d..aaff50ebba1d 100644
--- a/drivers/firewire/fw-sbp2.c
+++ b/drivers/firewire/fw-sbp2.c
@@ -543,7 +543,7 @@ sbp2_send_management_orb(struct sbp2_logical_unit *lu, int node_id,
         orb->response_bus =
                 dma_map_single(device->card->device, &orb->response,
                                sizeof(orb->response), DMA_FROM_DEVICE);
-        if (dma_mapping_error(orb->response_bus))
+        if (dma_mapping_error(device->card->device, orb->response_bus))
                 goto fail_mapping_response;
 
         orb->request.response.high = 0;
@@ -577,7 +577,7 @@ sbp2_send_management_orb(struct sbp2_logical_unit *lu, int node_id,
         orb->base.request_bus =
                 dma_map_single(device->card->device, &orb->request,
                                sizeof(orb->request), DMA_TO_DEVICE);
-        if (dma_mapping_error(orb->base.request_bus))
+        if (dma_mapping_error(device->card->device, orb->base.request_bus))
                 goto fail_mapping_request;
 
         sbp2_send_orb(&orb->base, lu, node_id, generation,
@@ -1424,7 +1424,7 @@ sbp2_map_scatterlist(struct sbp2_command_orb *orb, struct fw_device *device,
         orb->page_table_bus =
                 dma_map_single(device->card->device, orb->page_table,
                                sizeof(orb->page_table), DMA_TO_DEVICE);
-        if (dma_mapping_error(orb->page_table_bus))
+        if (dma_mapping_error(device->card->device, orb->page_table_bus))
                 goto fail_page_table;
 
         /*
@@ -1509,7 +1509,7 @@ static int sbp2_scsi_queuecommand(struct scsi_cmnd *cmd, scsi_done_fn_t done)
         orb->base.request_bus =
                 dma_map_single(device->card->device, &orb->request,
                                sizeof(orb->request), DMA_TO_DEVICE);
-        if (dma_mapping_error(orb->base.request_bus))
+        if (dma_mapping_error(device->card->device, orb->base.request_bus))
                 goto out;
 
         sbp2_send_orb(&orb->base, lu, lu->tgt->node_id, lu->generation,
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 564138714bb5..452c2d866ec5 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -318,7 +318,7 @@ static void drm_cleanup(struct drm_device * dev)
                 DRM_ERROR("Cannot unload module\n");
 }
 
-int drm_minors_cleanup(int id, void *ptr, void *data)
+static int drm_minors_cleanup(int id, void *ptr, void *data)
 {
         struct drm_minor *minor = ptr;
         struct drm_device *dev;
diff --git a/drivers/infiniband/hw/ipath/ipath_sdma.c b/drivers/infiniband/hw/ipath/ipath_sdma.c
index eaba03273e4f..284c9bca517e 100644
--- a/drivers/infiniband/hw/ipath/ipath_sdma.c
+++ b/drivers/infiniband/hw/ipath/ipath_sdma.c
@@ -698,7 +698,7 @@ retry:
 
         addr = dma_map_single(&dd->pcidev->dev, tx->txreq.map_addr,
                               tx->map_len, DMA_TO_DEVICE);
-        if (dma_mapping_error(addr)) {
+        if (dma_mapping_error(&dd->pcidev->dev, addr)) {
                 ret = -EIO;
                 goto unlock;
         }
diff --git a/drivers/infiniband/hw/ipath/ipath_user_sdma.c b/drivers/infiniband/hw/ipath/ipath_user_sdma.c
index 86e016916cd1..82d9a0b5ca2f 100644
--- a/drivers/infiniband/hw/ipath/ipath_user_sdma.c
+++ b/drivers/infiniband/hw/ipath/ipath_user_sdma.c
@@ -206,7 +206,7 @@ static int ipath_user_sdma_coalesce(const struct ipath_devdata *dd,
 
         dma_addr = dma_map_page(&dd->pcidev->dev, page, 0, len,
                                 DMA_TO_DEVICE);
-        if (dma_mapping_error(dma_addr)) {
+        if (dma_mapping_error(&dd->pcidev->dev, dma_addr)) {
                 ret = -ENOMEM;
                 goto free_unmap;
         }
@@ -301,7 +301,7 @@ static int ipath_user_sdma_pin_pages(const struct ipath_devdata *dd,
                                      pages[j], 0, flen, DMA_TO_DEVICE);
                 unsigned long fofs = addr & ~PAGE_MASK;
 
-                if (dma_mapping_error(dma_addr)) {
+                if (dma_mapping_error(&dd->pcidev->dev, dma_addr)) {
                         ret = -ENOMEM;
                         goto done;
                 }
@@ -508,7 +508,7 @@ static int ipath_user_sdma_queue_pkts(const struct ipath_devdata *dd,
                 if (page) {
                         dma_addr = dma_map_page(&dd->pcidev->dev,
                                                 page, 0, len, DMA_TO_DEVICE);
-                        if (dma_mapping_error(dma_addr)) {
+                        if (dma_mapping_error(&dd->pcidev->dev, dma_addr)) {
                                 ret = -ENOMEM;
                                 goto free_pbc;
                         }
diff --git a/drivers/infiniband/hw/mthca/mthca_eq.c b/drivers/infiniband/hw/mthca/mthca_eq.c
index 4e36aa7cb3d2..cc6858f0b65b 100644
--- a/drivers/infiniband/hw/mthca/mthca_eq.c
+++ b/drivers/infiniband/hw/mthca/mthca_eq.c
@@ -780,7 +780,7 @@ int mthca_map_eq_icm(struct mthca_dev *dev, u64 icm_virt)
                 return -ENOMEM;
         dev->eq_table.icm_dma  = pci_map_page(dev->pdev, dev->eq_table.icm_page, 0,
                                               PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
-        if (pci_dma_mapping_error(dev->eq_table.icm_dma)) {
+        if (pci_dma_mapping_error(dev->pdev, dev->eq_table.icm_dma)) {
                 __free_page(dev->eq_table.icm_page);
                 return -ENOMEM;
         }
diff --git a/drivers/isdn/hisax/hisax_fcpcipnp.c b/drivers/isdn/hisax/hisax_fcpcipnp.c
index c0b4db2f8364..1925118122f8 100644
--- a/drivers/isdn/hisax/hisax_fcpcipnp.c
+++ b/drivers/isdn/hisax/hisax_fcpcipnp.c
@@ -974,8 +974,6 @@ static struct pnp_driver fcpnp_driver = {
         .remove         = __devexit_p(fcpnp_remove),
         .id_table       = fcpnp_ids,
 };
-#else
-static struct pnp_driver fcpnp_driver;
 #endif
 
 static void __devexit fcpci_remove(struct pci_dev *pdev)
diff --git a/drivers/media/dvb/pluto2/pluto2.c b/drivers/media/dvb/pluto2/pluto2.c
index 1360403b88b6..a9653c63f4db 100644
--- a/drivers/media/dvb/pluto2/pluto2.c
+++ b/drivers/media/dvb/pluto2/pluto2.c
@@ -242,7 +242,7 @@ static int __devinit pluto_dma_map(struct pluto *pluto)
         pluto->dma_addr = pci_map_single(pluto->pdev, pluto->dma_buf,
                         TS_DMA_BYTES, PCI_DMA_FROMDEVICE);
 
-        return pci_dma_mapping_error(pluto->dma_addr);
+        return pci_dma_mapping_error(pluto->pdev, pluto->dma_addr);
 }
 
 static void pluto_dma_unmap(struct pluto *pluto)
diff --git a/drivers/memstick/core/memstick.c b/drivers/memstick/core/memstick.c
index 61b98c333cb0..a38005008a20 100644
--- a/drivers/memstick/core/memstick.c
+++ b/drivers/memstick/core/memstick.c
@@ -249,8 +249,11 @@ EXPORT_SYMBOL(memstick_next_req);
  */
 void memstick_new_req(struct memstick_host *host)
 {
-        host->retries = cmd_retries;
-        host->request(host);
+        if (host->card) {
+                host->retries = cmd_retries;
+                INIT_COMPLETION(host->card->mrq_complete);
+                host->request(host);
+        }
 }
 EXPORT_SYMBOL(memstick_new_req);
 
@@ -415,10 +418,14 @@ err_out:
         return NULL;
 }
 
-static void memstick_power_on(struct memstick_host *host)
+static int memstick_power_on(struct memstick_host *host)
 {
-        host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
-        host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
+        int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
+
+        if (!rc)
+                rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
+
+        return rc;
 }
 
 static void memstick_check(struct work_struct *work)
@@ -429,8 +436,11 @@ static void memstick_check(struct work_struct *work)
 
         dev_dbg(&host->dev, "memstick_check started\n");
         mutex_lock(&host->lock);
-        if (!host->card)
-                memstick_power_on(host);
+        if (!host->card) {
+                if (memstick_power_on(host))
+                        goto out_power_off;
+        } else
+                host->card->stop(host->card);
 
         card = memstick_alloc_card(host);
 
@@ -448,7 +458,8 @@ static void memstick_check(struct work_struct *work)
                             || !(host->card->check(host->card))) {
                                 device_unregister(&host->card->dev);
                                 host->card = NULL;
-                        }
+                        } else
+                                host->card->start(host->card);
                 }
 
                 if (!host->card) {
@@ -461,6 +472,7 @@ static void memstick_check(struct work_struct *work)
                         kfree(card);
         }
 
+out_power_off:
         if (!host->card)
                 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
 
@@ -573,11 +585,15 @@ EXPORT_SYMBOL(memstick_suspend_host);
  */
 void memstick_resume_host(struct memstick_host *host)
 {
+        int rc = 0;
+
         mutex_lock(&host->lock);
         if (host->card)
-                memstick_power_on(host);
+                rc = memstick_power_on(host);
         mutex_unlock(&host->lock);
-        memstick_detect_change(host);
+
+        if (!rc)
+                memstick_detect_change(host);
 }
 EXPORT_SYMBOL(memstick_resume_host);
 
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index 477d0fb6e588..44b1817f2f2f 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -136,9 +136,8 @@ struct mspro_block_data {
         unsigned int          caps;
         struct gendisk        *disk;
         struct request_queue  *queue;
+        struct request        *block_req;
         spinlock_t            q_lock;
-        wait_queue_head_t     q_wait;
-        struct task_struct    *q_thread;
 
         unsigned short        page_size;
         unsigned short        cylinders;
@@ -147,9 +146,10 @@ struct mspro_block_data {
 
         unsigned char         system;
         unsigned char         read_only:1,
-                              active:1,
+                              eject:1,
                               has_request:1,
-                              data_dir:1;
+                              data_dir:1,
+                              active:1;
         unsigned char         transfer_cmd;
 
         int                   (*mrq_handler)(struct memstick_dev *card,
@@ -160,12 +160,14 @@ struct mspro_block_data {
         struct scatterlist    req_sg[MSPRO_BLOCK_MAX_SEGS];
         unsigned int          seg_count;
         unsigned int          current_seg;
-        unsigned short        current_page;
+        unsigned int          current_page;
 };
 
 static DEFINE_IDR(mspro_block_disk_idr);
 static DEFINE_MUTEX(mspro_block_disk_lock);
 
+static int mspro_block_complete_req(struct memstick_dev *card, int error);
+
 /*** Block device ***/
 
 static int mspro_block_bd_open(struct inode *inode, struct file *filp)
@@ -197,8 +199,10 @@ static int mspro_block_disk_release(struct gendisk *disk)
 
         mutex_lock(&mspro_block_disk_lock);
 
-        if (msb->usage_count) {
-                msb->usage_count--;
+        if (msb) {
+                if (msb->usage_count)
+                        msb->usage_count--;
+
                 if (!msb->usage_count) {
                         kfree(msb);
                         disk->private_data = NULL;
@@ -523,11 +527,13 @@ static int h_mspro_block_req_init(struct memstick_dev *card,
 static int h_mspro_block_default(struct memstick_dev *card,
                                  struct memstick_request **mrq)
 {
-        complete(&card->mrq_complete);
-        if (!(*mrq)->error)
-                return -EAGAIN;
-        else
-                return (*mrq)->error;
+        return mspro_block_complete_req(card, (*mrq)->error);
+}
+
+static int h_mspro_block_default_bad(struct memstick_dev *card,
+                                     struct memstick_request **mrq)
+{
+        return -ENXIO;
 }
 
 static int h_mspro_block_get_ro(struct memstick_dev *card,
@@ -535,44 +541,30 @@ static int h_mspro_block_get_ro(struct memstick_dev *card,
 {
         struct mspro_block_data *msb = memstick_get_drvdata(card);
 
-        if ((*mrq)->error) {
-                complete(&card->mrq_complete);
-                return (*mrq)->error;
+        if (!(*mrq)->error) {
+                if ((*mrq)->data[offsetof(struct ms_status_register, status0)]
+                    & MEMSTICK_STATUS0_WP)
+                        msb->read_only = 1;
+                else
+                        msb->read_only = 0;
         }
 
-        if ((*mrq)->data[offsetof(struct ms_status_register, status0)]
-            & MEMSTICK_STATUS0_WP)
-                msb->read_only = 1;
-        else
-                msb->read_only = 0;
-
-        complete(&card->mrq_complete);
-        return -EAGAIN;
+        return mspro_block_complete_req(card, (*mrq)->error);
 }
 
 static int h_mspro_block_wait_for_ced(struct memstick_dev *card,
                                       struct memstick_request **mrq)
 {
-        if ((*mrq)->error) {
-                complete(&card->mrq_complete);
-                return (*mrq)->error;
-        }
-
         dev_dbg(&card->dev, "wait for ced: value %x\n", (*mrq)->data[0]);
 
-        if ((*mrq)->data[0] & (MEMSTICK_INT_CMDNAK | MEMSTICK_INT_ERR)) {
-                card->current_mrq.error = -EFAULT;
-                complete(&card->mrq_complete);
-                return card->current_mrq.error;
+        if (!(*mrq)->error) {
+                if ((*mrq)->data[0] & (MEMSTICK_INT_CMDNAK | MEMSTICK_INT_ERR))
+                        (*mrq)->error = -EFAULT;
+                else if (!((*mrq)->data[0] & MEMSTICK_INT_CED))
+                        return 0;
         }
 
-        if (!((*mrq)->data[0] & MEMSTICK_INT_CED))
-                return 0;
-        else {
-                card->current_mrq.error = 0;
-                complete(&card->mrq_complete);
-                return -EAGAIN;
-        }
+        return mspro_block_complete_req(card, (*mrq)->error);
 }
 
 static int h_mspro_block_transfer_data(struct memstick_dev *card,
@@ -583,10 +575,8 @@ static int h_mspro_block_transfer_data(struct memstick_dev *card,
         struct scatterlist t_sg = { 0 };
         size_t t_offset;
 
-        if ((*mrq)->error) {
-                complete(&card->mrq_complete);
-                return (*mrq)->error;
-        }
+        if ((*mrq)->error)
+                return mspro_block_complete_req(card, (*mrq)->error);
 
         switch ((*mrq)->tpc) {
         case MS_TPC_WRITE_REG:
@@ -617,8 +607,8 @@ has_int_reg:
 
                         if (msb->current_seg == msb->seg_count) {
                                 if (t_val & MEMSTICK_INT_CED) {
-                                        complete(&card->mrq_complete);
-                                        return -EAGAIN;
+                                        return mspro_block_complete_req(card,
+                                                                        0);
                                 } else {
                                         card->next_request
                                                 = h_mspro_block_wait_for_ced;
@@ -666,140 +656,184 @@ has_int_reg:
 
 /*** Data transfer ***/
 
-static void mspro_block_process_request(struct memstick_dev *card,
-                                        struct request *req)
+static int mspro_block_issue_req(struct memstick_dev *card, int chunk)
 {
         struct mspro_block_data *msb = memstick_get_drvdata(card);
-        struct mspro_param_register param;
-        int rc, chunk, cnt;
-        unsigned short page_count;
         sector_t t_sec;
-        unsigned long flags;
+        unsigned int count;
+        struct mspro_param_register param;
 
-        do {
-                page_count = 0;
+try_again:
+        while (chunk) {
+                msb->current_page = 0;
                 msb->current_seg = 0;
-                msb->seg_count = blk_rq_map_sg(req->q, req, msb->req_sg);
+                msb->seg_count = blk_rq_map_sg(msb->block_req->q,
+                                               msb->block_req,
+                                               msb->req_sg);
 
-                if (msb->seg_count) {
-                        msb->current_page = 0;
-                        for (rc = 0; rc < msb->seg_count; rc++)
-                                page_count += msb->req_sg[rc].length
-                                              / msb->page_size;
-
-                        t_sec = req->sector;
-                        sector_div(t_sec, msb->page_size >> 9);
-                        param.system = msb->system;
-                        param.data_count = cpu_to_be16(page_count);
-                        param.data_address = cpu_to_be32((uint32_t)t_sec);
-                        param.tpc_param = 0;
-
-                        msb->data_dir = rq_data_dir(req);
-                        msb->transfer_cmd = msb->data_dir == READ
-                                            ? MSPRO_CMD_READ_DATA
-                                            : MSPRO_CMD_WRITE_DATA;
-
-                        dev_dbg(&card->dev, "data transfer: cmd %x, "
-                                "lba %x, count %x\n", msb->transfer_cmd,
-                                be32_to_cpu(param.data_address),
-                                page_count);
-
-                        card->next_request = h_mspro_block_req_init;
-                        msb->mrq_handler = h_mspro_block_transfer_data;
-                        memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG,
-                                          &param, sizeof(param));
-                        memstick_new_req(card->host);
-                        wait_for_completion(&card->mrq_complete);
-                        rc = card->current_mrq.error;
+                if (!msb->seg_count) {
+                        chunk = __blk_end_request(msb->block_req, -ENOMEM,
+                                        blk_rq_cur_bytes(msb->block_req));
+                        continue;
+                }
 
-                        if (rc || (card->current_mrq.tpc == MSPRO_CMD_STOP)) {
-                                for (cnt = 0; cnt < msb->current_seg; cnt++)
-                                        page_count += msb->req_sg[cnt].length
-                                                      / msb->page_size;
-
-                                if (msb->current_page)
-                                        page_count += msb->current_page - 1;
-
-                                if (page_count && (msb->data_dir == READ))
-                                        rc = msb->page_size * page_count;
-                                else
-                                        rc = -EIO;
-                        } else
-                                rc = msb->page_size * page_count;
-                } else
-                        rc = -EFAULT;
+                t_sec = msb->block_req->sector << 9;
+                sector_div(t_sec, msb->page_size);
 
-                spin_lock_irqsave(&msb->q_lock, flags);
-                if (rc >= 0)
-                        chunk = __blk_end_request(req, 0, rc);
-                else
-                        chunk = __blk_end_request(req, rc, 0);
+                count = msb->block_req->nr_sectors << 9;
+                count /= msb->page_size;
 
-                dev_dbg(&card->dev, "end chunk %d, %d\n", rc, chunk);
-                spin_unlock_irqrestore(&msb->q_lock, flags);
-        } while (chunk);
+                param.system = msb->system;
+                param.data_count = cpu_to_be16(count);
+                param.data_address = cpu_to_be32((uint32_t)t_sec);
+                param.tpc_param = 0;
+
+                msb->data_dir = rq_data_dir(msb->block_req);
+                msb->transfer_cmd = msb->data_dir == READ
+                                    ? MSPRO_CMD_READ_DATA
+                                    : MSPRO_CMD_WRITE_DATA;
+
+                dev_dbg(&card->dev, "data transfer: cmd %x, "
+                        "lba %x, count %x\n", msb->transfer_cmd,
+                        be32_to_cpu(param.data_address), count);
+
+                card->next_request = h_mspro_block_req_init;
+                msb->mrq_handler = h_mspro_block_transfer_data;
+                memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG,
+                                  &param, sizeof(param));
+                memstick_new_req(card->host);
+                return 0;
+        }
+
+        dev_dbg(&card->dev, "elv_next\n");
+        msb->block_req = elv_next_request(msb->queue);
+        if (!msb->block_req) {
+                dev_dbg(&card->dev, "issue end\n");
+                return -EAGAIN;
+        }
+
+        dev_dbg(&card->dev, "trying again\n");
+        chunk = 1;
+        goto try_again;
 }
 
-static int mspro_block_has_request(struct mspro_block_data *msb)
+static int mspro_block_complete_req(struct memstick_dev *card, int error)
 {
-        int rc = 0;
+        struct mspro_block_data *msb = memstick_get_drvdata(card);
+        int chunk, cnt;
+        unsigned int t_len = 0;
         unsigned long flags;
 
         spin_lock_irqsave(&msb->q_lock, flags);
-        if (kthread_should_stop() || msb->has_request)
-                rc = 1;
+        dev_dbg(&card->dev, "complete %d, %d\n", msb->has_request ? 1 : 0,
+                error);
+
+        if (msb->has_request) {
+                /* Nothing to do - not really an error */
+                if (error == -EAGAIN)
+                        error = 0;
+
+                if (error || (card->current_mrq.tpc == MSPRO_CMD_STOP)) {
+                        if (msb->data_dir == READ) {
+                                for (cnt = 0; cnt < msb->current_seg; cnt++)
+                                        t_len += msb->req_sg[cnt].length
+                                                 / msb->page_size;
+
+                                        if (msb->current_page)
+                                                t_len += msb->current_page - 1;
+
+                                        t_len *= msb->page_size;
+                        }
+                } else
+                        t_len = msb->block_req->nr_sectors << 9;
+
+                dev_dbg(&card->dev, "transferred %x (%d)\n", t_len, error);
+
+                if (error && !t_len)
+                        t_len = blk_rq_cur_bytes(msb->block_req);
+
+                chunk = __blk_end_request(msb->block_req, error, t_len);
+
+                error = mspro_block_issue_req(card, chunk);
+
+                if (!error)
+                        goto out;
+                else
+                        msb->has_request = 0;
+        } else {
+                if (!error)
+                        error = -EAGAIN;
+        }
+
+        card->next_request = h_mspro_block_default_bad;
+        complete_all(&card->mrq_complete);
+out:
         spin_unlock_irqrestore(&msb->q_lock, flags);
-        return rc;
+        return error;
 }
 
-static int mspro_block_queue_thread(void *data)
+static void mspro_block_stop(struct memstick_dev *card)
 {
-        struct memstick_dev *card = data;
-        struct memstick_host *host = card->host;
         struct mspro_block_data *msb = memstick_get_drvdata(card);
-        struct request *req;
+        int rc = 0;
         unsigned long flags;
 
         while (1) {
-                wait_event(msb->q_wait, mspro_block_has_request(msb));
-                dev_dbg(&card->dev, "thread iter\n");
-
                 spin_lock_irqsave(&msb->q_lock, flags);
-                req = elv_next_request(msb->queue);
-                dev_dbg(&card->dev, "next req %p\n", req);
-                if (!req) {
-                        msb->has_request = 0;
-                        if (kthread_should_stop()) {
-                                spin_unlock_irqrestore(&msb->q_lock, flags);
-                                break;
-                        }
-                } else
-                        msb->has_request = 1;
+                if (!msb->has_request) {
+                        blk_stop_queue(msb->queue);
+                        rc = 1;
+                }
                 spin_unlock_irqrestore(&msb->q_lock, flags);
 
-                if (req) {
-                        mutex_lock(&host->lock);
-                        mspro_block_process_request(card, req);
-                        mutex_unlock(&host->lock);
-                }
+                if (rc)
+                        break;
+
+                wait_for_completion(&card->mrq_complete);
         }
-        dev_dbg(&card->dev, "thread finished\n");
-        return 0;
 }
 
-static void mspro_block_request(struct request_queue *q)
+static void mspro_block_start(struct memstick_dev *card)
+{
+        struct mspro_block_data *msb = memstick_get_drvdata(card);
+        unsigned long flags;
+
+        spin_lock_irqsave(&msb->q_lock, flags);
+        blk_start_queue(msb->queue);
+        spin_unlock_irqrestore(&msb->q_lock, flags);
+}
+
+static int mspro_block_prepare_req(struct request_queue *q, struct request *req)
+{
+        if (!blk_fs_request(req) && !blk_pc_request(req)) {
+                blk_dump_rq_flags(req, "MSPro unsupported request");
+                return BLKPREP_KILL;
+        }
+
+        req->cmd_flags |= REQ_DONTPREP;
+
+        return BLKPREP_OK;
+}
+
+static void mspro_block_submit_req(struct request_queue *q)
 {
         struct memstick_dev *card = q->queuedata;
         struct mspro_block_data *msb = memstick_get_drvdata(card);
         struct request *req = NULL;
 
-        if (msb->q_thread) {
-                msb->has_request = 1;
-                wake_up_all(&msb->q_wait);
-        } else {
+        if (msb->has_request)
+                return;
+
+        if (msb->eject) {
                 while ((req = elv_next_request(q)) != NULL)
                         end_queued_request(req, -ENODEV);
+
+                return;
         }
+
+        msb->has_request = 1;
+        if (mspro_block_issue_req(card, 0))
+                msb->has_request = 0;
 }
 
 /*** Initialization ***/
@@ -1169,16 +1203,14 @@ static int mspro_block_init_disk(struct memstick_dev *card)
                 goto out_release_id;
         }
 
-        spin_lock_init(&msb->q_lock);
-        init_waitqueue_head(&msb->q_wait);
-
-        msb->queue = blk_init_queue(mspro_block_request, &msb->q_lock);
+        msb->queue = blk_init_queue(mspro_block_submit_req, &msb->q_lock);
         if (!msb->queue) {
                 rc = -ENOMEM;
                 goto out_put_disk;
         }
 
         msb->queue->queuedata = card;
+        blk_queue_prep_rq(msb->queue, mspro_block_prepare_req);
 
         blk_queue_bounce_limit(msb->queue, limit);
         blk_queue_max_sectors(msb->queue, MSPRO_BLOCK_MAX_PAGES);
@@ -1204,14 +1236,8 @@ static int mspro_block_init_disk(struct memstick_dev *card)
         capacity *= msb->page_size >> 9;
         set_capacity(msb->disk, capacity);
         dev_dbg(&card->dev, "capacity set %ld\n", capacity);
-        msb->q_thread = kthread_run(mspro_block_queue_thread, card,
-                                    DRIVER_NAME"d");
-        if (IS_ERR(msb->q_thread))
-                goto out_put_disk;
 
-        mutex_unlock(&host->lock);
         add_disk(msb->disk);
-        mutex_lock(&host->lock);
         msb->active = 1;
         return 0;
 
@@ -1259,6 +1285,7 @@ static int mspro_block_probe(struct memstick_dev *card)
                 return -ENOMEM;
         memstick_set_drvdata(card, msb);
         msb->card = card;
+        spin_lock_init(&msb->q_lock);
 
         rc = mspro_block_init_card(card);
 
@@ -1272,6 +1299,8 @@ static int mspro_block_probe(struct memstick_dev *card)
         rc = mspro_block_init_disk(card);
         if (!rc) {
                 card->check = mspro_block_check_card;
+                card->stop = mspro_block_stop;
+                card->start = mspro_block_start;
                 return 0;
         }
 
@@ -1286,26 +1315,17 @@ out_free:
 static void mspro_block_remove(struct memstick_dev *card)
 {
         struct mspro_block_data *msb = memstick_get_drvdata(card);
-        struct task_struct *q_thread = NULL;
         unsigned long flags;
 
         del_gendisk(msb->disk);
         dev_dbg(&card->dev, "mspro block remove\n");
         spin_lock_irqsave(&msb->q_lock, flags);
-        q_thread = msb->q_thread;
-        msb->q_thread = NULL;
-        msb->active = 0;
+        msb->eject = 1;
+        blk_start_queue(msb->queue);
         spin_unlock_irqrestore(&msb->q_lock, flags);
 
-        if (q_thread) {
-                mutex_unlock(&card->host->lock);
-                kthread_stop(q_thread);
-                mutex_lock(&card->host->lock);
-        }
-
-        dev_dbg(&card->dev, "queue thread stopped\n");
-
         blk_cleanup_queue(msb->queue);
+        msb->queue = NULL;
 
         sysfs_remove_group(&card->dev.kobj, &msb->attr_group);
 
@@ -1322,19 +1342,13 @@ static void mspro_block_remove(struct memstick_dev *card)
 static int mspro_block_suspend(struct memstick_dev *card, pm_message_t state)
 {
         struct mspro_block_data *msb = memstick_get_drvdata(card);
-        struct task_struct *q_thread = NULL;
         unsigned long flags;
 
         spin_lock_irqsave(&msb->q_lock, flags);
-        q_thread = msb->q_thread;
-        msb->q_thread = NULL;
-        msb->active = 0;
         blk_stop_queue(msb->queue);
+        msb->active = 0;
         spin_unlock_irqrestore(&msb->q_lock, flags);
 
-        if (q_thread)
-                kthread_stop(q_thread);
-
         return 0;
 }
 
@@ -1373,14 +1387,7 @@ static int mspro_block_resume(struct memstick_dev *card)
                         if (memcmp(s_attr->data, r_attr->data, s_attr->size))
                                 break;
 
-                        memstick_set_drvdata(card, msb);
-                        msb->q_thread = kthread_run(mspro_block_queue_thread,
-                                                    card, DRIVER_NAME"d");
-                        if (IS_ERR(msb->q_thread))
-                                msb->q_thread = NULL;
-                        else
-                                msb->active = 1;
-
+                        msb->active = 1;
                         break;
                 }
         }
diff --git a/drivers/memstick/host/jmb38x_ms.c b/drivers/memstick/host/jmb38x_ms.c
index 4e3bfbcdf155..3485c63d20b0 100644
--- a/drivers/memstick/host/jmb38x_ms.c
+++ b/drivers/memstick/host/jmb38x_ms.c
@@ -50,6 +50,7 @@ struct jmb38x_ms_host {
         struct jmb38x_ms        *chip;
         void __iomem            *addr;
         spinlock_t              lock;
+        struct tasklet_struct   notify;
         int                     id;
         char                    host_id[32];
         int                     irq;
@@ -590,55 +591,97 @@ static void jmb38x_ms_abort(unsigned long data)
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static void jmb38x_ms_request(struct memstick_host *msh)
+static void jmb38x_ms_req_tasklet(unsigned long data)
 {
+        struct memstick_host *msh = (struct memstick_host *)data;
         struct jmb38x_ms_host *host = memstick_priv(msh);
         unsigned long flags;
         int rc;
 
         spin_lock_irqsave(&host->lock, flags);
-        if (host->req) {
-                spin_unlock_irqrestore(&host->lock, flags);
-                BUG();
-                return;
+        if (!host->req) {
+                do {
+                        rc = memstick_next_req(msh, &host->req);
+                        dev_dbg(&host->chip->pdev->dev, "tasklet req %d\n", rc);
+                } while (!rc && jmb38x_ms_issue_cmd(msh));
         }
-
-        do {
-                rc = memstick_next_req(msh, &host->req);
-        } while (!rc && jmb38x_ms_issue_cmd(msh));
         spin_unlock_irqrestore(&host->lock, flags);
 }
 
-static void jmb38x_ms_reset(struct jmb38x_ms_host *host)
+static void jmb38x_ms_dummy_submit(struct memstick_host *msh)
 {
-        unsigned int host_ctl = readl(host->addr + HOST_CONTROL);
+        return;
+}
+
+static void jmb38x_ms_submit_req(struct memstick_host *msh)
+{
+        struct jmb38x_ms_host *host = memstick_priv(msh);
+
+        tasklet_schedule(&host->notify);
+}
+
+static int jmb38x_ms_reset(struct jmb38x_ms_host *host)
+{
+        int cnt;
+
+        writel(HOST_CONTROL_RESET_REQ | HOST_CONTROL_CLOCK_EN
+               | readl(host->addr + HOST_CONTROL),
+               host->addr + HOST_CONTROL);
+        mmiowb();
+
+        for (cnt = 0; cnt < 20; ++cnt) {
+                if (!(HOST_CONTROL_RESET_REQ
+                      & readl(host->addr + HOST_CONTROL)))
+                        goto reset_next;
 
-        writel(HOST_CONTROL_RESET_REQ, host->addr + HOST_CONTROL);
+                ndelay(20);
+        }
+        dev_dbg(&host->chip->pdev->dev, "reset_req timeout\n");
+        return -EIO;
+
+reset_next:
+        writel(HOST_CONTROL_RESET | HOST_CONTROL_CLOCK_EN
+               | readl(host->addr + HOST_CONTROL),
+               host->addr + HOST_CONTROL);
+        mmiowb();
+
+        for (cnt = 0; cnt < 20; ++cnt) {
+                if (!(HOST_CONTROL_RESET
+                      & readl(host->addr + HOST_CONTROL)))
+                        goto reset_ok;
 
-        while (HOST_CONTROL_RESET_REQ
-               & (host_ctl = readl(host->addr + HOST_CONTROL))) {
                 ndelay(20);
-                dev_dbg(&host->chip->pdev->dev, "reset %08x\n", host_ctl);
         }
+        dev_dbg(&host->chip->pdev->dev, "reset timeout\n");
+        return -EIO;
 
-        writel(HOST_CONTROL_RESET, host->addr + HOST_CONTROL);
+reset_ok:
         mmiowb();
         writel(INT_STATUS_ALL, host->addr + INT_SIGNAL_ENABLE);
         writel(INT_STATUS_ALL, host->addr + INT_STATUS_ENABLE);
+        return 0;
 }
 
-static void jmb38x_ms_set_param(struct memstick_host *msh,
-                                enum memstick_param param,
-                                int value)
+static int jmb38x_ms_set_param(struct memstick_host *msh,
+                               enum memstick_param param,
+                               int value)
 {
         struct jmb38x_ms_host *host = memstick_priv(msh);
         unsigned int host_ctl = readl(host->addr + HOST_CONTROL);
         unsigned int clock_ctl = CLOCK_CONTROL_40MHZ, clock_delay = 0;
+        int rc = 0;
 
         switch (param) {
         case MEMSTICK_POWER:
                 if (value == MEMSTICK_POWER_ON) {
-                        jmb38x_ms_reset(host);
+                        rc = jmb38x_ms_reset(host);
+                        if (rc)
+                                return rc;
+
+                        host_ctl = 7;
+                        host_ctl |= HOST_CONTROL_POWER_EN
+                                 | HOST_CONTROL_CLOCK_EN;
+                        writel(host_ctl, host->addr + HOST_CONTROL);
 
                         writel(host->id ? PAD_PU_PD_ON_MS_SOCK1
                                         : PAD_PU_PD_ON_MS_SOCK0,
@@ -647,11 +690,7 @@ static void jmb38x_ms_set_param(struct memstick_host *msh,
                         writel(PAD_OUTPUT_ENABLE_MS,
                                host->addr + PAD_OUTPUT_ENABLE);
 
-                        host_ctl = 7;
-                        host_ctl |= HOST_CONTROL_POWER_EN
-                                 | HOST_CONTROL_CLOCK_EN;
-                        writel(host_ctl, host->addr + HOST_CONTROL);
-
+                        msleep(10);
                         dev_dbg(&host->chip->pdev->dev, "power on\n");
                 } else if (value == MEMSTICK_POWER_OFF) {
                         host_ctl &= ~(HOST_CONTROL_POWER_EN
@@ -660,7 +699,8 @@ static void jmb38x_ms_set_param(struct memstick_host *msh,
                         writel(0, host->addr + PAD_OUTPUT_ENABLE);
                         writel(PAD_PU_PD_OFF, host->addr + PAD_PU_PD);
                         dev_dbg(&host->chip->pdev->dev, "power off\n");
-                }
+                } else
+                        return -EINVAL;
                 break;
         case MEMSTICK_INTERFACE:
                 host_ctl &= ~(3 << HOST_CONTROL_IF_SHIFT);
@@ -686,12 +726,14 @@ static void jmb38x_ms_set_param(struct memstick_host *msh,
                         host_ctl &= ~HOST_CONTROL_REI;
                         clock_ctl = CLOCK_CONTROL_60MHZ;
                         clock_delay = 0;
-                }
+                } else
+                        return -EINVAL;
                 writel(host_ctl, host->addr + HOST_CONTROL);
                 writel(clock_ctl, host->addr + CLOCK_CONTROL);
                 writel(clock_delay, host->addr + CLOCK_DELAY);
                 break;
         };
+        return 0;
 }
 
 #ifdef CONFIG_PM
@@ -785,7 +827,9 @@ static struct memstick_host *jmb38x_ms_alloc_host(struct jmb38x_ms *jm, int cnt)
                  host->id);
         host->irq = jm->pdev->irq;
         host->timeout_jiffies = msecs_to_jiffies(1000);
-        msh->request = jmb38x_ms_request;
+
+        tasklet_init(&host->notify, jmb38x_ms_req_tasklet, (unsigned long)msh);
+        msh->request = jmb38x_ms_submit_req;
         msh->set_param = jmb38x_ms_set_param;
 
         msh->caps = MEMSTICK_CAP_PAR4 | MEMSTICK_CAP_PAR8;
@@ -897,6 +941,8 @@ static void jmb38x_ms_remove(struct pci_dev *dev)
 
                 host = memstick_priv(jm->hosts[cnt]);
 
+                jm->hosts[cnt]->request = jmb38x_ms_dummy_submit;
+                tasklet_kill(&host->notify);
                 writel(0, host->addr + INT_SIGNAL_ENABLE);
                 writel(0, host->addr + INT_STATUS_ENABLE);
                 mmiowb();
diff --git a/drivers/memstick/host/tifm_ms.c b/drivers/memstick/host/tifm_ms.c
index 8577de4ebb0e..d32d6ad8f3fc 100644
--- a/drivers/memstick/host/tifm_ms.c
+++ b/drivers/memstick/host/tifm_ms.c
@@ -71,6 +71,7 @@ struct tifm_ms {
         struct tifm_dev         *dev;
         struct timer_list       timer;
         struct memstick_request *req;
+        struct tasklet_struct   notify;
         unsigned int            mode_mask;
         unsigned int            block_pos;
         unsigned long           timeout_jiffies;
@@ -455,49 +456,51 @@ static void tifm_ms_card_event(struct tifm_dev *sock)
         return;
 }
 
-static void tifm_ms_request(struct memstick_host *msh)
+static void tifm_ms_req_tasklet(unsigned long data)
 {
+        struct memstick_host *msh = (struct memstick_host *)data;
         struct tifm_ms *host = memstick_priv(msh);
         struct tifm_dev *sock = host->dev;
         unsigned long flags;
         int rc;
 
         spin_lock_irqsave(&sock->lock, flags);
-        if (host->req) {
-                printk(KERN_ERR "%s : unfinished request detected\n",
-                       sock->dev.bus_id);
-                spin_unlock_irqrestore(&sock->lock, flags);
-                tifm_eject(host->dev);
-                return;
-        }
+        if (!host->req) {
+                if (host->eject) {
+                        do {
+                                rc = memstick_next_req(msh, &host->req);
+                                if (!rc)
+                                        host->req->error = -ETIME;
+                        } while (!rc);
+                        spin_unlock_irqrestore(&sock->lock, flags);
+                        return;
+                }
 
-        if (host->eject) {
                 do {
                         rc = memstick_next_req(msh, &host->req);
-                        if (!rc)
-                                host->req->error = -ETIME;
-                } while (!rc);
-                spin_unlock_irqrestore(&sock->lock, flags);
-                return;
+                } while (!rc && tifm_ms_issue_cmd(host));
         }
-
-        do {
-                rc = memstick_next_req(msh, &host->req);
-        } while (!rc && tifm_ms_issue_cmd(host));
-
         spin_unlock_irqrestore(&sock->lock, flags);
+}
+
+static void tifm_ms_dummy_submit(struct memstick_host *msh)
+{
         return;
 }
 
-static void tifm_ms_set_param(struct memstick_host *msh,
-                              enum memstick_param param,
-                              int value)
+static void tifm_ms_submit_req(struct memstick_host *msh)
 {
         struct tifm_ms *host = memstick_priv(msh);
-        struct tifm_dev *sock = host->dev;
-        unsigned long flags;
 
-        spin_lock_irqsave(&sock->lock, flags);
+        tasklet_schedule(&host->notify);
+}
+
+static int tifm_ms_set_param(struct memstick_host *msh,
+                             enum memstick_param param,
+                             int value)
+{
+        struct tifm_ms *host = memstick_priv(msh);
+        struct tifm_dev *sock = host->dev;
 
         switch (param) {
         case MEMSTICK_POWER:
@@ -512,7 +515,8 @@ static void tifm_ms_set_param(struct memstick_host *msh,
                         writel(TIFM_MS_SYS_FCLR | TIFM_MS_SYS_INTCLR,
                                sock->addr + SOCK_MS_SYSTEM);
                         writel(0xffffffff, sock->addr + SOCK_MS_STATUS);
-                }
+                } else
+                        return -EINVAL;
                 break;
         case MEMSTICK_INTERFACE:
                 if (value == MEMSTICK_SERIAL) {
@@ -525,11 +529,12 @@ static void tifm_ms_set_param(struct memstick_host *msh,
                         writel(TIFM_CTRL_FAST_CLK
                                | readl(sock->addr + SOCK_CONTROL),
                                sock->addr + SOCK_CONTROL);
-                }
+                } else
+                        return -EINVAL;
                 break;
         };
 
-        spin_unlock_irqrestore(&sock->lock, flags);
+        return 0;
 }
 
 static void tifm_ms_abort(unsigned long data)
@@ -570,8 +575,9 @@ static int tifm_ms_probe(struct tifm_dev *sock)
         host->timeout_jiffies = msecs_to_jiffies(1000);
 
         setup_timer(&host->timer, tifm_ms_abort, (unsigned long)host);
+        tasklet_init(&host->notify, tifm_ms_req_tasklet, (unsigned long)msh);
 
-        msh->request = tifm_ms_request;
+        msh->request = tifm_ms_submit_req;
         msh->set_param = tifm_ms_set_param;
         sock->card_event = tifm_ms_card_event;
         sock->data_event = tifm_ms_data_event;
@@ -593,6 +599,8 @@ static void tifm_ms_remove(struct tifm_dev *sock)
         int rc = 0;
         unsigned long flags;
 
+        msh->request = tifm_ms_dummy_submit;
+        tasklet_kill(&host->notify);
         spin_lock_irqsave(&sock->lock, flags);
         host->eject = 1;
         if (host->req) {
diff --git a/drivers/message/fusion/lsi/mpi_history.txt b/drivers/message/fusion/lsi/mpi_history.txt
index 241592ab13ad..3f15fcfe4a2e 100644
--- a/drivers/message/fusion/lsi/mpi_history.txt
+++ b/drivers/message/fusion/lsi/mpi_history.txt
@@ -127,7 +127,7 @@ mpi_ioc.h
  *  08-08-01  01.02.01  Original release for v1.2 work.
  *                      New format for FWVersion and ProductId in
  *                      MSG_IOC_FACTS_REPLY and MPI_FW_HEADER.
- *  08-31-01  01.02.02  Addded event MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE and
+ *  08-31-01  01.02.02  Added event MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE and
  *                      related structure and defines.
  *                      Added event MPI_EVENT_ON_BUS_TIMER_EXPIRED.
  *                      Added MPI_IOCINIT_FLAGS_DISCARD_FW_IMAGE.
@@ -187,7 +187,7 @@ mpi_ioc.h
  *  10-11-06  01.05.12  Added MPI_IOCFACTS_EXCEPT_METADATA_UNSUPPORTED.
  *                      Added MaxInitiators field to PortFacts reply.
  *                      Added SAS Device Status Change ReasonCode for
- *                      asynchronous notificaiton.
+ *                      asynchronous notification.
  *                      Added MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE and event
  *                      data structure.
  *                      Added new ImageType values for FWDownload and FWUpload
@@ -213,7 +213,7 @@ mpi_cnfg.h
  *                      Added _RESPONSE_ID_MASK definition to SCSI_PORT_1
  *                      page and updated the page version.
  *                      Added Information field and _INFO_PARAMS_NEGOTIATED
- *                      definitionto SCSI_DEVICE_0 page.
+ *                      definition to SCSI_DEVICE_0 page.
  *  06-22-00  01.00.03  Removed batch controls from LAN_0 page and updated the
  *                      page version.
  *                      Added BucketsRemaining to LAN_1 page, redefined the
diff --git a/drivers/mfd/asic3.c b/drivers/mfd/asic3.c
index 3b870e7fb3e1..eabf0bfccab4 100644
--- a/drivers/mfd/asic3.c
+++ b/drivers/mfd/asic3.c
@@ -314,10 +314,12 @@ static int __init asic3_irq_probe(struct platform_device *pdev)
         unsigned long clksel = 0;
         unsigned int irq, irq_base;
         int map_size;
+        int ret;
 
-        asic->irq_nr = platform_get_irq(pdev, 0);
-        if (asic->irq_nr < 0)
-                return asic->irq_nr;
+        ret = platform_get_irq(pdev, 0);
+        if (ret < 0)
+                return ret;
+        asic->irq_nr = ret;
 
         /* turn on clock to IRQ controller */
         clksel |= CLOCK_SEL_CX;
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index c3a5db72ddd7..5f95e10229b5 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -337,7 +337,7 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
 
         host->align_addr = dma_map_single(mmc_dev(host->mmc),
                 host->align_buffer, 128 * 4, direction);
-        if (dma_mapping_error(host->align_addr))
+        if (dma_mapping_error(mmc_dev(host->mmc), host->align_addr))
                 goto fail;
         BUG_ON(host->align_addr & 0x3);
 
@@ -439,7 +439,7 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
 
         host->adma_addr = dma_map_single(mmc_dev(host->mmc),
                 host->adma_desc, (128 * 2 + 1) * 4, DMA_TO_DEVICE);
-        if (dma_mapping_error(host->align_addr))
+        if (dma_mapping_error(mmc_dev(host->mmc), host->align_addr))
                 goto unmap_entries;
         BUG_ON(host->adma_addr & 0x3);
 
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index a06bf8b89343..e354faee5df0 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -9,6 +9,8 @@
  * your option) any later version.
  */
 
+#include <linux/scatterlist.h>
+
 /*
  * Controller registers
  */
diff --git a/drivers/net/arm/ep93xx_eth.c b/drivers/net/arm/ep93xx_eth.c
index 7a14980f3472..18d3eeb7eab2 100644
--- a/drivers/net/arm/ep93xx_eth.c
+++ b/drivers/net/arm/ep93xx_eth.c
@@ -482,7 +482,7 @@ static int ep93xx_alloc_buffers(struct ep93xx_priv *ep)
                         goto err;
 
                 d = dma_map_single(NULL, page, PAGE_SIZE, DMA_FROM_DEVICE);
-                if (dma_mapping_error(d)) {
+                if (dma_mapping_error(NULL, d)) {
                         free_page((unsigned long)page);
                         goto err;
                 }
@@ -505,7 +505,7 @@ static int ep93xx_alloc_buffers(struct ep93xx_priv *ep)
                         goto err;
 
                 d = dma_map_single(NULL, page, PAGE_SIZE, DMA_TO_DEVICE);
-                if (dma_mapping_error(d)) {
+                if (dma_mapping_error(NULL, d)) {
                         free_page((unsigned long)page);
                         goto err;
                 }
diff --git a/drivers/net/bnx2x_main.c b/drivers/net/bnx2x_main.c
index 0263bef9cc6d..c7cc760a1777 100644
--- a/drivers/net/bnx2x_main.c
+++ b/drivers/net/bnx2x_main.c
@@ -1020,7 +1020,7 @@ static inline int bnx2x_alloc_rx_sge(struct bnx2x *bp,
 
         mapping = pci_map_page(bp->pdev, page, 0, BCM_PAGE_SIZE*PAGES_PER_SGE,
                                PCI_DMA_FROMDEVICE);
-        if (unlikely(dma_mapping_error(mapping))) {
+        if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
                 __free_pages(page, PAGES_PER_SGE_SHIFT);
                 return -ENOMEM;
         }
@@ -1048,7 +1048,7 @@ static inline int bnx2x_alloc_rx_skb(struct bnx2x *bp,
 
         mapping = pci_map_single(bp->pdev, skb->data, bp->rx_buf_use_size,
                                  PCI_DMA_FROMDEVICE);
-        if (unlikely(dma_mapping_error(mapping))) {
+        if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
                 dev_kfree_skb(skb);
                 return -ENOMEM;
         }
diff --git a/drivers/net/cassini.c b/drivers/net/cassini.c
index 83768df27806..f1936d51b458 100644
--- a/drivers/net/cassini.c
+++ b/drivers/net/cassini.c
@@ -576,6 +576,18 @@ static void cas_spare_recover(struct cas *cp, const gfp_t flags)
         list_for_each_safe(elem, tmp, &list) {
                 cas_page_t *page = list_entry(elem, cas_page_t, list);
 
+                /*
+                 * With the lockless pagecache, cassini buffering scheme gets
+                 * slightly less accurate: we might find that a page has an
+                 * elevated reference count here, due to a speculative ref,
+                 * and skip it as in-use. Ideally we would be able to reclaim
+                 * it. However this would be such a rare case, it doesn't
+                 * matter too much as we should pick it up the next time round.
+                 *
+                 * Importantly, if we find that the page has a refcount of 1
+                 * here (our refcount), then we know it is definitely not inuse
+                 * so we can reuse it.
+                 */
                 if (page_count(page->buffer) > 1)
                         continue;
 
diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c
index a96331c875e6..1b0861d73ab7 100644
--- a/drivers/net/cxgb3/sge.c
+++ b/drivers/net/cxgb3/sge.c
@@ -386,7 +386,7 @@ static inline int add_one_rx_buf(void *va, unsigned int len,
         dma_addr_t mapping;
 
         mapping = pci_map_single(pdev, va, len, PCI_DMA_FROMDEVICE);
-        if (unlikely(pci_dma_mapping_error(mapping)))
+        if (unlikely(pci_dma_mapping_error(pdev, mapping)))
                 return -ENOMEM;
 
         pci_unmap_addr_set(sd, dma_addr, mapping);
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index 1037b1332312..19d32a227be1 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -1790,7 +1790,7 @@ static int e100_rx_alloc_skb(struct nic *nic, struct rx *rx)
         rx->dma_addr = pci_map_single(nic->pdev, rx->skb->data,
                 RFD_BUF_LEN, PCI_DMA_BIDIRECTIONAL);
 
-        if (pci_dma_mapping_error(rx->dma_addr)) {
+        if (pci_dma_mapping_error(nic->pdev, rx->dma_addr)) {
                 dev_kfree_skb_any(rx->skb);
                 rx->skb = NULL;
                 rx->dma_addr = 0;
diff --git a/drivers/net/e1000e/ethtool.c b/drivers/net/e1000e/ethtool.c
index a14561f40db0..9350564065e7 100644
--- a/drivers/net/e1000e/ethtool.c
+++ b/drivers/net/e1000e/ethtool.c
@@ -1090,7 +1090,7 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
                 tx_ring->buffer_info[i].dma =
                         pci_map_single(pdev, skb->data, skb->len,
                                        PCI_DMA_TODEVICE);
-                if (pci_dma_mapping_error(tx_ring->buffer_info[i].dma)) {
+                if (pci_dma_mapping_error(pdev, tx_ring->buffer_info[i].dma)) {
                         ret_val = 4;
                         goto err_nomem;
                 }
@@ -1153,7 +1153,7 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
                 rx_ring->buffer_info[i].dma =
                         pci_map_single(pdev, skb->data, 2048,
                                        PCI_DMA_FROMDEVICE);
-                if (pci_dma_mapping_error(rx_ring->buffer_info[i].dma)) {
+                if (pci_dma_mapping_error(pdev, rx_ring->buffer_info[i].dma)) {
                         ret_val = 8;
                         goto err_nomem;
                 }
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 9c0f56b3c518..d13677899767 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -195,7 +195,7 @@ map_skb:
                 buffer_info->dma = pci_map_single(pdev, skb->data,
                                                   adapter->rx_buffer_len,
                                                   PCI_DMA_FROMDEVICE);
-                if (pci_dma_mapping_error(buffer_info->dma)) {
+                if (pci_dma_mapping_error(pdev, buffer_info->dma)) {
                         dev_err(&pdev->dev, "RX DMA map failed\n");
                         adapter->rx_dma_failed++;
                         break;
@@ -265,7 +265,7 @@ static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
                                                    ps_page->page,
                                                    0, PAGE_SIZE,
                                                    PCI_DMA_FROMDEVICE);
-                                if (pci_dma_mapping_error(ps_page->dma)) {
+                                if (pci_dma_mapping_error(pdev, ps_page->dma)) {
                                         dev_err(&adapter->pdev->dev,
                                           "RX DMA page map failed\n");
                                         adapter->rx_dma_failed++;
@@ -300,7 +300,7 @@ static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
                 buffer_info->dma = pci_map_single(pdev, skb->data,
                                                   adapter->rx_ps_bsize0,
                                                   PCI_DMA_FROMDEVICE);
-                if (pci_dma_mapping_error(buffer_info->dma)) {
+                if (pci_dma_mapping_error(pdev, buffer_info->dma)) {
                         dev_err(&pdev->dev, "RX DMA map failed\n");
                         adapter->rx_dma_failed++;
                         /* cleanup skb */
@@ -3344,7 +3344,7 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
                                 skb->data + offset,
                                 size,
                                 PCI_DMA_TODEVICE);
-                if (pci_dma_mapping_error(buffer_info->dma)) {
+                if (pci_dma_mapping_error(adapter->pdev, buffer_info->dma)) {
                         dev_err(&adapter->pdev->dev, "TX DMA map failed\n");
                         adapter->tx_dma_failed++;
                         return -1;
@@ -3382,7 +3382,8 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
                                         offset,
                                         size,
                                         PCI_DMA_TODEVICE);
-                        if (pci_dma_mapping_error(buffer_info->dma)) {
+                        if (pci_dma_mapping_error(adapter->pdev,
+                                                  buffer_info->dma)) {
                                 dev_err(&adapter->pdev->dev,
                                         "TX DMA page map failed\n");
                                 adapter->tx_dma_failed++;
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index e5a6e2e84540..91ec9fdc7184 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -260,7 +260,7 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
                 dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
                                 pool->buff_size, DMA_FROM_DEVICE);
 
-                if (dma_mapping_error(dma_addr))
+                if (dma_mapping_error((&adapter->vdev->dev, dma_addr))
                         goto failure;
 
                 pool->free_map[free_index] = IBM_VETH_INVALID_MAP;
@@ -294,7 +294,7 @@ failure:
                 pool->consumer_index = pool->size - 1;
         else
                 pool->consumer_index--;
-        if (!dma_mapping_error(dma_addr))
+        if (!dma_mapping_error((&adapter->vdev->dev, dma_addr))
                 dma_unmap_single(&adapter->vdev->dev,
                                  pool->dma_addr[index], pool->buff_size,
                                  DMA_FROM_DEVICE);
@@ -448,11 +448,11 @@ static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
 static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
 {
         int i;
+        struct device *dev = &adapter->vdev->dev;
 
         if(adapter->buffer_list_addr != NULL) {
-                if(!dma_mapping_error(adapter->buffer_list_dma)) {
-                        dma_unmap_single(&adapter->vdev->dev,
-                                        adapter->buffer_list_dma, 4096,
+                if (!dma_mapping_error(dev, adapter->buffer_list_dma)) {
+                        dma_unmap_single(dev, adapter->buffer_list_dma, 4096,
                                         DMA_BIDIRECTIONAL);
                         adapter->buffer_list_dma = DMA_ERROR_CODE;
                 }
@@ -461,9 +461,8 @@ static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
         }
 
         if(adapter->filter_list_addr != NULL) {
-                if(!dma_mapping_error(adapter->filter_list_dma)) {
-                        dma_unmap_single(&adapter->vdev->dev,
-                                        adapter->filter_list_dma, 4096,
+                if (!dma_mapping_error(dev, adapter->filter_list_dma)) {
+                        dma_unmap_single(dev, adapter->filter_list_dma, 4096,
                                         DMA_BIDIRECTIONAL);
                         adapter->filter_list_dma = DMA_ERROR_CODE;
                 }
@@ -472,8 +471,8 @@ static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
         }
 
         if(adapter->rx_queue.queue_addr != NULL) {
-                if(!dma_mapping_error(adapter->rx_queue.queue_dma)) {
-                        dma_unmap_single(&adapter->vdev->dev,
+                if (!dma_mapping_error(dev, adapter->rx_queue.queue_dma)) {
+                        dma_unmap_single(dev,
                                         adapter->rx_queue.queue_dma,
                                         adapter->rx_queue.queue_len,
                                         DMA_BIDIRECTIONAL);
@@ -535,6 +534,7 @@ static int ibmveth_open(struct net_device *netdev)
         int rc;
         union ibmveth_buf_desc rxq_desc;
         int i;
+        struct device *dev;
 
         ibmveth_debug_printk("open starting\n");
 
@@ -563,17 +563,19 @@ static int ibmveth_open(struct net_device *netdev)
                 return -ENOMEM;
         }
 
-        adapter->buffer_list_dma = dma_map_single(&adapter->vdev->dev,
+        dev = &adapter->vdev->dev;
+
+        adapter->buffer_list_dma = dma_map_single(dev,
                         adapter->buffer_list_addr, 4096, DMA_BIDIRECTIONAL);
-        adapter->filter_list_dma = dma_map_single(&adapter->vdev->dev,
+        adapter->filter_list_dma = dma_map_single(dev,
                         adapter->filter_list_addr, 4096, DMA_BIDIRECTIONAL);
-        adapter->rx_queue.queue_dma = dma_map_single(&adapter->vdev->dev,
+        adapter->rx_queue.queue_dma = dma_map_single(dev,
                         adapter->rx_queue.queue_addr,
                         adapter->rx_queue.queue_len, DMA_BIDIRECTIONAL);
 
-        if((dma_mapping_error(adapter->buffer_list_dma) ) ||
-           (dma_mapping_error(adapter->filter_list_dma)) ||
-           (dma_mapping_error(adapter->rx_queue.queue_dma))) {
+        if ((dma_mapping_error(dev, adapter->buffer_list_dma)) ||
+            (dma_mapping_error(dev, adapter->filter_list_dma)) ||
+            (dma_mapping_error(dev, adapter->rx_queue.queue_dma))) {
                 ibmveth_error_printk("unable to map filter or buffer list pages\n");
                 ibmveth_cleanup(adapter);
                 napi_disable(&adapter->napi);
@@ -645,7 +647,7 @@ static int ibmveth_open(struct net_device *netdev)
         adapter->bounce_buffer_dma =
             dma_map_single(&adapter->vdev->dev, adapter->bounce_buffer,
                            netdev->mtu + IBMVETH_BUFF_OH, DMA_BIDIRECTIONAL);
-        if (dma_mapping_error(adapter->bounce_buffer_dma)) {
+        if (dma_mapping_error(dev, adapter->bounce_buffer_dma)) {
                 ibmveth_error_printk("unable to map bounce buffer\n");
                 ibmveth_cleanup(adapter);
                 napi_disable(&adapter->napi);
@@ -922,7 +924,7 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                 buf[1] = 0;
         }
 
-        if (dma_mapping_error(data_dma_addr)) {
+        if (dma_mapping_error((&adapter->vdev->dev, data_dma_addr)) {
                 if (!firmware_has_feature(FW_FEATURE_CMO))
                         ibmveth_error_printk("tx: unable to map xmit buffer\n");
                 skb_copy_from_linear_data(skb, adapter->bounce_buffer,
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c
index b8d0639c1cdf..c46864d626b2 100644
--- a/drivers/net/iseries_veth.c
+++ b/drivers/net/iseries_veth.c
@@ -1128,7 +1128,7 @@ static int veth_transmit_to_one(struct sk_buff *skb, HvLpIndex rlp,
         msg->data.addr[0] = dma_map_single(port->dev, skb->data,
                                 skb->len, DMA_TO_DEVICE);
 
-        if (dma_mapping_error(msg->data.addr[0]))
+        if (dma_mapping_error(port->dev, msg->data.addr[0]))
                 goto recycle_and_drop;
 
         msg->dev = port->dev;
@@ -1226,7 +1226,7 @@ static void veth_recycle_msg(struct veth_lpar_connection *cnx,
                 dma_address = msg->data.addr[0];
                 dma_length = msg->data.len[0];
 
-                if (!dma_mapping_error(dma_address))
+                if (!dma_mapping_error(msg->dev, dma_address))
                         dma_unmap_single(msg->dev, dma_address, dma_length,
                                         DMA_TO_DEVICE);
 
diff --git a/drivers/net/mlx4/eq.c b/drivers/net/mlx4/eq.c
index ea3a09aaa844..7df928d3a3d8 100644
--- a/drivers/net/mlx4/eq.c
+++ b/drivers/net/mlx4/eq.c
@@ -526,7 +526,7 @@ int mlx4_map_eq_icm(struct mlx4_dev *dev, u64 icm_virt)
                 return -ENOMEM;
         priv->eq_table.icm_dma  = pci_map_page(dev->pdev, priv->eq_table.icm_page, 0,
                                                PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
-        if (pci_dma_mapping_error(priv->eq_table.icm_dma)) {
+        if (pci_dma_mapping_error(dev->pdev, priv->eq_table.icm_dma)) {
                 __free_page(priv->eq_table.icm_page);
                 return -ENOMEM;
         }
diff --git a/drivers/net/pasemi_mac.c b/drivers/net/pasemi_mac.c
index 993d87c9296f..edc0fd588985 100644
--- a/drivers/net/pasemi_mac.c
+++ b/drivers/net/pasemi_mac.c
@@ -650,7 +650,7 @@ static void pasemi_mac_replenish_rx_ring(const struct net_device *dev,
                                      mac->bufsz - LOCAL_SKB_ALIGN,
                                      PCI_DMA_FROMDEVICE);
 
-                if (unlikely(dma_mapping_error(dma))) {
+                if (unlikely(pci_dma_mapping_error(mac->dma_pdev, dma))) {
                         dev_kfree_skb_irq(info->skb);
                         break;
                 }
@@ -1519,7 +1519,7 @@ static int pasemi_mac_start_tx(struct sk_buff *skb, struct net_device *dev)
         map[0] = pci_map_single(mac->dma_pdev, skb->data, skb_headlen(skb),
                                 PCI_DMA_TODEVICE);
         map_size[0] = skb_headlen(skb);
-        if (dma_mapping_error(map[0]))
+        if (pci_dma_mapping_error(mac->dma_pdev, map[0]))
                 goto out_err_nolock;
 
         for (i = 0; i < nfrags; i++) {
@@ -1529,7 +1529,7 @@ static int pasemi_mac_start_tx(struct sk_buff *skb, struct net_device *dev)
                                         frag->page_offset, frag->size,
                                         PCI_DMA_TODEVICE);
                 map_size[i+1] = frag->size;
-                if (dma_mapping_error(map[i+1])) {
+                if (pci_dma_mapping_error(mac->dma_pdev, map[i+1])) {
                         nfrags = i;
                         goto out_err_nolock;
                 }
diff --git a/drivers/net/qla3xxx.c b/drivers/net/qla3xxx.c
index e7d48a352beb..e82b37bbd6c3 100644
--- a/drivers/net/qla3xxx.c
+++ b/drivers/net/qla3xxx.c
@@ -328,7 +328,7 @@ static void ql_release_to_lrg_buf_free_list(struct ql3_adapter *qdev,
                                              qdev->lrg_buffer_len -
                                              QL_HEADER_SPACE,
                                              PCI_DMA_FROMDEVICE);
-                        err = pci_dma_mapping_error(map);
+                        err = pci_dma_mapping_error(qdev->pdev, map);
                         if(err) {
                                 printk(KERN_ERR "%s: PCI mapping failed with error: %d\n",
                                        qdev->ndev->name, err);
@@ -1919,7 +1919,7 @@ static int ql_populate_free_queue(struct ql3_adapter *qdev)
                                                      QL_HEADER_SPACE,
                                                      PCI_DMA_FROMDEVICE);
 
-                                err = pci_dma_mapping_error(map);
+                                err = pci_dma_mapping_error(qdev->pdev, map);
                                 if(err) {
                                         printk(KERN_ERR "%s: PCI mapping failed with error: %d\n",
                                                qdev->ndev->name, err);
@@ -2454,7 +2454,7 @@ static int ql_send_map(struct ql3_adapter *qdev,
          */
         map = pci_map_single(qdev->pdev, skb->data, len, PCI_DMA_TODEVICE);
 
-        err = pci_dma_mapping_error(map);
+        err = pci_dma_mapping_error(qdev->pdev, map);
         if(err) {
                 printk(KERN_ERR "%s: PCI mapping failed with error: %d\n",
                        qdev->ndev->name, err);
@@ -2487,7 +2487,7 @@ static int ql_send_map(struct ql3_adapter *qdev,
                                                      sizeof(struct oal),
                                                      PCI_DMA_TODEVICE);
 
-                                err = pci_dma_mapping_error(map);
+                                err = pci_dma_mapping_error(qdev->pdev, map);
                                 if(err) {
 
                                         printk(KERN_ERR "%s: PCI mapping outbound address list with error: %d\n",
@@ -2514,7 +2514,7 @@ static int ql_send_map(struct ql3_adapter *qdev,
                                          frag->page_offset, frag->size,
                                          PCI_DMA_TODEVICE);
 
-                        err = pci_dma_mapping_error(map);
+                        err = pci_dma_mapping_error(qdev->pdev, map);
                         if(err) {
                                 printk(KERN_ERR "%s: PCI mapping frags failed with error: %d\n",
                                        qdev->ndev->name, err);
@@ -2916,7 +2916,7 @@ static int ql_alloc_large_buffers(struct ql3_adapter *qdev)
                                              QL_HEADER_SPACE,
                                              PCI_DMA_FROMDEVICE);
 
-                        err = pci_dma_mapping_error(map);
+                        err = pci_dma_mapping_error(qdev->pdev, map);
                         if(err) {
                                 printk(KERN_ERR "%s: PCI mapping failed with error: %d\n",
                                        qdev->ndev->name, err);
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index 9dae40ccf048..86d77d05190a 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -2512,8 +2512,8 @@ static void stop_nic(struct s2io_nic *nic)
  *   Return Value:
  *  SUCCESS on success or an appropriate -ve value on failure.
  */
-
-static int fill_rx_buffers(struct ring_info *ring, int from_card_up)
+static int fill_rx_buffers(struct s2io_nic *nic, struct ring_info *ring,
+                                int from_card_up)
 {
         struct sk_buff *skb;
         struct RxD_t *rxdp;
@@ -2602,7 +2602,8 @@ static int fill_rx_buffers(struct ring_info *ring, int from_card_up)
                         rxdp1->Buffer0_ptr = pci_map_single
                             (ring->pdev, skb->data, size - NET_IP_ALIGN,
                                 PCI_DMA_FROMDEVICE);
-                        if(pci_dma_mapping_error(rxdp1->Buffer0_ptr))
+                        if (pci_dma_mapping_error(nic->pdev,
+                                                rxdp1->Buffer0_ptr))
                                 goto pci_map_failed;
 
                         rxdp->Control_2 =
@@ -2636,7 +2637,8 @@ static int fill_rx_buffers(struct ring_info *ring, int from_card_up)
                                 rxdp3->Buffer0_ptr =
                                    pci_map_single(ring->pdev, ba->ba_0,
                                         BUF0_LEN, PCI_DMA_FROMDEVICE);
-                                if (pci_dma_mapping_error(rxdp3->Buffer0_ptr))
+                        if (pci_dma_mapping_error(nic->pdev,
+                                                rxdp3->Buffer0_ptr))
                                         goto pci_map_failed;
                         } else
                                 pci_dma_sync_single_for_device(ring->pdev,
@@ -2655,7 +2657,8 @@ static int fill_rx_buffers(struct ring_info *ring, int from_card_up)
                                 (ring->pdev, skb->data, ring->mtu + 4,
                                                 PCI_DMA_FROMDEVICE);
 
-                                if (pci_dma_mapping_error(rxdp3->Buffer2_ptr))
+                                if (pci_dma_mapping_error(nic->pdev,
+                                                        rxdp3->Buffer2_ptr))
                                         goto pci_map_failed;
 
                                 if (from_card_up) {
@@ -2664,8 +2667,8 @@ static int fill_rx_buffers(struct ring_info *ring, int from_card_up)
                                                 ba->ba_1, BUF1_LEN,
                                                 PCI_DMA_FROMDEVICE);
 
-                                        if (pci_dma_mapping_error
-                                                (rxdp3->Buffer1_ptr)) {
+                                        if (pci_dma_mapping_error(nic->pdev,
+                                                rxdp3->Buffer1_ptr)) {
                                                 pci_unmap_single
                                                         (ring->pdev,
                                                     (dma_addr_t)(unsigned long)
@@ -2806,9 +2809,9 @@ static void free_rx_buffers(struct s2io_nic *sp)
         }
 }
 
-static int s2io_chk_rx_buffers(struct ring_info *ring)
+static int s2io_chk_rx_buffers(struct s2io_nic *nic, struct ring_info *ring)
 {
-        if (fill_rx_buffers(ring, 0) == -ENOMEM) {
+        if (fill_rx_buffers(nic, ring, 0) == -ENOMEM) {
                 DBG_PRINT(INFO_DBG, "%s:Out of memory", ring->dev->name);
                 DBG_PRINT(INFO_DBG, " in Rx Intr!!\n");
         }
@@ -2848,7 +2851,7 @@ static int s2io_poll_msix(struct napi_struct *napi, int budget)
                 return 0;
 
         pkts_processed = rx_intr_handler(ring, budget);
-        s2io_chk_rx_buffers(ring);
+        s2io_chk_rx_buffers(nic, ring);
 
         if (pkts_processed < budget_org) {
                 netif_rx_complete(dev, napi);
@@ -2882,7 +2885,7 @@ static int s2io_poll_inta(struct napi_struct *napi, int budget)
         for (i = 0; i < config->rx_ring_num; i++) {
                 ring = &mac_control->rings[i];
                 ring_pkts_processed = rx_intr_handler(ring, budget);
-                s2io_chk_rx_buffers(ring);
+                s2io_chk_rx_buffers(nic, ring);
                 pkts_processed += ring_pkts_processed;
                 budget -= ring_pkts_processed;
                 if (budget <= 0)
@@ -2939,7 +2942,8 @@ static void s2io_netpoll(struct net_device *dev)
                 rx_intr_handler(&mac_control->rings[i], 0);
 
         for (i = 0; i < config->rx_ring_num; i++) {
-                if (fill_rx_buffers(&mac_control->rings[i], 0) == -ENOMEM) {
+                if (fill_rx_buffers(nic, &mac_control->rings[i], 0) ==
+                                -ENOMEM) {
                         DBG_PRINT(INFO_DBG, "%s:Out of memory", dev->name);
                         DBG_PRINT(INFO_DBG, " in Rx Netpoll!!\n");
                         break;
@@ -4235,14 +4239,14 @@ static int s2io_xmit(struct sk_buff *skb, struct net_device *dev)
                 txdp->Buffer_Pointer = pci_map_single(sp->pdev,
                                         fifo->ufo_in_band_v,
                                         sizeof(u64), PCI_DMA_TODEVICE);
-                if (pci_dma_mapping_error(txdp->Buffer_Pointer))
+                if (pci_dma_mapping_error(sp->pdev, txdp->Buffer_Pointer))
                         goto pci_map_failed;
                 txdp++;
         }
 
         txdp->Buffer_Pointer = pci_map_single
             (sp->pdev, skb->data, frg_len, PCI_DMA_TODEVICE);
-        if (pci_dma_mapping_error(txdp->Buffer_Pointer))
+        if (pci_dma_mapping_error(sp->pdev, txdp->Buffer_Pointer))
                 goto pci_map_failed;
 
         txdp->Host_Control = (unsigned long) skb;
@@ -4345,7 +4349,7 @@ static irqreturn_t s2io_msix_ring_handle(int irq, void *dev_id)
                 netif_rx_schedule(dev, &ring->napi);
         } else {
                 rx_intr_handler(ring, 0);
-                s2io_chk_rx_buffers(ring);
+                s2io_chk_rx_buffers(sp, ring);
         }
 
         return IRQ_HANDLED;
@@ -4826,7 +4830,7 @@ static irqreturn_t s2io_isr(int irq, void *dev_id)
                  */
                 if (!config->napi) {
                         for (i = 0; i < config->rx_ring_num; i++)
-                                s2io_chk_rx_buffers(&mac_control->rings[i]);
+                                s2io_chk_rx_buffers(sp, &mac_control->rings[i]);
                 }
                 writeq(sp->general_int_mask, &bar0->general_int_mask);
                 readl(&bar0->general_int_status);
@@ -6859,7 +6863,7 @@ static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp,
                                 pci_map_single( sp->pdev, (*skb)->data,
                                         size - NET_IP_ALIGN,
                                         PCI_DMA_FROMDEVICE);
-                        if (pci_dma_mapping_error(rxdp1->Buffer0_ptr))
+                        if (pci_dma_mapping_error(sp->pdev, rxdp1->Buffer0_ptr))
                                 goto memalloc_failed;
                         rxdp->Host_Control = (unsigned long) (*skb);
                 }
@@ -6886,12 +6890,13 @@ static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp,
                                 pci_map_single(sp->pdev, (*skb)->data,
                                                dev->mtu + 4,
                                                PCI_DMA_FROMDEVICE);
-                        if (pci_dma_mapping_error(rxdp3->Buffer2_ptr))
+                        if (pci_dma_mapping_error(sp->pdev, rxdp3->Buffer2_ptr))
                                 goto memalloc_failed;
                         rxdp3->Buffer0_ptr = *temp0 =
                                 pci_map_single( sp->pdev, ba->ba_0, BUF0_LEN,
                                                 PCI_DMA_FROMDEVICE);
-                        if (pci_dma_mapping_error(rxdp3->Buffer0_ptr)) {
+                        if (pci_dma_mapping_error(sp->pdev,
+                                                rxdp3->Buffer0_ptr)) {
                                 pci_unmap_single (sp->pdev,
                                         (dma_addr_t)rxdp3->Buffer2_ptr,
                                         dev->mtu + 4, PCI_DMA_FROMDEVICE);
@@ -6903,7 +6908,8 @@ static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp,
                         rxdp3->Buffer1_ptr = *temp1 =
                                 pci_map_single(sp->pdev, ba->ba_1, BUF1_LEN,
                                                 PCI_DMA_FROMDEVICE);
-                        if (pci_dma_mapping_error(rxdp3->Buffer1_ptr)) {
+                        if (pci_dma_mapping_error(sp->pdev,
+                                                rxdp3->Buffer1_ptr)) {
                                 pci_unmap_single (sp->pdev,
                                         (dma_addr_t)rxdp3->Buffer0_ptr,
                                         BUF0_LEN, PCI_DMA_FROMDEVICE);
@@ -7187,7 +7193,7 @@ static int s2io_card_up(struct s2io_nic * sp)
 
         for (i = 0; i < config->rx_ring_num; i++) {
                 mac_control->rings[i].mtu = dev->mtu;
-                ret = fill_rx_buffers(&mac_control->rings[i], 1);
+                ret = fill_rx_buffers(sp, &mac_control->rings[i], 1);
                 if (ret) {
                         DBG_PRINT(ERR_DBG, "%s: Out of memory in Open\n",
                                   dev->name);
diff --git a/drivers/net/sfc/rx.c b/drivers/net/sfc/rx.c
index 601b001437c0..0d27dd39bc09 100644
--- a/drivers/net/sfc/rx.c
+++ b/drivers/net/sfc/rx.c
@@ -233,7 +233,7 @@ static inline int efx_init_rx_buffer_skb(struct efx_rx_queue *rx_queue,
                                           rx_buf->data, rx_buf->len,
                                           PCI_DMA_FROMDEVICE);
 
-        if (unlikely(pci_dma_mapping_error(rx_buf->dma_addr))) {
+        if (unlikely(pci_dma_mapping_error(efx->pci_dev, rx_buf->dma_addr))) {
                 dev_kfree_skb_any(rx_buf->skb);
                 rx_buf->skb = NULL;
                 return -EIO;
@@ -275,7 +275,7 @@ static inline int efx_init_rx_buffer_page(struct efx_rx_queue *rx_queue,
                                         0, efx_rx_buf_size(efx),
                                         PCI_DMA_FROMDEVICE);
 
-                if (unlikely(pci_dma_mapping_error(dma_addr))) {
+                if (unlikely(pci_dma_mapping_error(efx->pci_dev, dma_addr))) {
                         __free_pages(rx_buf->page, efx->rx_buffer_order);
                         rx_buf->page = NULL;
                         return -EIO;
diff --git a/drivers/net/sfc/tx.c b/drivers/net/sfc/tx.c
index 5cdd082ab8f6..5e8374ab28ee 100644
--- a/drivers/net/sfc/tx.c
+++ b/drivers/net/sfc/tx.c
@@ -172,7 +172,7 @@ static inline int efx_enqueue_skb(struct efx_tx_queue *tx_queue,
 
         /* Process all fragments */
         while (1) {
-                if (unlikely(pci_dma_mapping_error(dma_addr)))
+                if (unlikely(pci_dma_mapping_error(pci_dev, dma_addr)))
                         goto pci_err;
 
                 /* Store fields for marking in the per-fragment final
@@ -661,7 +661,8 @@ efx_tsoh_heap_alloc(struct efx_tx_queue *tx_queue, size_t header_len)
         tsoh->dma_addr = pci_map_single(tx_queue->efx->pci_dev,
                                         TSOH_BUFFER(tsoh), header_len,
                                         PCI_DMA_TODEVICE);
-        if (unlikely(pci_dma_mapping_error(tsoh->dma_addr))) {
+        if (unlikely(pci_dma_mapping_error(tx_queue->efx->pci_dev,
+                                           tsoh->dma_addr))) {
                 kfree(tsoh);
                 return NULL;
         }
@@ -863,7 +864,7 @@ static inline int tso_get_fragment(struct tso_state *st, struct efx_nic *efx,
 
         st->ifc.unmap_addr = pci_map_page(efx->pci_dev, page, page_off,
                                           len, PCI_DMA_TODEVICE);
-        if (likely(!pci_dma_mapping_error(st->ifc.unmap_addr))) {
+        if (likely(!pci_dma_mapping_error(efx->pci_dev, st->ifc.unmap_addr))) {
                 st->ifc.unmap_len = len;
                 st->ifc.len = len;
                 st->ifc.dma_addr = st->ifc.unmap_addr;
diff --git a/drivers/net/spider_net.c b/drivers/net/spider_net.c
index 00aa0b108cb9..b6435d0d71f9 100644
--- a/drivers/net/spider_net.c
+++ b/drivers/net/spider_net.c
@@ -452,7 +452,7 @@ spider_net_prepare_rx_descr(struct spider_net_card *card,
         /* iommu-map the skb */
         buf = pci_map_single(card->pdev, descr->skb->data,
                         SPIDER_NET_MAX_FRAME, PCI_DMA_FROMDEVICE);
-        if (pci_dma_mapping_error(buf)) {
+        if (pci_dma_mapping_error(card->pdev, buf)) {
                 dev_kfree_skb_any(descr->skb);
                 descr->skb = NULL;
                 if (netif_msg_rx_err(card) && net_ratelimit())
@@ -691,7 +691,7 @@ spider_net_prepare_tx_descr(struct spider_net_card *card,
         unsigned long flags;
 
         buf = pci_map_single(card->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
-        if (pci_dma_mapping_error(buf)) {
+        if (pci_dma_mapping_error(card->pdev, buf)) {
                 if (netif_msg_tx_err(card) && net_ratelimit())
                         dev_err(&card->netdev->dev, "could not iommu-map packet (%p, %i). "
                                   "Dropping packet\n", skb->data, skb->len);
diff --git a/drivers/net/tc35815.c b/drivers/net/tc35815.c
index a645e5028c14..8487ace9d2e3 100644
--- a/drivers/net/tc35815.c
+++ b/drivers/net/tc35815.c
@@ -506,7 +506,7 @@ static void *alloc_rxbuf_page(struct pci_dev *hwdev, dma_addr_t *dma_handle)
                 return NULL;
         *dma_handle = pci_map_single(hwdev, buf, PAGE_SIZE,
                                      PCI_DMA_FROMDEVICE);
-        if (pci_dma_mapping_error(*dma_handle)) {
+        if (pci_dma_mapping_error(hwdev, *dma_handle)) {
                 free_page((unsigned long)buf);
                 return NULL;
         }
@@ -536,7 +536,7 @@ static struct sk_buff *alloc_rxbuf_skb(struct net_device *dev,
                 return NULL;
         *dma_handle = pci_map_single(hwdev, skb->data, RX_BUF_SIZE,
                                      PCI_DMA_FROMDEVICE);
-        if (pci_dma_mapping_error(*dma_handle)) {
+        if (pci_dma_mapping_error(hwdev, *dma_handle)) {
                 dev_kfree_skb_any(skb);
                 return NULL;
         }
diff --git a/drivers/net/wireless/ath5k/base.c b/drivers/net/wireless/ath5k/base.c
index 217d506527a9..d9769c527346 100644
--- a/drivers/net/wireless/ath5k/base.c
+++ b/drivers/net/wireless/ath5k/base.c
@@ -1166,7 +1166,7 @@ ath5k_rxbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf)
                 bf->skb = skb;
                 bf->skbaddr = pci_map_single(sc->pdev,
                         skb->data, sc->rxbufsize, PCI_DMA_FROMDEVICE);
-                if (unlikely(pci_dma_mapping_error(bf->skbaddr))) {
+                if (unlikely(pci_dma_mapping_error(sc->pdev, bf->skbaddr))) {
                         ATH5K_ERR(sc, "%s: DMA mapping failed\n", __func__);
                         dev_kfree_skb(skb);
                         bf->skb = NULL;
@@ -1918,7 +1918,7 @@ ath5k_beacon_setup(struct ath5k_softc *sc, struct ath5k_buf *bf)
         ATH5K_DBG(sc, ATH5K_DEBUG_BEACON, "skb %p [data %p len %u] "
                         "skbaddr %llx\n", skb, skb->data, skb->len,
                         (unsigned long long)bf->skbaddr);
-        if (pci_dma_mapping_error(bf->skbaddr)) {
+        if (pci_dma_mapping_error(sc->pdev, bf->skbaddr)) {
                 ATH5K_ERR(sc, "beacon DMA mapping failed\n");
                 return -EIO;
         }
diff --git a/drivers/parport/ieee1284.c b/drivers/parport/ieee1284.c
index 0338b0912674..e97059415ab4 100644
--- a/drivers/parport/ieee1284.c
+++ b/drivers/parport/ieee1284.c
@@ -199,8 +199,6 @@ int parport_wait_peripheral(struct parport *port,
         /* 40ms of slow polling. */
         deadline = jiffies + msecs_to_jiffies(40);
         while (time_before (jiffies, deadline)) {
-                int ret;
-
                 if (signal_pending (current))
                         return -EINTR;
 
diff --git a/drivers/parport/parport_cs.c b/drivers/parport/parport_cs.c
index 802a81d47367..00e1d9620f7c 100644
--- a/drivers/parport/parport_cs.c
+++ b/drivers/parport/parport_cs.c
@@ -235,7 +235,7 @@ failed:
     
 ======================================================================*/
 
-void parport_cs_release(struct pcmcia_device *link)
+static void parport_cs_release(struct pcmcia_device *link)
 {
         parport_info_t *info = link->priv;
 
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index e0c2a4584ec6..8a846adf1dcf 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -2867,7 +2867,7 @@ static struct parport_pc_pci {
          * and 840 locks up if you write 1 to bit 2! */
         /* oxsemi_952 */                { 1, { { 0, 1 }, } },
         /* oxsemi_954 */                { 1, { { 0, -1 }, } },
-        /* oxsemi_840 */                { 1, { { 0, -1 }, } },
+        /* oxsemi_840 */                { 1, { { 0, 1 }, } },
         /* aks_0100 */                  { 1, { { 0, -1 }, } },
         /* mobility_pp */               { 1, { { 0, 1 }, } },
         /* netmos_9705 */               { 1, { { 0, -1 }, } }, /* untested */
diff --git a/drivers/parport/procfs.c b/drivers/parport/procfs.c
index d950fc34320a..554e11f9e1ce 100644
--- a/drivers/parport/procfs.c
+++ b/drivers/parport/procfs.c
@@ -429,9 +429,6 @@ struct parport_default_sysctl_table
         ctl_table dev_dir[2];
 };
 
-extern unsigned long parport_default_timeslice;
-extern int parport_default_spintime;
-
 static struct parport_default_sysctl_table
 parport_default_sysctl_table = {
         .sysctl_header  = NULL,
diff --git a/drivers/pnp/base.h b/drivers/pnp/base.h
index e3fa9a2d9a3d..9fd7bb9b7dce 100644
--- a/drivers/pnp/base.h
+++ b/drivers/pnp/base.h
@@ -19,7 +19,6 @@ struct pnp_id *pnp_add_id(struct pnp_dev *dev, char *id);
 int pnp_interface_attach_device(struct pnp_dev *dev);
 
 int pnp_add_card(struct pnp_card *card);
-struct pnp_id *pnp_add_card_id(struct pnp_card *card, char *id);
 void pnp_remove_card(struct pnp_card *card);
 int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev);
 void pnp_remove_card_device(struct pnp_dev *dev);
diff --git a/drivers/pnp/card.c b/drivers/pnp/card.c
index a762a4176736..e75b060daa95 100644
--- a/drivers/pnp/card.c
+++ b/drivers/pnp/card.c
@@ -8,6 +8,7 @@
 #include <linux/ctype.h>
 #include <linux/slab.h>
 #include <linux/pnp.h>
+#include <linux/dma-mapping.h>
 #include "base.h"
 
 LIST_HEAD(pnp_cards);
@@ -101,7 +102,7 @@ static int card_probe(struct pnp_card *card, struct pnp_card_driver *drv)
  * @id: pointer to a pnp_id structure
  * @card: pointer to the desired card
  */
-struct pnp_id *pnp_add_card_id(struct pnp_card *card, char *id)
+static struct pnp_id *pnp_add_card_id(struct pnp_card *card, char *id)
 {
         struct pnp_id *dev_id, *ptr;
 
@@ -167,6 +168,9 @@ struct pnp_card *pnp_alloc_card(struct pnp_protocol *protocol, int id, char *pnp
         sprintf(card->dev.bus_id, "%02x:%02x", card->protocol->number,
                 card->number);
 
+        card->dev.coherent_dma_mask = DMA_24BIT_MASK;
+        card->dev.dma_mask = &card->dev.coherent_dma_mask;
+
         dev_id = pnp_add_card_id(card, pnpid);
         if (!dev_id) {
                 kfree(card);
diff --git a/drivers/pnp/quirks.c b/drivers/pnp/quirks.c
index 55f55ed72dc7..0bdf9b8a5e58 100644
--- a/drivers/pnp/quirks.c
+++ b/drivers/pnp/quirks.c
@@ -245,15 +245,17 @@ static void quirk_system_pci_resources(struct pnp_dev *dev)
          */
         for_each_pci_dev(pdev) {
                 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
-                        if (!(pci_resource_flags(pdev, i) & IORESOURCE_MEM) ||
-                            pci_resource_len(pdev, i) == 0)
+                        unsigned int type;
+
+                        type = pci_resource_flags(pdev, i) &
+                                        (IORESOURCE_IO | IORESOURCE_MEM);
+                        if (!type || pci_resource_len(pdev, i) == 0)
                                 continue;
 
                         pci_start = pci_resource_start(pdev, i);
                         pci_end = pci_resource_end(pdev, i);
                         for (j = 0;
-                             (res = pnp_get_resource(dev, IORESOURCE_MEM, j));
-                             j++) {
+                             (res = pnp_get_resource(dev, type, j)); j++) {
                                 if (res->start == 0 && res->end == 0)
                                         continue;
 
@@ -283,9 +285,10 @@ static void quirk_system_pci_resources(struct pnp_dev *dev)
                                  * the PCI region, and that might prevent a PCI
                                  * driver from requesting its resources.
                                  */
-                                dev_warn(&dev->dev, "mem resource "
+                                dev_warn(&dev->dev, "%s resource "
                                         "(0x%llx-0x%llx) overlaps %s BAR %d "
                                         "(0x%llx-0x%llx), disabling\n",
+                                        pnp_resource_type_name(res),
                                         (unsigned long long) pnp_start,
                                         (unsigned long long) pnp_end,
                                         pci_name(pdev), i,
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index c4a7c06793c5..61f8fdea2d96 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -3525,7 +3525,7 @@ static int ibmvfc_init_crq(struct ibmvfc_host *vhost)
         crq->msg_token = dma_map_single(dev, crq->msgs,
                                         PAGE_SIZE, DMA_BIDIRECTIONAL);
 
-        if (dma_mapping_error(crq->msg_token))
+        if (dma_mapping_error(dev, crq->msg_token))
                 goto map_failed;
 
         retrc = rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
@@ -3618,7 +3618,7 @@ static int ibmvfc_alloc_mem(struct ibmvfc_host *vhost)
                                             async_q->size * sizeof(*async_q->msgs),
                                             DMA_BIDIRECTIONAL);
 
-        if (dma_mapping_error(async_q->msg_token)) {
+        if (dma_mapping_error(dev, async_q->msg_token)) {
                 dev_err(dev, "Failed to map async queue\n");
                 goto free_async_crq;
         }
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 20000ec79b04..6b24b9cdb04c 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -859,7 +859,7 @@ static void send_mad_adapter_info(struct ibmvscsi_host_data *hostdata)
                                             sizeof(hostdata->madapter_info),
                                             DMA_BIDIRECTIONAL);
 
-        if (dma_mapping_error(req->buffer)) {
+        if (dma_mapping_error(hostdata->dev, req->buffer)) {
                 if (!firmware_has_feature(FW_FEATURE_CMO))
                         dev_err(hostdata->dev,
                                 "Unable to map request_buffer for "
@@ -1407,7 +1407,7 @@ static int ibmvscsi_do_host_config(struct ibmvscsi_host_data *hostdata,
                                                     length,
                                                     DMA_BIDIRECTIONAL);
 
-        if (dma_mapping_error(host_config->buffer)) {
+        if (dma_mapping_error(hostdata->dev, host_config->buffer)) {
                 if (!firmware_has_feature(FW_FEATURE_CMO))
                         dev_err(hostdata->dev,
                                 "dma_mapping error getting host config\n");
diff --git a/drivers/scsi/ibmvscsi/ibmvstgt.c b/drivers/scsi/ibmvscsi/ibmvstgt.c
index 3b9514c8f1f1..2e13ec00172a 100644
--- a/drivers/scsi/ibmvscsi/ibmvstgt.c
+++ b/drivers/scsi/ibmvscsi/ibmvstgt.c
@@ -564,7 +564,7 @@ static int crq_queue_create(struct crq_queue *queue, struct srp_target *target)
                                           queue->size * sizeof(*queue->msgs),
                                           DMA_BIDIRECTIONAL);
 
-        if (dma_mapping_error(queue->msg_token))
+        if (dma_mapping_error(target->dev, queue->msg_token))
                 goto map_failed;
 
         err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token,
diff --git a/drivers/scsi/ibmvscsi/rpa_vscsi.c b/drivers/scsi/ibmvscsi/rpa_vscsi.c
index 182146100dc1..462a8574dad9 100644
--- a/drivers/scsi/ibmvscsi/rpa_vscsi.c
+++ b/drivers/scsi/ibmvscsi/rpa_vscsi.c
@@ -253,7 +253,7 @@ static int rpavscsi_init_crq_queue(struct crq_queue *queue,
                                           queue->size * sizeof(*queue->msgs),
                                           DMA_BIDIRECTIONAL);
 
-        if (dma_mapping_error(queue->msg_token))
+        if (dma_mapping_error(hostdata->dev, queue->msg_token))
                 goto map_failed;
 
         gather_partition_info();
diff --git a/drivers/spi/atmel_spi.c b/drivers/spi/atmel_spi.c
index e81d59d78910..0c7165660853 100644
--- a/drivers/spi/atmel_spi.c
+++ b/drivers/spi/atmel_spi.c
@@ -313,14 +313,14 @@ atmel_spi_dma_map_xfer(struct atmel_spi *as, struct spi_transfer *xfer)
                 xfer->tx_dma = dma_map_single(dev,
                                 (void *) xfer->tx_buf, xfer->len,
                                 DMA_TO_DEVICE);
-                if (dma_mapping_error(xfer->tx_dma))
+                if (dma_mapping_error(dev, xfer->tx_dma))
                         return -ENOMEM;
         }
         if (xfer->rx_buf) {
                 xfer->rx_dma = dma_map_single(dev,
                                 xfer->rx_buf, xfer->len,
                                 DMA_FROM_DEVICE);
-                if (dma_mapping_error(xfer->rx_dma)) {
+                if (dma_mapping_error(dev, xfer->rx_dma)) {
                         if (xfer->tx_buf)
                                 dma_unmap_single(dev,
                                                 xfer->tx_dma, xfer->len,
diff --git a/drivers/spi/au1550_spi.c b/drivers/spi/au1550_spi.c
index 9149689c79d9..87b73e0169c5 100644
--- a/drivers/spi/au1550_spi.c
+++ b/drivers/spi/au1550_spi.c
@@ -334,7 +334,7 @@ static int au1550_spi_dma_rxtmp_alloc(struct au1550_spi *hw, unsigned size)
         hw->dma_rx_tmpbuf_size = size;
         hw->dma_rx_tmpbuf_addr = dma_map_single(hw->dev, hw->dma_rx_tmpbuf,
                         size, DMA_FROM_DEVICE);
-        if (dma_mapping_error(hw->dma_rx_tmpbuf_addr)) {
+        if (dma_mapping_error(hw->dev, hw->dma_rx_tmpbuf_addr)) {
                 kfree(hw->dma_rx_tmpbuf);
                 hw->dma_rx_tmpbuf = 0;
                 hw->dma_rx_tmpbuf_size = 0;
@@ -378,7 +378,7 @@ static int au1550_spi_dma_txrxb(struct spi_device *spi, struct spi_transfer *t)
                         dma_rx_addr = dma_map_single(hw->dev,
                                         (void *)t->rx_buf,
                                         t->len, DMA_FROM_DEVICE);
-                        if (dma_mapping_error(dma_rx_addr))
+                        if (dma_mapping_error(hw->dev, dma_rx_addr))
                                 dev_err(hw->dev, "rx dma map error\n");
                 }
         } else {
@@ -401,7 +401,7 @@ static int au1550_spi_dma_txrxb(struct spi_device *spi, struct spi_transfer *t)
                         dma_tx_addr = dma_map_single(hw->dev,
                                         (void *)t->tx_buf,
                                         t->len, DMA_TO_DEVICE);
-                        if (dma_mapping_error(dma_tx_addr))
+                        if (dma_mapping_error(hw->dev, dma_tx_addr))
                                 dev_err(hw->dev, "tx dma map error\n");
                 }
         } else {
diff --git a/drivers/spi/omap2_mcspi.c b/drivers/spi/omap2_mcspi.c
index b1cc148036c1..f6f987bb71ca 100644
--- a/drivers/spi/omap2_mcspi.c
+++ b/drivers/spi/omap2_mcspi.c
@@ -836,7 +836,7 @@ static int omap2_mcspi_transfer(struct spi_device *spi, struct spi_message *m)
                 if (tx_buf != NULL) {
                         t->tx_dma = dma_map_single(&spi->dev, (void *) tx_buf,
                                         len, DMA_TO_DEVICE);
-                        if (dma_mapping_error(t->tx_dma)) {
+                        if (dma_mapping_error(&spi->dev, t->tx_dma)) {
                                 dev_dbg(&spi->dev, "dma %cX %d bytes error\n",
                                                 'T', len);
                                 return -EINVAL;
@@ -845,7 +845,7 @@ static int omap2_mcspi_transfer(struct spi_device *spi, struct spi_message *m)
                 if (rx_buf != NULL) {
                         t->rx_dma = dma_map_single(&spi->dev, rx_buf, t->len,
                                         DMA_FROM_DEVICE);
-                        if (dma_mapping_error(t->rx_dma)) {
+                        if (dma_mapping_error(&spi->dev, t->rx_dma)) {
                                 dev_dbg(&spi->dev, "dma %cX %d bytes error\n",
                                                 'R', len);
                                 if (tx_buf != NULL)
diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index 0c452c46ab07..067299d6d192 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -353,7 +353,7 @@ static int map_dma_buffers(struct driver_data *drv_data)
         drv_data->rx_dma = dma_map_single(dev, drv_data->rx,
                                                 drv_data->rx_map_len,
                                                 DMA_FROM_DEVICE);
-        if (dma_mapping_error(drv_data->rx_dma))
+        if (dma_mapping_error(dev, drv_data->rx_dma))
                 return 0;
 
         /* Stream map the tx buffer */
@@ -361,7 +361,7 @@ static int map_dma_buffers(struct driver_data *drv_data)
                                                 drv_data->tx_map_len,
                                                 DMA_TO_DEVICE);
 
-        if (dma_mapping_error(drv_data->tx_dma)) {
+        if (dma_mapping_error(dev, drv_data->tx_dma)) {
                 dma_unmap_single(dev, drv_data->rx_dma,
                                         drv_data->rx_map_len, DMA_FROM_DEVICE);
                 return 0;
diff --git a/drivers/spi/spi_imx.c b/drivers/spi/spi_imx.c
index 54ac7bea5f8c..6fb77fcc4971 100644
--- a/drivers/spi/spi_imx.c
+++ b/drivers/spi/spi_imx.c
@@ -491,7 +491,7 @@ static int map_dma_buffers(struct driver_data *drv_data)
                                                         buf,
                                                         drv_data->tx_map_len,
                                                         DMA_TO_DEVICE);
-                        if (dma_mapping_error(drv_data->tx_dma))
+                        if (dma_mapping_error(dev, drv_data->tx_dma))
                                 return -1;
 
                         drv_data->tx_dma_needs_unmap = 1;
@@ -516,7 +516,7 @@ static int map_dma_buffers(struct driver_data *drv_data)
                                         buf,
                                         drv_data->len,
                                         DMA_FROM_DEVICE);
-                if (dma_mapping_error(drv_data->rx_dma))
+                if (dma_mapping_error(dev, drv_data->rx_dma))
                         return -1;
                 drv_data->rx_dma_needs_unmap = 1;
         }
@@ -534,7 +534,7 @@ static int map_dma_buffers(struct driver_data *drv_data)
                                         buf,
                                         drv_data->tx_map_len,
                                         DMA_TO_DEVICE);
-        if (dma_mapping_error(drv_data->tx_dma)) {
+        if (dma_mapping_error(dev, drv_data->tx_dma)) {
                 if (drv_data->rx_dma) {
                         dma_unmap_single(dev,
                                         drv_data->rx_dma,
diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c
index 5e3e4e9b6c77..1f715436d6d3 100644
--- a/drivers/usb/mon/mon_text.c
+++ b/drivers/usb/mon/mon_text.c
@@ -87,7 +87,7 @@ struct mon_reader_text {
 
 static struct dentry *mon_dir;          /* Usually /sys/kernel/debug/usbmon */
 
-static void mon_text_ctor(struct kmem_cache *, void *);
+static void mon_text_ctor(void *);
 
 struct mon_text_ptr {
         int cnt, limit;
@@ -720,7 +720,7 @@ void mon_text_del(struct mon_bus *mbus)
 /*
  * Slab interface: constructor.
  */
-static void mon_text_ctor(struct kmem_cache *slab, void *mem)
+static void mon_text_ctor(void *mem)
 {
         /*
          * Nothing to initialize. No, really!
diff --git a/drivers/video/console/sticon.c b/drivers/video/console/sticon.c
index a11cc2fdd4cd..4055dbdd1b42 100644
--- a/drivers/video/console/sticon.c
+++ b/drivers/video/console/sticon.c
@@ -370,7 +370,7 @@ static const struct consw sti_con = {
 
 
 
-int __init sticonsole_init(void)
+static int __init sticonsole_init(void)
 {
     /* already initialized ? */
     if (sticon_sti)
diff --git a/drivers/video/console/sticore.c b/drivers/video/console/sticore.c
index e9ab657f0bb7..d7822af0e00a 100644
--- a/drivers/video/console/sticore.c
+++ b/drivers/video/console/sticore.c
@@ -29,7 +29,7 @@
 
 #define STI_DRIVERVERSION "Version 0.9a"
 
-struct sti_struct *default_sti __read_mostly;
+static struct sti_struct *default_sti __read_mostly;
 
 /* number of STI ROMS found and their ptrs to each struct */
 static int num_sti_roms __read_mostly;
@@ -68,8 +68,7 @@ static const struct sti_init_flags default_init_flags = {
         .init_cmap_tx = 1,
 };
 
-int
-sti_init_graph(struct sti_struct *sti) 
+static int sti_init_graph(struct sti_struct *sti)
 {
         struct sti_init_inptr_ext inptr_ext = { 0, };
         struct sti_init_inptr inptr = {
@@ -100,8 +99,7 @@ static const struct sti_conf_flags default_conf_flags = {
         .wait   = STI_WAIT,
 };
 
-void
-sti_inq_conf(struct sti_struct *sti)
+static void sti_inq_conf(struct sti_struct *sti)
 {
         struct sti_conf_inptr inptr = { 0, };
         unsigned long flags;
@@ -237,8 +235,8 @@ static void sti_flush(unsigned long start, unsigned long end)
         flush_icache_range(start, end);
 }
 
-void __devinit
-sti_rom_copy(unsigned long base, unsigned long count, void *dest)
+static void __devinit sti_rom_copy(unsigned long base, unsigned long count,
+                                   void *dest)
 {
         unsigned long dest_start = (unsigned long) dest;
 
@@ -478,8 +476,8 @@ sti_init_glob_cfg(struct sti_struct *sti,
 }
 
 #ifdef CONFIG_FB
-struct sti_cooked_font * __devinit
-sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
+static struct sti_cooked_font __devinit
+*sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
 {
         const struct font_desc *fbfont;
         unsigned int size, bpc;
@@ -534,16 +532,16 @@ sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
         return cooked_font;
 }
 #else
-struct sti_cooked_font * __devinit
-sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
+static struct sti_cooked_font __devinit
+*sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
 {
         return NULL;
 }
 #endif
 
-struct sti_cooked_font * __devinit
-sti_select_font(struct sti_cooked_rom *rom,
-            int (*search_font_fnc) (struct sti_cooked_rom *,int,int) )
+static struct sti_cooked_font __devinit
+*sti_select_font(struct sti_cooked_rom *rom,
+                 int (*search_font_fnc)(struct sti_cooked_rom *, int, int))
 {
         struct sti_cooked_font *font;
         int i;
@@ -707,8 +705,7 @@ sti_get_bmode_rom (unsigned long address)
         return raw;
 }
 
-struct sti_rom * __devinit
-sti_get_wmode_rom (unsigned long address)
+static struct sti_rom __devinit *sti_get_wmode_rom(unsigned long address)
 {
         struct sti_rom *raw;
         unsigned long size;
@@ -723,8 +720,8 @@ sti_get_wmode_rom (unsigned long address)
         return raw;
 }
 
-int __devinit
-sti_read_rom(int wordmode, struct sti_struct *sti, unsigned long address)
+static int __devinit sti_read_rom(int wordmode, struct sti_struct *sti,
+                                  unsigned long address)
 {
         struct sti_cooked_rom *cooked;
         struct sti_rom *raw = NULL;
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 5d84b3431098..6b487801eeae 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -35,7 +35,6 @@
 #include <linux/device.h>
 #include <linux/efi.h>
 #include <linux/fb.h>
-#include <linux/major.h>
 
 #include <asm/fb.h>
 
diff --git a/drivers/video/macfb.c b/drivers/video/macfb.c
index aa8c714d6245..b790ddff76f9 100644
--- a/drivers/video/macfb.c
+++ b/drivers/video/macfb.c
@@ -596,7 +596,7 @@ static struct fb_ops macfb_ops = {
         .fb_imageblit   = cfb_imageblit,
 };
 
-void __init macfb_setup(char *options)
+static void __init macfb_setup(char *options)
 {
         char *this_opt;
         
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index 2b707a8ce5de..69de2fed6c58 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -1336,7 +1336,7 @@ static int __devinit pxafb_map_video_memory(struct pxafb_info *fbi)
                 fbi->dma_buff_phys = fbi->map_dma;
                 fbi->palette_cpu = (u16 *) fbi->dma_buff->palette;
 
-                pr_debug("pxafb: palette_mem_size = 0x%08lx\n", fbi->palette_size*sizeof(u16));
+                pr_debug("pxafb: palette_mem_size = 0x%08x\n", fbi->palette_size*sizeof(u16));
 
 #ifdef CONFIG_FB_PXA_SMARTPANEL
                 fbi->smart_cmds = (uint16_t *) fbi->dma_buff->cmd_buff;
diff --git a/drivers/video/sticore.h b/drivers/video/sticore.h
index 1a9a60c74be3..7fe5be4bc70e 100644
--- a/drivers/video/sticore.h
+++ b/drivers/video/sticore.h
@@ -352,8 +352,6 @@ struct sti_struct *sti_get_rom(unsigned int index); /* 0: default sti */
 
 /* functions to call the STI ROM directly */
 
-int  sti_init_graph(struct sti_struct *sti);
-void sti_inq_conf(struct sti_struct *sti);
 void sti_putc(struct sti_struct *sti, int c, int y, int x);
 void sti_set(struct sti_struct *sti, int src_y, int src_x,
              int height, int width, u8 color);
diff --git a/drivers/video/stifb.c b/drivers/video/stifb.c
index 598d35eff935..166481402412 100644
--- a/drivers/video/stifb.c
+++ b/drivers/video/stifb.c
@@ -1078,8 +1078,7 @@ static struct fb_ops stifb_ops = {
  *  Initialization
  */
 
-int __init
-stifb_init_fb(struct sti_struct *sti, int bpp_pref)
+static int __init stifb_init_fb(struct sti_struct *sti, int bpp_pref)
 {
         struct fb_fix_screeninfo *fix;
         struct fb_var_screeninfo *var;
@@ -1315,8 +1314,7 @@ static int stifb_disabled __initdata;
 int __init
 stifb_setup(char *options);
 
-int __init
-stifb_init(void)
+static int __init stifb_init(void)
 {
         struct sti_struct *sti;
         struct sti_struct *def_sti;