65 files changed, 2446 insertions, 1219 deletions
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 368ae6d3a096..a2b902f4d437 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -96,8 +96,6 @@ source "drivers/edac/Kconfig"
 source "drivers/rtc/Kconfig"
-source "drivers/clocksource/Kconfig"
 source "drivers/dma/Kconfig"
 source "drivers/dca/Kconfig"
diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig
deleted file mode 100644
index 08f726c5fee5..000000000000
--- a/drivers/clocksource/Kconfig
+++ /dev/null
@@ -1,9 +0,0 @@
-config CS5535_CLOCK_EVENT_SRC
-        tristate "CS5535/CS5536 high-res timer (MFGPT) events"
-        depends on GENERIC_TIME && GENERIC_CLOCKEVENTS && CS5535_MFGPT
-        help
-          This driver provides a clock event source based on the MFGPT
-          timer(s) in the CS5535 and CS5536 companion chips.
-          MFGPTs have a better resolution and max interval than the
-          generic PIT, and are suitable for use as high-res timers.
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index 73655aeb3a60..1aea7157d8ff 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -100,8 +100,8 @@ struct menu_device {
        int             needs_update;
        unsigned int    expected_us;
-        u64             predicted_us;
        unsigned int    measured_us;
+        u64             predicted_us;
        unsigned int    exit_us;
        unsigned int    bucket;
        u64             correction_factor[BUCKETS];
diff --git a/drivers/dma/ioat/dma.c b/drivers/dma/ioat/dma.c
index 5d0e42b263df..af14c9a5b8d4 100644
--- a/drivers/dma/ioat/dma.c
+++ b/drivers/dma/ioat/dma.c
@@ -71,7 +71,7 @@ static irqreturn_t ioat_dma_do_interrupt(int irq, void *data)
        }
        attnstatus = readl(instance->reg_base + IOAT_ATTNSTATUS_OFFSET);
-        for_each_bit(bit, &attnstatus, BITS_PER_LONG) {
+        for_each_set_bit(bit, &attnstatus, BITS_PER_LONG) {
                chan = ioat_chan_by_index(instance, bit);
                tasklet_schedule(&chan->cleanup_task);
        }
diff --git a/drivers/eisa/eisa-bus.c b/drivers/eisa/eisa-bus.c
index 66958b3f10b4..806c77bfd434 100644
--- a/drivers/eisa/eisa-bus.c
+++ b/drivers/eisa/eisa-bus.c
@@ -39,10 +39,10 @@ static unsigned int enable_dev_count;
 static int disable_dev[EISA_MAX_FORCED_DEV];
 static unsigned int disable_dev_count;
-static int is_forced_dev (int *forced_tab,
+static int is_forced_dev(int *forced_tab,
-                          int forced_count,
+                         int forced_count,
-                          struct eisa_root_device *root,
+                         struct eisa_root_device *root,
-                          struct eisa_device *edev)
+                         struct eisa_device *edev)
 {
        int i, x;
@@ -55,21 +55,21 @@ static int is_forced_dev (int *forced_tab,
        return 0;
 }
-static void __init eisa_name_device (struct eisa_device *edev)
+static void __init eisa_name_device(struct eisa_device *edev)
 {
 #ifdef CONFIG_EISA_NAMES
        int i;
        for (i = 0; i < EISA_INFOS; i++) {
-                if (!strcmp (edev->id.sig, eisa_table[i].id.sig)) {
+                if (!strcmp(edev->id.sig, eisa_table[i].id.sig)) {
-                        strlcpy (edev->pretty_name,
+                        strlcpy(edev->pretty_name,
-                                 eisa_table[i].name,
+                                eisa_table[i].name,
-                                 sizeof(edev->pretty_name));
+                                sizeof(edev->pretty_name));
                        return;
                }
        }
        /* No name was found */
-        sprintf (edev->pretty_name, "EISA device %.7s", edev->id.sig);
+        sprintf(edev->pretty_name, "EISA device %.7s", edev->id.sig);
 #endif
 }
@@ -91,7 +91,7 @@ static char __init *decode_eisa_sig(unsigned long addr)
                 */
                outb(0x80 + i, addr);
 #endif
-                sig[i] = inb (addr + i);
+                sig[i] = inb(addr + i);
                if (!i && (sig[0] & 0x80))
                        return NULL;
@@ -106,17 +106,17 @@ static char __init *decode_eisa_sig(unsigned long addr)
        return sig_str;
 }
-static int eisa_bus_match (struct device *dev, struct device_driver *drv)
+static int eisa_bus_match(struct device *dev, struct device_driver *drv)
 {
-        struct eisa_device *edev = to_eisa_device (dev);
+        struct eisa_device *edev = to_eisa_device(dev);
-        struct eisa_driver *edrv = to_eisa_driver (drv);
+        struct eisa_driver *edrv = to_eisa_driver(drv);
        const struct eisa_device_id *eids = edrv->id_table;
        if (!eids)
                return 0;
-        while (strlen (eids->sig)) {
+        while (strlen(eids->sig)) {
-                if (!strcmp (eids->sig, edev->id.sig) &&
+                if (!strcmp(eids->sig, edev->id.sig) &&
                    edev->state & EISA_CONFIG_ENABLED) {
                        edev->id.driver_data = eids->driver_data;
                        return 1;
@@ -141,61 +141,71 @@ struct bus_type eisa_bus_type = {
        .match = eisa_bus_match,
        .uevent = eisa_bus_uevent,
 };
+EXPORT_SYMBOL(eisa_bus_type);
-int eisa_driver_register (struct eisa_driver *edrv)
+int eisa_driver_register(struct eisa_driver *edrv)
 {
        edrv->driver.bus = &eisa_bus_type;
-        return driver_register (&edrv->driver);
+        return driver_register(&edrv->driver);
 }
+EXPORT_SYMBOL(eisa_driver_register);
-void eisa_driver_unregister (struct eisa_driver *edrv)
+void eisa_driver_unregister(struct eisa_driver *edrv)
 {
-        driver_unregister (&edrv->driver);
+        driver_unregister(&edrv->driver);
 }
+EXPORT_SYMBOL(eisa_driver_unregister);
-static ssize_t eisa_show_sig (struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t eisa_show_sig(struct device *dev, struct device_attribute *attr,
+                             char *buf)
 {
-        struct eisa_device *edev = to_eisa_device (dev);
+        struct eisa_device *edev = to_eisa_device(dev);
-        return sprintf (buf,"%s\n", edev->id.sig);
+        return sprintf(buf, "%s\n", edev->id.sig);
 }
 static DEVICE_ATTR(signature, S_IRUGO, eisa_show_sig, NULL);
-static ssize_t eisa_show_state (struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t eisa_show_state(struct device *dev,
+                               struct device_attribute *attr,
+                               char *buf)
 {
-        struct eisa_device *edev = to_eisa_device (dev);
+        struct eisa_device *edev = to_eisa_device(dev);
-        return sprintf (buf,"%d\n", edev->state & EISA_CONFIG_ENABLED);
+        return sprintf(buf, "%d\n", edev->state & EISA_CONFIG_ENABLED);
 }
 static DEVICE_ATTR(enabled, S_IRUGO, eisa_show_state, NULL);
-static ssize_t eisa_show_modalias (struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t eisa_show_modalias(struct device *dev,
+                                  struct device_attribute *attr,
+                                  char *buf)
 {
-        struct eisa_device *edev = to_eisa_device (dev);
+        struct eisa_device *edev = to_eisa_device(dev);
-        return sprintf (buf, EISA_DEVICE_MODALIAS_FMT "\n", edev->id.sig);
+        return sprintf(buf, EISA_DEVICE_MODALIAS_FMT "\n", edev->id.sig);
 }
 static DEVICE_ATTR(modalias, S_IRUGO, eisa_show_modalias, NULL);
-static int __init eisa_init_device (struct eisa_root_device *root,
+static int __init eisa_init_device(struct eisa_root_device *root,
-                                    struct eisa_device *edev,
+                                   struct eisa_device *edev,
-                                    int slot)
+                                   int slot)
 {
        char *sig;
-        unsigned long sig_addr;
+        unsigned long sig_addr;
        int i;
-        sig_addr = SLOT_ADDRESS (root, slot) + EISA_VENDOR_ID_OFFSET;
+        sig_addr = SLOT_ADDRESS(root, slot) + EISA_VENDOR_ID_OFFSET;
-        if (!(sig = decode_eisa_sig (sig_addr)))
+        sig = decode_eisa_sig(sig_addr);
+        if (!sig)
                return -1;      /* No EISA device here */
        
-        memcpy (edev->id.sig, sig, EISA_SIG_LEN);
+        memcpy(edev->id.sig, sig, EISA_SIG_LEN);
        edev->slot = slot;
-        edev->state = inb (SLOT_ADDRESS (root, slot) + EISA_CONFIG_OFFSET) & EISA_CONFIG_ENABLED;
+        edev->state = inb(SLOT_ADDRESS(root, slot) + EISA_CONFIG_OFFSET)
-        edev->base_addr = SLOT_ADDRESS (root, slot);
+                      & EISA_CONFIG_ENABLED;
+        edev->base_addr = SLOT_ADDRESS(root, slot);
        edev->dma_mask = root->dma_mask; /* Default DMA mask */
-        eisa_name_device (edev);
+        eisa_name_device(edev);
        edev->dev.parent = root->dev;
        edev->dev.bus = &eisa_bus_type;
        edev->dev.dma_mask = &edev->dma_mask;
@@ -210,42 +220,45 @@ static int __init eisa_init_device (struct eisa_root_device *root,
 #endif
        }
-        if (is_forced_dev (enable_dev, enable_dev_count, root, edev))
+        if (is_forced_dev(enable_dev, enable_dev_count, root, edev))
                edev->state = EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED;
        
-        if (is_forced_dev (disable_dev, disable_dev_count, root, edev))
+        if (is_forced_dev(disable_dev, disable_dev_count, root, edev))
                edev->state = EISA_CONFIG_FORCED;
        return 0;
 }
-static int __init eisa_register_device (struct eisa_device *edev)
+static int __init eisa_register_device(struct eisa_device *edev)
 {
-        int rc = device_register (&edev->dev);
+        int rc = device_register(&edev->dev);
        if (rc)
                return rc;
-        rc = device_create_file (&edev->dev, &dev_attr_signature);
+        rc = device_create_file(&edev->dev, &dev_attr_signature);
-        if (rc) goto err_devreg;
+        if (rc)
-        rc = device_create_file (&edev->dev, &dev_attr_enabled);
+                goto err_devreg;
-        if (rc) goto err_sig;
+        rc = device_create_file(&edev->dev, &dev_attr_enabled);
-        rc = device_create_file (&edev->dev, &dev_attr_modalias);
+        if (rc)
-        if (rc) goto err_enab;
+                goto err_sig;
+        rc = device_create_file(&edev->dev, &dev_attr_modalias);
+        if (rc)
+                goto err_enab;
        return 0;
 err_enab:
-        device_remove_file (&edev->dev, &dev_attr_enabled);
+        device_remove_file(&edev->dev, &dev_attr_enabled);
 err_sig:
-        device_remove_file (&edev->dev, &dev_attr_signature);
+        device_remove_file(&edev->dev, &dev_attr_signature);
 err_devreg:
        device_unregister(&edev->dev);
        return rc;
 }
-static int __init eisa_request_resources (struct eisa_root_device *root,
+static int __init eisa_request_resources(struct eisa_root_device *root,
-                                          struct eisa_device *edev,
+                                         struct eisa_device *edev,
-                                          int slot)
+                                         int slot)
 {
        int i;
@@ -263,17 +276,19 @@ static int __init eisa_request_resources (struct eisa_root_device *root,
                
                if (slot) {
                        edev->res[i].name  = NULL;
-                        edev->res[i].start = SLOT_ADDRESS (root, slot) + (i * 0x400);
+                        edev->res[i].start = SLOT_ADDRESS(root, slot)
+                                             + (i * 0x400);
                        edev->res[i].end   = edev->res[i].start + 0xff;
                        edev->res[i].flags = IORESOURCE_IO;
                } else {
                        edev->res[i].name  = NULL;
-                        edev->res[i].start = SLOT_ADDRESS (root, slot) + EISA_VENDOR_ID_OFFSET;
+                        edev->res[i].start = SLOT_ADDRESS(root, slot)
+                                             + EISA_VENDOR_ID_OFFSET;
                        edev->res[i].end   = edev->res[i].start + 3;
                        edev->res[i].flags = IORESOURCE_BUSY;
                }
-                if (request_resource (root->res, &edev->res[i]))
+                if (request_resource(root->res, &edev->res[i]))
                        goto failed;
        }
@@ -281,99 +296,100 @@ static int __init eisa_request_resources (struct eisa_root_device *root,
        
 failed:
        while (--i >= 0)
-                release_resource (&edev->res[i]);
+                release_resource(&edev->res[i]);
        return -1;
 }
-static void __init eisa_release_resources (struct eisa_device *edev)
+static void __init eisa_release_resources(struct eisa_device *edev)
 {
        int i;
        for (i = 0; i < EISA_MAX_RESOURCES; i++)
                if (edev->res[i].start || edev->res[i].end)
-                        release_resource (&edev->res[i]);
+                        release_resource(&edev->res[i]);
 }
-static int __init eisa_probe (struct eisa_root_device *root)
+static int __init eisa_probe(struct eisa_root_device *root)
 {
        int i, c;
        struct eisa_device *edev;
-        printk (KERN_INFO "EISA: Probing bus %d at %s\n",
+        printk(KERN_INFO "EISA: Probing bus %d at %s\n",
-                root->bus_nr, dev_name(root->dev));
+               root->bus_nr, dev_name(root->dev));
        /* First try to get hold of slot 0. If there is no device
         * here, simply fail, unless root->force_probe is set. */
        
-        if (!(edev = kzalloc (sizeof (*edev), GFP_KERNEL))) {
+        edev = kzalloc(sizeof(*edev), GFP_KERNEL);
-                printk (KERN_ERR "EISA: Couldn't allocate mainboard slot\n");
+        if (!edev) {
+                printk(KERN_ERR "EISA: Couldn't allocate mainboard slot\n");
                return -ENOMEM;
        }
                
-        if (eisa_request_resources (root, edev, 0)) {
+        if (eisa_request_resources(root, edev, 0)) {
-                printk (KERN_WARNING \
+                printk(KERN_WARNING \
-                        "EISA: Cannot allocate resource for mainboard\n");
+                       "EISA: Cannot allocate resource for mainboard\n");
-                kfree (edev);
+                kfree(edev);
                if (!root->force_probe)
                        return -EBUSY;
                goto force_probe;
        }
-        if (eisa_init_device (root, edev, 0)) {
+        if (eisa_init_device(root, edev, 0)) {
-                eisa_release_resources (edev);
+                eisa_release_resources(edev);
-                kfree (edev);
+                kfree(edev);
                if (!root->force_probe)
                        return -ENODEV;
                goto force_probe;
        }
-        printk (KERN_INFO "EISA: Mainboard %s detected.\n", edev->id.sig);
+        printk(KERN_INFO "EISA: Mainboard %s detected.\n", edev->id.sig);
-        if (eisa_register_device (edev)) {
+        if (eisa_register_device(edev)) {
-                printk (KERN_ERR "EISA: Failed to register %s\n",
+                printk(KERN_ERR "EISA: Failed to register %s\n",
-                        edev->id.sig);
+                       edev->id.sig);
-                eisa_release_resources (edev);
+                eisa_release_resources(edev);
-                kfree (edev);
+                kfree(edev);
        }
        
 force_probe:
        
        for (c = 0, i = 1; i <= root->slots; i++) {
-                if (!(edev = kzalloc (sizeof (*edev), GFP_KERNEL))) {
+                edev = kzalloc(sizeof(*edev), GFP_KERNEL);
-                        printk (KERN_ERR "EISA: Out of memory for slot %d\n",
+                if (!edev) {
-                                i);
+                        printk(KERN_ERR "EISA: Out of memory for slot %d\n", i);
                        continue;
                }
-                if (eisa_request_resources (root, edev, i)) {
+                if (eisa_request_resources(root, edev, i)) {
-                        printk (KERN_WARNING \
+                        printk(KERN_WARNING \
-                                "Cannot allocate resource for EISA slot %d\n",
+                               "Cannot allocate resource for EISA slot %d\n",
-                                i);
+                               i);
-                        kfree (edev);
+                        kfree(edev);
                        continue;
                }
-                if (eisa_init_device (root, edev, i)) {
+                if (eisa_init_device(root, edev, i)) {
-                        eisa_release_resources (edev);
+                        eisa_release_resources(edev);
-                        kfree (edev);
+                        kfree(edev);
                        continue;
                }
                
-                printk (KERN_INFO "EISA: slot %d : %s detected",
+                printk(KERN_INFO "EISA: slot %d : %s detected",
-                        i, edev->id.sig);
+                       i, edev->id.sig);
                        
                switch (edev->state) {
                case EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED:
-                        printk (" (forced enabled)");
+                        printk(" (forced enabled)");
                        break;
                case EISA_CONFIG_FORCED:
-                        printk (" (forced disabled)");
+                        printk(" (forced disabled)");
                        break;
                case 0:
-                        printk (" (disabled)");
+                        printk(" (disabled)");
                        break;
                }
                        
@@ -381,15 +397,15 @@ static int __init eisa_probe (struct eisa_root_device *root)
                c++;
-                if (eisa_register_device (edev)) {
+                if (eisa_register_device(edev)) {
-                        printk (KERN_ERR "EISA: Failed to register %s\n",
+                        printk(KERN_ERR "EISA: Failed to register %s\n",
-                                edev->id.sig);
+                               edev->id.sig);
-                        eisa_release_resources (edev);
+                        eisa_release_resources(edev);
-                        kfree (edev);
+                        kfree(edev);
                }
        }
-        printk (KERN_INFO "EISA: Detected %d card%s.\n", c, c == 1 ? "" : "s");
+        printk(KERN_INFO "EISA: Detected %d card%s.\n", c, c == 1 ? "" : "s");
        return 0;
 }
@@ -403,7 +419,7 @@ static struct resource eisa_root_res = {
 static int eisa_bus_count;
-int __init eisa_root_register (struct eisa_root_device *root)
+int __init eisa_root_register(struct eisa_root_device *root)
 {
        int err;
@@ -417,35 +433,35 @@ int __init eisa_root_register (struct eisa_root_device *root)
        root->eisa_root_res.end   = root->res->end;
        root->eisa_root_res.flags = IORESOURCE_BUSY;
-        if ((err = request_resource (&eisa_root_res, &root->eisa_root_res)))
+        err = request_resource(&eisa_root_res, &root->eisa_root_res);
+        if (err)
                return err;
        
        root->bus_nr = eisa_bus_count++;
-        if ((err = eisa_probe (root)))
+        err = eisa_probe(root);
-                release_resource (&root->eisa_root_res);
+        if (err)
+                release_resource(&root->eisa_root_res);
        return err;
 }
-static int __init eisa_init (void)
+static int __init eisa_init(void)
 {
        int r;
        
-        if ((r = bus_register (&eisa_bus_type)))
+        r = bus_register(&eisa_bus_type);
+        if (r)
                return r;
-        printk (KERN_INFO "EISA bus registered\n");
+        printk(KERN_INFO "EISA bus registered\n");
        return 0;
 }
 module_param_array(enable_dev, int, &enable_dev_count, 0444);
 module_param_array(disable_dev, int, &disable_dev_count, 0444);
-postcore_initcall (eisa_init);
+postcore_initcall(eisa_init);
 int EISA_bus;           /* for legacy drivers */
-EXPORT_SYMBOL (EISA_bus);
+EXPORT_SYMBOL(EISA_bus);
-EXPORT_SYMBOL (eisa_bus_type);
-EXPORT_SYMBOL (eisa_driver_register);
-EXPORT_SYMBOL (eisa_driver_unregister);
diff --git a/drivers/firmware/memmap.c b/drivers/firmware/memmap.c
index 56f9234781fa..20f645743ead 100644
--- a/drivers/firmware/memmap.c
+++ b/drivers/firmware/memmap.c
@@ -122,29 +122,53 @@ static int firmware_map_add_entry(u64 start, u64 end,
        return 0;
 }
+/*
+ * Add memmap entry on sysfs
+ */
+static int add_sysfs_fw_map_entry(struct firmware_map_entry *entry)
+{
+        static int map_entries_nr;
+        static struct kset *mmap_kset;
+        if (!mmap_kset) {
+                mmap_kset = kset_create_and_add("memmap", NULL, firmware_kobj);
+                if (!mmap_kset)
+                        return -ENOMEM;
+        }
+        entry->kobj.kset = mmap_kset;
+        if (kobject_add(&entry->kobj, NULL, "%d", map_entries_nr++))
+                kobject_put(&entry->kobj);
+        return 0;
+}
 /**
- * firmware_map_add() - Adds a firmware mapping entry.
+ * firmware_map_add_hotplug() - Adds a firmware mapping entry when we do
+ * memory hotplug.
 * @start: Start of the memory range.
 * @end:   End of the memory range (inclusive).
 * @type:  Type of the memory range.
 *
- * This function uses kmalloc() for memory
+ * Adds a firmware mapping entry. This function is for memory hotplug, it is
- * allocation. Use firmware_map_add_early() if you want to use the bootmem
+ * similar to function firmware_map_add_early(). The only difference is that
- * allocator.
+ * it will create the syfs entry dynamically.
- *
- * That function must be called before late_initcall.
 *
 * Returns 0 on success, or -ENOMEM if no memory could be allocated.
 **/
-int firmware_map_add(u64 start, u64 end, const char *type)
+int __meminit firmware_map_add_hotplug(u64 start, u64 end, const char *type)
 {
        struct firmware_map_entry *entry;
-        entry = kmalloc(sizeof(struct firmware_map_entry), GFP_ATOMIC);
+        entry = kzalloc(sizeof(struct firmware_map_entry), GFP_ATOMIC);
        if (!entry)
                return -ENOMEM;
-        return firmware_map_add_entry(start, end, type, entry);
+        firmware_map_add_entry(start, end, type, entry);
+        /* create the memmap entry */
+        add_sysfs_fw_map_entry(entry);
+        return 0;
 }
 /**
@@ -154,7 +178,7 @@ int firmware_map_add(u64 start, u64 end, const char *type)
 * @type:  Type of the memory range.
 *
 * Adds a firmware mapping entry. This function uses the bootmem allocator
- * for memory allocation. Use firmware_map_add() if you want to use kmalloc().
+ * for memory allocation.
 *
 * That function must be called before late_initcall.
 *
@@ -214,19 +238,10 @@ static ssize_t memmap_attr_show(struct kobject *kobj,
 */
 static int __init memmap_init(void)
 {
-        int i = 0;
        struct firmware_map_entry *entry;
-        struct kset *memmap_kset;
-        memmap_kset = kset_create_and_add("memmap", NULL, firmware_kobj);
-        if (WARN_ON(!memmap_kset))
-                return -ENOMEM;
-        list_for_each_entry(entry, &map_entries, list) {
+        list_for_each_entry(entry, &map_entries, list)
-                entry->kobj.kset = memmap_kset;
+                add_sysfs_fw_map_entry(entry);
-                if (kobject_add(&entry->kobj, NULL, "%d", i++))
-                        kobject_put(&entry->kobj);
-        }
        return 0;
 }
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 1f1d88ae68d6..a4cdbd51b1c6 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -65,8 +65,17 @@ config GPIO_SYSFS
 # put expanders in the right section, in alphabetical order
+config GPIO_MAX730X
+        tristate
 comment "Memory mapped GPIO expanders:"
+config GPIO_IT8761E
+        tristate "IT8761E GPIO support"
+        depends on GPIOLIB
+        help
+          Say yes here to support GPIO functionality of IT8761E super I/O chip.
 config GPIO_PL061
        bool "PrimeCell PL061 GPIO support"
        depends on ARM_AMBA
@@ -87,6 +96,13 @@ config GPIO_VR41XX
 comment "I2C GPIO expanders:"
+config GPIO_MAX7300
+        tristate "Maxim MAX7300 GPIO expander"
+        depends on I2C
+        select GPIO_MAX730X
+        help
+          GPIO driver for Maxim MAX7301 I2C-based GPIO expander.
 config GPIO_MAX732X
        tristate "MAX7319, MAX7320-7327 I2C Port Expanders"
        depends on I2C
@@ -124,6 +140,13 @@ config GPIO_PCA953X
          This driver can also be built as a module.  If so, the module
          will be called pca953x.
+config GPIO_PCA953X_IRQ
+        bool "Interrupt controller support for PCA953x"
+        depends on GPIO_PCA953X=y
+        help
+          Say yes here to enable the pca953x to be used as an interrupt
+          controller. It requires the driver to be built in the kernel.
 config GPIO_PCF857X
        tristate "PCF857x, PCA{85,96}7x, and MAX732[89] I2C GPIO expanders"
        depends on I2C
@@ -226,8 +249,9 @@ comment "SPI GPIO expanders:"
 config GPIO_MAX7301
        tristate "Maxim MAX7301 GPIO expander"
        depends on SPI_MASTER
+        select GPIO_MAX730X
        help
-          gpio driver for Maxim MAX7301 SPI GPIO expander.
+          GPIO driver for Maxim MAX7301 SPI-based GPIO expander.
 config GPIO_MCP23S08
        tristate "Microchip MCP23S08 I/O expander"
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 48687238edb1..128abf8a98da 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -7,6 +7,8 @@ obj-$(CONFIG_GPIOLIB)		+= gpiolib.o
 obj-$(CONFIG_GPIO_ADP5520)      += adp5520-gpio.o
 obj-$(CONFIG_GPIO_ADP5588)      += adp5588-gpio.o
 obj-$(CONFIG_GPIO_LANGWELL)     += langwell_gpio.o
+obj-$(CONFIG_GPIO_MAX730X)      += max730x.o
+obj-$(CONFIG_GPIO_MAX7300)      += max7300.o
 obj-$(CONFIG_GPIO_MAX7301)      += max7301.o
 obj-$(CONFIG_GPIO_MAX732X)      += max732x.o
 obj-$(CONFIG_GPIO_MC33880)      += mc33880.o
@@ -20,5 +22,6 @@ obj-$(CONFIG_GPIO_UCB1400)	+= ucb1400_gpio.o
 obj-$(CONFIG_GPIO_XILINX)       += xilinx_gpio.o
 obj-$(CONFIG_GPIO_CS5535)       += cs5535-gpio.o
 obj-$(CONFIG_GPIO_BT8XX)        += bt8xxgpio.o
+obj-$(CONFIG_GPIO_IT8761E)      += it8761e_gpio.o
 obj-$(CONFIG_GPIO_VR41XX)       += vr41xx_giu.o
 obj-$(CONFIG_GPIO_WM831X)       += wm831x-gpio.o
diff --git a/drivers/gpio/cs5535-gpio.c b/drivers/gpio/cs5535-gpio.c
index 0fdbe94f24a3..0c3c498f2260 100644
--- a/drivers/gpio/cs5535-gpio.c
+++ b/drivers/gpio/cs5535-gpio.c
@@ -154,7 +154,7 @@ static int chip_gpio_request(struct gpio_chip *c, unsigned offset)
 static int chip_gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        return cs5535_gpio_isset(offset, GPIO_OUTPUT_VAL);
+        return cs5535_gpio_isset(offset, GPIO_READ_BACK);
 }
 static void chip_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
@@ -172,6 +172,7 @@ static int chip_direction_input(struct gpio_chip *c, unsigned offset)
        spin_lock_irqsave(&chip->lock, flags);
        __cs5535_gpio_set(chip, offset, GPIO_INPUT_ENABLE);
+        __cs5535_gpio_clear(chip, offset, GPIO_OUTPUT_ENABLE);
        spin_unlock_irqrestore(&chip->lock, flags);
        return 0;
@@ -184,6 +185,7 @@ static int chip_direction_output(struct gpio_chip *c, unsigned offset, int val)
        spin_lock_irqsave(&chip->lock, flags);
+        __cs5535_gpio_set(chip, offset, GPIO_INPUT_ENABLE);
        __cs5535_gpio_set(chip, offset, GPIO_OUTPUT_ENABLE);
        if (val)
                __cs5535_gpio_set(chip, offset, GPIO_OUTPUT_VAL);
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 350842ad3632..9006fdb26fea 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -1237,6 +1237,64 @@ void gpio_free(unsigned gpio)
 }
 EXPORT_SYMBOL_GPL(gpio_free);
+/**
+ * gpio_request_one - request a single GPIO with initial configuration
+ * @gpio:       the GPIO number
+ * @flags:      GPIO configuration as specified by GPIOF_*
+ * @label:      a literal description string of this GPIO
+ */
+int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
+{
+        int err;
+        err = gpio_request(gpio, label);
+        if (err)
+                return err;
+        if (flags & GPIOF_DIR_IN)
+                err = gpio_direction_input(gpio);
+        else
+                err = gpio_direction_output(gpio,
+                                (flags & GPIOF_INIT_HIGH) ? 1 : 0);
+        return err;
+}
+EXPORT_SYMBOL_GPL(gpio_request_one);
+/**
+ * gpio_request_array - request multiple GPIOs in a single call
+ * @array:      array of the 'struct gpio'
+ * @num:        how many GPIOs in the array
+ */
+int gpio_request_array(struct gpio *array, size_t num)
+{
+        int i, err;
+        for (i = 0; i < num; i++, array++) {
+                err = gpio_request_one(array->gpio, array->flags, array->label);
+                if (err)
+                        goto err_free;
+        }
+        return 0;
+err_free:
+        while (i--)
+                gpio_free((--array)->gpio);
+        return err;
+}
+EXPORT_SYMBOL_GPL(gpio_request_array);
+/**
+ * gpio_free_array - release multiple GPIOs in a single call
+ * @array:      array of the 'struct gpio'
+ * @num:        how many GPIOs in the array
+ */
+void gpio_free_array(struct gpio *array, size_t num)
+{
+        while (num--)
+                gpio_free((array++)->gpio);
+}
+EXPORT_SYMBOL_GPL(gpio_free_array);
 /**
 * gpiochip_is_requested - return string iff signal was requested
diff --git a/drivers/gpio/it8761e_gpio.c b/drivers/gpio/it8761e_gpio.c
new file mode 100644
index 000000000000..753219cf993a
--- /dev/null
+++ b/drivers/gpio/it8761e_gpio.c
@@ -0,0 +1,231 @@
+/*
+ *  it8761_gpio.c - GPIO interface for IT8761E Super I/O chip
+ *
+ *  Author: Denis Turischev <denis@compulab.co.il>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License 2 as published
+ *  by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/gpio.h>
+#define SIO_CHIP_ID             0x8761
+#define CHIP_ID_HIGH_BYTE       0x20
+#define CHIP_ID_LOW_BYTE        0x21
+static u8 ports[2] = { 0x2e, 0x4e };
+static u8 port;
+static DEFINE_SPINLOCK(sio_lock);
+#define GPIO_NAME               "it8761-gpio"
+#define GPIO_BA_HIGH_BYTE       0x60
+#define GPIO_BA_LOW_BYTE        0x61
+#define GPIO_IOSIZE             4
+#define GPIO1X_IO               0xf0
+#define GPIO2X_IO               0xf1
+static u16 gpio_ba;
+static u8 read_reg(u8 addr, u8 port)
+{
+        outb(addr, port);
+        return inb(port + 1);
+}
+static void write_reg(u8 data, u8 addr, u8 port)
+{
+        outb(addr, port);
+        outb(data, port + 1);
+}
+static void enter_conf_mode(u8 port)
+{
+        outb(0x87, port);
+        outb(0x61, port);
+        outb(0x55, port);
+        outb((port == 0x2e) ? 0x55 : 0xaa, port);
+}
+static void exit_conf_mode(u8 port)
+{
+        outb(0x2, port);
+        outb(0x2, port + 1);
+}
+static void enter_gpio_mode(u8 port)
+{
+        write_reg(0x2, 0x7, port);
+}
+static int it8761e_gpio_get(struct gpio_chip *gc, unsigned gpio_num)
+{
+        u16 reg;
+        u8 bit;
+        bit = gpio_num % 7;
+        reg = (gpio_num >= 7) ? gpio_ba + 1 : gpio_ba;
+        return !!(inb(reg) & (1 << bit));
+}
+static int it8761e_gpio_direction_in(struct gpio_chip *gc, unsigned gpio_num)
+{
+        u8 curr_dirs;
+        u8 io_reg, bit;
+        bit = gpio_num % 7;
+        io_reg = (gpio_num >= 7) ? GPIO2X_IO : GPIO1X_IO;
+        spin_lock(&sio_lock);
+        enter_conf_mode(port);
+        enter_gpio_mode(port);
+        curr_dirs = read_reg(io_reg, port);
+        if (curr_dirs & (1 << bit))
+                write_reg(curr_dirs & ~(1 << bit), io_reg, port);
+        exit_conf_mode(port);
+        spin_unlock(&sio_lock);
+        return 0;
+}
+static void it8761e_gpio_set(struct gpio_chip *gc,
+                                unsigned gpio_num, int val)
+{
+        u8 curr_vals, bit;
+        u16 reg;
+        bit = gpio_num % 7;
+        reg = (gpio_num >= 7) ? gpio_ba + 1 : gpio_ba;
+        spin_lock(&sio_lock);
+        curr_vals = inb(reg);
+        if (val)
+                outb(curr_vals | (1 << bit) , reg);
+        else
+                outb(curr_vals & ~(1 << bit), reg);
+        spin_unlock(&sio_lock);
+}
+static int it8761e_gpio_direction_out(struct gpio_chip *gc,
+                                        unsigned gpio_num, int val)
+{
+        u8 curr_dirs, io_reg, bit;
+        bit = gpio_num % 7;
+        io_reg = (gpio_num >= 7) ? GPIO2X_IO : GPIO1X_IO;
+        it8761e_gpio_set(gc, gpio_num, val);
+        spin_lock(&sio_lock);
+        enter_conf_mode(port);
+        enter_gpio_mode(port);
+        curr_dirs = read_reg(io_reg, port);
+        if (!(curr_dirs & (1 << bit)))
+                write_reg(curr_dirs | (1 << bit), io_reg, port);
+        exit_conf_mode(port);
+        spin_unlock(&sio_lock);
+        return 0;
+}
+static struct gpio_chip it8761e_gpio_chip = {
+        .label                  = GPIO_NAME,
+        .owner                  = THIS_MODULE,
+        .get                    = it8761e_gpio_get,
+        .direction_input        = it8761e_gpio_direction_in,
+        .set                    = it8761e_gpio_set,
+        .direction_output       = it8761e_gpio_direction_out,
+};
+static int __init it8761e_gpio_init(void)
+{
+        int i, id, err;
+        /* chip and port detection */
+        for (i = 0; i < ARRAY_SIZE(ports); i++) {
+                spin_lock(&sio_lock);
+                enter_conf_mode(ports[i]);
+                id = (read_reg(CHIP_ID_HIGH_BYTE, ports[i]) << 8) +
+                                read_reg(CHIP_ID_LOW_BYTE, ports[i]);
+                exit_conf_mode(ports[i]);
+                spin_unlock(&sio_lock);
+                if (id == SIO_CHIP_ID) {
+                        port = ports[i];
+                        break;
+                }
+        }
+        if (!port)
+                return -ENODEV;
+        /* fetch GPIO base address */
+        enter_conf_mode(port);
+        enter_gpio_mode(port);
+        gpio_ba = (read_reg(GPIO_BA_HIGH_BYTE, port) << 8) +
+                                read_reg(GPIO_BA_LOW_BYTE, port);
+        exit_conf_mode(port);
+        if (!request_region(gpio_ba, GPIO_IOSIZE, GPIO_NAME))
+                return -EBUSY;
+        it8761e_gpio_chip.base = -1;
+        it8761e_gpio_chip.ngpio = 14;
+        err = gpiochip_add(&it8761e_gpio_chip);
+        if (err < 0)
+                goto gpiochip_add_err;
+        return 0;
+gpiochip_add_err:
+        release_region(gpio_ba, GPIO_IOSIZE);
+        gpio_ba = 0;
+        return err;
+}
+static void __exit it8761e_gpio_exit(void)
+{
+        if (gpio_ba) {
+                gpiochip_remove(&it8761e_gpio_chip);
+                release_region(gpio_ba, GPIO_IOSIZE);
+                gpio_ba = 0;
+        }
+}
+module_init(it8761e_gpio_init);
+module_exit(it8761e_gpio_exit);
+MODULE_AUTHOR("Denis Turischev <denis@compulab.co.il>");
+MODULE_DESCRIPTION("GPIO interface for IT8761E Super I/O chip");
+MODULE_LICENSE("GPL");
diff --git a/drivers/gpio/max7300.c b/drivers/gpio/max7300.c
new file mode 100644
index 000000000000..9d74eef1157a
--- /dev/null
+++ b/drivers/gpio/max7300.c
@@ -0,0 +1,94 @@
+/*
+ * drivers/gpio/max7300.c
+ *
+ * Copyright (C) 2009 Wolfram Sang, Pengutronix
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Check max730x.c for further details.
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/i2c.h>
+#include <linux/spi/max7301.h>
+static int max7300_i2c_write(struct device *dev, unsigned int reg,
+                                unsigned int val)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        return i2c_smbus_write_byte_data(client, reg, val);
+}
+static int max7300_i2c_read(struct device *dev, unsigned int reg)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        return i2c_smbus_read_byte_data(client, reg);
+}
+static int __devinit max7300_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct max7301 *ts;
+        int ret;
+        if (!i2c_check_functionality(client->adapter,
+                        I2C_FUNC_SMBUS_BYTE_DATA))
+                return -EIO;
+        ts = kzalloc(sizeof(struct max7301), GFP_KERNEL);
+        if (!ts)
+                return -ENOMEM;
+        ts->read = max7300_i2c_read;
+        ts->write = max7300_i2c_write;
+        ts->dev = &client->dev;
+        ret = __max730x_probe(ts);
+        if (ret)
+                kfree(ts);
+        return ret;
+}
+static int __devexit max7300_remove(struct i2c_client *client)
+{
+        return __max730x_remove(&client->dev);
+}
+static const struct i2c_device_id max7300_id[] = {
+        { "max7300", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, max7300_id);
+static struct i2c_driver max7300_driver = {
+        .driver = {
+                .name = "max7300",
+                .owner = THIS_MODULE,
+        },
+        .probe = max7300_probe,
+        .remove = __devexit_p(max7300_remove),
+        .id_table = max7300_id,
+};
+static int __init max7300_init(void)
+{
+        return i2c_add_driver(&max7300_driver);
+}
+subsys_initcall(max7300_init);
+static void __exit max7300_exit(void)
+{
+        i2c_del_driver(&max7300_driver);
+}
+module_exit(max7300_exit);
+MODULE_AUTHOR("Wolfram Sang");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("MAX7300 GPIO-Expander");
diff --git a/drivers/gpio/max7301.c b/drivers/gpio/max7301.c
index 480956f1ca50..965d9b1ea13e 100644
--- a/drivers/gpio/max7301.c
+++ b/drivers/gpio/max7301.c
@@ -1,98 +1,41 @@
-/**
+/*
 * drivers/gpio/max7301.c
 *
 * Copyright (C) 2006 Juergen Beisert, Pengutronix
 * Copyright (C) 2008 Guennadi Liakhovetski, Pengutronix
+ * Copyright (C) 2009 Wolfram Sang, Pengutronix
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
- * The Maxim's MAX7301 device is an SPI driven GPIO expander. There are
+ * Check max730x.c for further details.
- * 28 GPIOs. 8 of them can trigger an interrupt. See datasheet for more
- * details
- * Note:
- * - DIN must be stable at the rising edge of clock.
- * - when writing:
- *   - always clock in 16 clocks at once
- *   - at DIN: D15 first, D0 last
- *   - D0..D7 = databyte, D8..D14 = commandbyte
- *   - D15 = low -> write command
- * - when reading
- *   - always clock in 16 clocks at once
- *   - at DIN: D15 first, D0 last
- *   - D0..D7 = dummy, D8..D14 = register address
- *   - D15 = high -> read command
- *   - raise CS and assert it again
- *   - always clock in 16 clocks at once
- *   - at DOUT: D15 first, D0 last
- *   - D0..D7 contains the data from the first cycle
- *
- * The driver exports a standard gpiochip interface
 */
+#include <linux/module.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/mutex.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/max7301.h>
-#include <linux/gpio.h>
-#define DRIVER_NAME "max7301"
-/*
- * Pin configurations, see MAX7301 datasheet page 6
- */
-#define PIN_CONFIG_MASK 0x03
-#define PIN_CONFIG_IN_PULLUP 0x03
-#define PIN_CONFIG_IN_WO_PULLUP 0x02
-#define PIN_CONFIG_OUT 0x01
-#define PIN_NUMBER 28
-/*
- * Some registers must be read back to modify.
- * To save time we cache them here in memory
- */
-struct max7301 {
-        struct mutex    lock;
-        u8              port_config[8]; /* field 0 is unused */
-        u32             out_level;      /* cached output levels */
-        struct gpio_chip chip;
-        struct spi_device *spi;
-};
-/**
+/* A write to the MAX7301 means one message with one transfer */
- * max7301_write - Write a new register content
+static int max7301_spi_write(struct device *dev, unsigned int reg,
- * @spi: The SPI device
+                                unsigned int val)
- * @reg: Register offset
- * @val: Value to write
- *
- * A write to the MAX7301 means one message with one transfer
- *
- * Returns 0 if successful or a negative value on error
- */
-static int max7301_write(struct spi_device *spi, unsigned int reg, unsigned int val)
 {
+        struct spi_device *spi = to_spi_device(dev);
        u16 word = ((reg & 0x7F) << 8) | (val & 0xFF);
        return spi_write(spi, (const u8 *)&word, sizeof(word));
 }
-/**
+/* A read from the MAX7301 means two transfers; here, one message each */
- * max7301_read - Read back register content
- * @spi: The SPI device
+static int max7301_spi_read(struct device *dev, unsigned int reg)
- * @reg: Register offset
- *
- * A read from the MAX7301 means two transfers; here, one message each
- *
- * Returns positive 8 bit value from device if successful or a
- * negative value on error
- */
-static int max7301_read(struct spi_device *spi, unsigned int reg)
 {
        int ret;
        u16 word;
+        struct spi_device *spi = to_spi_device(dev);
        word = 0x8000 | (reg << 8);
        ret = spi_write(spi, (const u8 *)&word, sizeof(word));
@@ -108,125 +51,13 @@ static int max7301_read(struct spi_device *spi, unsigned int reg)
        return word & 0xff;
 }
-static int max7301_direction_input(struct gpio_chip *chip, unsigned offset)
-{
-        struct max7301 *ts = container_of(chip, struct max7301, chip);
-        u8 *config;
-        int ret;
-        /* First 4 pins are unused in the controller */
-        offset += 4;
-        config = &ts->port_config[offset >> 2];
-        mutex_lock(&ts->lock);
-        /* Standard GPIO API doesn't support pull-ups, has to be extended.
-         * Hard-coding no pollup for now. */
-        *config = (*config & ~(3 << (offset & 3))) | (1 << (offset & 3));
-        ret = max7301_write(ts->spi, 0x08 + (offset >> 2), *config);
-        mutex_unlock(&ts->lock);
-        return ret;
-}
-static int __max7301_set(struct max7301 *ts, unsigned offset, int value)
-{
-        if (value) {
-                ts->out_level |= 1 << offset;
-                return max7301_write(ts->spi, 0x20 + offset, 0x01);
-        } else {
-                ts->out_level &= ~(1 << offset);
-                return max7301_write(ts->spi, 0x20 + offset, 0x00);
-        }
-}
-static int max7301_direction_output(struct gpio_chip *chip, unsigned offset,
-                                    int value)
-{
-        struct max7301 *ts = container_of(chip, struct max7301, chip);
-        u8 *config;
-        int ret;
-        /* First 4 pins are unused in the controller */
-        offset += 4;
-        config = &ts->port_config[offset >> 2];
-        mutex_lock(&ts->lock);
-        *config = (*config & ~(3 << (offset & 3))) | (1 << (offset & 3));
-        ret = __max7301_set(ts, offset, value);
-        if (!ret)
-                ret = max7301_write(ts->spi, 0x08 + (offset >> 2), *config);
-        mutex_unlock(&ts->lock);
-        return ret;
-}
-static int max7301_get(struct gpio_chip *chip, unsigned offset)
-{
-        struct max7301 *ts = container_of(chip, struct max7301, chip);
-        int config, level = -EINVAL;
-        /* First 4 pins are unused in the controller */
-        offset += 4;
-        mutex_lock(&ts->lock);
-        config = (ts->port_config[offset >> 2] >> ((offset & 3) * 2)) & 3;
-        switch (config) {
-        case 1:
-                /* Output: return cached level */
-                level =  !!(ts->out_level & (1 << offset));
-                break;
-        case 2:
-        case 3:
-                /* Input: read out */
-                level = max7301_read(ts->spi, 0x20 + offset) & 0x01;
-        }
-        mutex_unlock(&ts->lock);
-        return level;
-}
-static void max7301_set(struct gpio_chip *chip, unsigned offset, int value)
-{
-        struct max7301 *ts = container_of(chip, struct max7301, chip);
-        /* First 4 pins are unused in the controller */
-        offset += 4;
-        mutex_lock(&ts->lock);
-        __max7301_set(ts, offset, value);
-        mutex_unlock(&ts->lock);
-}
 static int __devinit max7301_probe(struct spi_device *spi)
 {
        struct max7301 *ts;
-        struct max7301_platform_data *pdata;
+        int ret;
-        int i, ret;
-        pdata = spi->dev.platform_data;
-        if (!pdata || !pdata->base) {
-                dev_dbg(&spi->dev, "incorrect or missing platform data\n");
-                return -EINVAL;
-        }
-        /*
+        /* bits_per_word cannot be configured in platform data */
-         * bits_per_word cannot be configured in platform data
-         */
        spi->bits_per_word = 16;
        ret = spi_setup(spi);
        if (ret < 0)
                return ret;
@@ -235,90 +66,35 @@ static int __devinit max7301_probe(struct spi_device *spi)
        if (!ts)
                return -ENOMEM;
-        mutex_init(&ts->lock);
+        ts->read = max7301_spi_read;
+        ts->write = max7301_spi_write;
-        dev_set_drvdata(&spi->dev, ts);
+        ts->dev = &spi->dev;
-        /* Power up the chip and disable IRQ output */
+        ret = __max730x_probe(ts);
-        max7301_write(spi, 0x04, 0x01);
-        ts->spi = spi;
-        ts->chip.label = DRIVER_NAME,
-        ts->chip.direction_input = max7301_direction_input;
-        ts->chip.get = max7301_get;
-        ts->chip.direction_output = max7301_direction_output;
-        ts->chip.set = max7301_set;
-        ts->chip.base = pdata->base;
-        ts->chip.ngpio = PIN_NUMBER;
-        ts->chip.can_sleep = 1;
-        ts->chip.dev = &spi->dev;
-        ts->chip.owner = THIS_MODULE;
-        /*
-         * tristate all pins in hardware and cache the
-         * register values for later use.
-         */
-        for (i = 1; i < 8; i++) {
-                int j;
-                /* 0xAA means input with internal pullup disabled */
-                max7301_write(spi, 0x08 + i, 0xAA);
-                ts->port_config[i] = 0xAA;
-                for (j = 0; j < 4; j++) {
-                        int offset = (i - 1) * 4 + j;
-                        ret = max7301_direction_input(&ts->chip, offset);
-                        if (ret)
-                                goto exit_destroy;
-                }
-        }
-        ret = gpiochip_add(&ts->chip);
        if (ret)
-                goto exit_destroy;
+                kfree(ts);
-        return ret;
-exit_destroy:
-        dev_set_drvdata(&spi->dev, NULL);
-        mutex_destroy(&ts->lock);
-        kfree(ts);
        return ret;
 }
 static int __devexit max7301_remove(struct spi_device *spi)
 {
-        struct max7301 *ts;
+        return __max730x_remove(&spi->dev);
-        int ret;
-        ts = dev_get_drvdata(&spi->dev);
-        if (ts == NULL)
-                return -ENODEV;
-        dev_set_drvdata(&spi->dev, NULL);
-        /* Power down the chip and disable IRQ output */
-        max7301_write(spi, 0x04, 0x00);
-        ret = gpiochip_remove(&ts->chip);
-        if (!ret) {
-                mutex_destroy(&ts->lock);
-                kfree(ts);
-        } else
-                dev_err(&spi->dev, "Failed to remove the GPIO controller: %d\n",
-                        ret);
-        return ret;
 }
+static const struct spi_device_id max7301_id[] = {
+        { "max7301", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(spi, max7301_id);
 static struct spi_driver max7301_driver = {
        .driver = {
-                .name           = DRIVER_NAME,
+                .name = "max7301",
-                .owner          = THIS_MODULE,
+                .owner = THIS_MODULE,
        },
-        .probe          = max7301_probe,
+        .probe = max7301_probe,
-        .remove         = __devexit_p(max7301_remove),
+        .remove = __devexit_p(max7301_remove),
+        .id_table = max7301_id,
 };
 static int __init max7301_init(void)
@@ -336,7 +112,6 @@ static void __exit max7301_exit(void)
 }
 module_exit(max7301_exit);
-MODULE_AUTHOR("Juergen Beisert");
+MODULE_AUTHOR("Juergen Beisert, Wolfram Sang");
 MODULE_LICENSE("GPL v2");
-MODULE_DESCRIPTION("MAX7301 SPI based GPIO-Expander");
+MODULE_DESCRIPTION("MAX7301 GPIO-Expander");
-MODULE_ALIAS("spi:" DRIVER_NAME);
diff --git a/drivers/gpio/max730x.c b/drivers/gpio/max730x.c
new file mode 100644
index 000000000000..c9bced55f82b
--- /dev/null
+++ b/drivers/gpio/max730x.c
@@ -0,0 +1,244 @@
+/**
+ * drivers/gpio/max7301.c
+ *
+ * Copyright (C) 2006 Juergen Beisert, Pengutronix
+ * Copyright (C) 2008 Guennadi Liakhovetski, Pengutronix
+ * Copyright (C) 2009 Wolfram Sang, Pengutronix
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * The Maxim MAX7300/1 device is an I2C/SPI driven GPIO expander. There are
+ * 28 GPIOs. 8 of them can trigger an interrupt. See datasheet for more
+ * details
+ * Note:
+ * - DIN must be stable at the rising edge of clock.
+ * - when writing:
+ *   - always clock in 16 clocks at once
+ *   - at DIN: D15 first, D0 last
+ *   - D0..D7 = databyte, D8..D14 = commandbyte
+ *   - D15 = low -> write command
+ * - when reading
+ *   - always clock in 16 clocks at once
+ *   - at DIN: D15 first, D0 last
+ *   - D0..D7 = dummy, D8..D14 = register address
+ *   - D15 = high -> read command
+ *   - raise CS and assert it again
+ *   - always clock in 16 clocks at once
+ *   - at DOUT: D15 first, D0 last
+ *   - D0..D7 contains the data from the first cycle
+ *
+ * The driver exports a standard gpiochip interface
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/spi/max7301.h>
+#include <linux/gpio.h>
+/*
+ * Pin configurations, see MAX7301 datasheet page 6
+ */
+#define PIN_CONFIG_MASK 0x03
+#define PIN_CONFIG_IN_PULLUP 0x03
+#define PIN_CONFIG_IN_WO_PULLUP 0x02
+#define PIN_CONFIG_OUT 0x01
+#define PIN_NUMBER 28
+static int max7301_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        struct max7301 *ts = container_of(chip, struct max7301, chip);
+        u8 *config;
+        u8 offset_bits;
+        int ret;
+        /* First 4 pins are unused in the controller */
+        offset += 4;
+        offset_bits = (offset & 3) << 1;
+        config = &ts->port_config[offset >> 2];
+        mutex_lock(&ts->lock);
+        /* Standard GPIO API doesn't support pull-ups, has to be extended.
+         * Hard-coding no pollup for now. */
+        *config = (*config & ~(PIN_CONFIG_MASK << offset_bits))
+                           | (PIN_CONFIG_IN_WO_PULLUP << offset_bits);
+        ret = ts->write(ts->dev, 0x08 + (offset >> 2), *config);
+        mutex_unlock(&ts->lock);
+        return ret;
+}
+static int __max7301_set(struct max7301 *ts, unsigned offset, int value)
+{
+        if (value) {
+                ts->out_level |= 1 << offset;
+                return ts->write(ts->dev, 0x20 + offset, 0x01);
+        } else {
+                ts->out_level &= ~(1 << offset);
+                return ts->write(ts->dev, 0x20 + offset, 0x00);
+        }
+}
+static int max7301_direction_output(struct gpio_chip *chip, unsigned offset,
+                                    int value)
+{
+        struct max7301 *ts = container_of(chip, struct max7301, chip);
+        u8 *config;
+        u8 offset_bits;
+        int ret;
+        /* First 4 pins are unused in the controller */
+        offset += 4;
+        offset_bits = (offset & 3) << 1;
+        config = &ts->port_config[offset >> 2];
+        mutex_lock(&ts->lock);
+        *config = (*config & ~(PIN_CONFIG_MASK << offset_bits))
+                           | (PIN_CONFIG_OUT << offset_bits);
+        ret = __max7301_set(ts, offset, value);
+        if (!ret)
+                ret = ts->write(ts->dev, 0x08 + (offset >> 2), *config);
+        mutex_unlock(&ts->lock);
+        return ret;
+}
+static int max7301_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct max7301 *ts = container_of(chip, struct max7301, chip);
+        int config, level = -EINVAL;
+        /* First 4 pins are unused in the controller */
+        offset += 4;
+        mutex_lock(&ts->lock);
+        config = (ts->port_config[offset >> 2] >> ((offset & 3) << 1))
+                        & PIN_CONFIG_MASK;
+        switch (config) {
+        case PIN_CONFIG_OUT:
+                /* Output: return cached level */
+                level =  !!(ts->out_level & (1 << offset));
+                break;
+        case PIN_CONFIG_IN_WO_PULLUP:
+        case PIN_CONFIG_IN_PULLUP:
+                /* Input: read out */
+                level = ts->read(ts->dev, 0x20 + offset) & 0x01;
+        }
+        mutex_unlock(&ts->lock);
+        return level;
+}
+static void max7301_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct max7301 *ts = container_of(chip, struct max7301, chip);
+        /* First 4 pins are unused in the controller */
+        offset += 4;
+        mutex_lock(&ts->lock);
+        __max7301_set(ts, offset, value);
+        mutex_unlock(&ts->lock);
+}
+int __devinit __max730x_probe(struct max7301 *ts)
+{
+        struct device *dev = ts->dev;
+        struct max7301_platform_data *pdata;
+        int i, ret;
+        pdata = dev->platform_data;
+        if (!pdata || !pdata->base) {
+                dev_err(dev, "incorrect or missing platform data\n");
+                return -EINVAL;
+        }
+        mutex_init(&ts->lock);
+        dev_set_drvdata(dev, ts);
+        /* Power up the chip and disable IRQ output */
+        ts->write(dev, 0x04, 0x01);
+        ts->chip.label = dev->driver->name;
+        ts->chip.direction_input = max7301_direction_input;
+        ts->chip.get = max7301_get;
+        ts->chip.direction_output = max7301_direction_output;
+        ts->chip.set = max7301_set;
+        ts->chip.base = pdata->base;
+        ts->chip.ngpio = PIN_NUMBER;
+        ts->chip.can_sleep = 1;
+        ts->chip.dev = dev;
+        ts->chip.owner = THIS_MODULE;
+        /*
+         * tristate all pins in hardware and cache the
+         * register values for later use.
+         */
+        for (i = 1; i < 8; i++) {
+                int j;
+                /* 0xAA means input with internal pullup disabled */
+                ts->write(dev, 0x08 + i, 0xAA);
+                ts->port_config[i] = 0xAA;
+                for (j = 0; j < 4; j++) {
+                        int offset = (i - 1) * 4 + j;
+                        ret = max7301_direction_input(&ts->chip, offset);
+                        if (ret)
+                                goto exit_destroy;
+                }
+        }
+        ret = gpiochip_add(&ts->chip);
+        if (ret)
+                goto exit_destroy;
+        return ret;
+exit_destroy:
+        dev_set_drvdata(dev, NULL);
+        mutex_destroy(&ts->lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(__max730x_probe);
+int __devexit __max730x_remove(struct device *dev)
+{
+        struct max7301 *ts = dev_get_drvdata(dev);
+        int ret;
+        if (ts == NULL)
+                return -ENODEV;
+        dev_set_drvdata(dev, NULL);
+        /* Power down the chip and disable IRQ output */
+        ts->write(dev, 0x04, 0x00);
+        ret = gpiochip_remove(&ts->chip);
+        if (!ret) {
+                mutex_destroy(&ts->lock);
+                kfree(ts);
+        } else
+                dev_err(dev, "Failed to remove GPIO controller: %d\n", ret);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(__max730x_remove);
diff --git a/drivers/gpio/pca953x.c b/drivers/gpio/pca953x.c
index 6a2fb3fbb3d9..ab5daab14bc2 100644
--- a/drivers/gpio/pca953x.c
+++ b/drivers/gpio/pca953x.c
@@ -14,6 +14,8 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/gpio.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
 #include <linux/i2c.h>
 #include <linux/i2c/pca953x.h>
 #ifdef CONFIG_OF_GPIO
@@ -26,23 +28,28 @@
 #define PCA953X_INVERT         2
 #define PCA953X_DIRECTION      3
+#define PCA953X_GPIOS          0x00FF
+#define PCA953X_INT            0x0100
 static const struct i2c_device_id pca953x_id[] = {
-        { "pca9534", 8, },
+        { "pca9534", 8  | PCA953X_INT, },
-        { "pca9535", 16, },
+        { "pca9535", 16 | PCA953X_INT, },
        { "pca9536", 4, },
-        { "pca9537", 4, },
+        { "pca9537", 4  | PCA953X_INT, },
-        { "pca9538", 8, },
+        { "pca9538", 8  | PCA953X_INT, },
-        { "pca9539", 16, },
+        { "pca9539", 16 | PCA953X_INT, },
-        { "pca9554", 8, },
+        { "pca9554", 8  | PCA953X_INT, },
-        { "pca9555", 16, },
+        { "pca9555", 16 | PCA953X_INT, },
        { "pca9556", 8, },
        { "pca9557", 8, },
        { "max7310", 8, },
-        { "max7315", 8, },
+        { "max7312", 16 | PCA953X_INT, },
-        { "pca6107", 8, },
+        { "max7313", 16 | PCA953X_INT, },
-        { "tca6408", 8, },
+        { "max7315", 8  | PCA953X_INT, },
-        { "tca6416", 16, },
+        { "pca6107", 8  | PCA953X_INT, },
+        { "tca6408", 8  | PCA953X_INT, },
+        { "tca6416", 16 | PCA953X_INT, },
        /* NYET:  { "tca6424", 24, }, */
        { }
 };
@@ -53,6 +60,15 @@ struct pca953x_chip {
        uint16_t reg_output;
        uint16_t reg_direction;
+#ifdef CONFIG_GPIO_PCA953X_IRQ
+        struct mutex irq_lock;
+        uint16_t irq_mask;
+        uint16_t irq_stat;
+        uint16_t irq_trig_raise;
+        uint16_t irq_trig_fall;
+        int      irq_base;
+#endif
        struct i2c_client *client;
        struct pca953x_platform_data *dyn_pdata;
        struct gpio_chip gpio_chip;
@@ -202,6 +218,210 @@ static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
        gc->names = chip->names;
 }
+#ifdef CONFIG_GPIO_PCA953X_IRQ
+static int pca953x_gpio_to_irq(struct gpio_chip *gc, unsigned off)
+{
+        struct pca953x_chip *chip;
+        chip = container_of(gc, struct pca953x_chip, gpio_chip);
+        return chip->irq_base + off;
+}
+static void pca953x_irq_mask(unsigned int irq)
+{
+        struct pca953x_chip *chip = get_irq_chip_data(irq);
+        chip->irq_mask &= ~(1 << (irq - chip->irq_base));
+}
+static void pca953x_irq_unmask(unsigned int irq)
+{
+        struct pca953x_chip *chip = get_irq_chip_data(irq);
+        chip->irq_mask |= 1 << (irq - chip->irq_base);
+}
+static void pca953x_irq_bus_lock(unsigned int irq)
+{
+        struct pca953x_chip *chip = get_irq_chip_data(irq);
+        mutex_lock(&chip->irq_lock);
+}
+static void pca953x_irq_bus_sync_unlock(unsigned int irq)
+{
+        struct pca953x_chip *chip = get_irq_chip_data(irq);
+        mutex_unlock(&chip->irq_lock);
+}
+static int pca953x_irq_set_type(unsigned int irq, unsigned int type)
+{
+        struct pca953x_chip *chip = get_irq_chip_data(irq);
+        uint16_t level = irq - chip->irq_base;
+        uint16_t mask = 1 << level;
+        if (!(type & IRQ_TYPE_EDGE_BOTH)) {
+                dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
+                        irq, type);
+                return -EINVAL;
+        }
+        if (type & IRQ_TYPE_EDGE_FALLING)
+                chip->irq_trig_fall |= mask;
+        else
+                chip->irq_trig_fall &= ~mask;
+        if (type & IRQ_TYPE_EDGE_RISING)
+                chip->irq_trig_raise |= mask;
+        else
+                chip->irq_trig_raise &= ~mask;
+        return pca953x_gpio_direction_input(&chip->gpio_chip, level);
+}
+static struct irq_chip pca953x_irq_chip = {
+        .name                   = "pca953x",
+        .mask                   = pca953x_irq_mask,
+        .unmask                 = pca953x_irq_unmask,
+        .bus_lock               = pca953x_irq_bus_lock,
+        .bus_sync_unlock        = pca953x_irq_bus_sync_unlock,
+        .set_type               = pca953x_irq_set_type,
+};
+static uint16_t pca953x_irq_pending(struct pca953x_chip *chip)
+{
+        uint16_t cur_stat;
+        uint16_t old_stat;
+        uint16_t pending;
+        uint16_t trigger;
+        int ret;
+        ret = pca953x_read_reg(chip, PCA953X_INPUT, &cur_stat);
+        if (ret)
+                return 0;
+        /* Remove output pins from the equation */
+        cur_stat &= chip->reg_direction;
+        old_stat = chip->irq_stat;
+        trigger = (cur_stat ^ old_stat) & chip->irq_mask;
+        if (!trigger)
+                return 0;
+        chip->irq_stat = cur_stat;
+        pending = (old_stat & chip->irq_trig_fall) |
+                  (cur_stat & chip->irq_trig_raise);
+        pending &= trigger;
+        return pending;
+}
+static irqreturn_t pca953x_irq_handler(int irq, void *devid)
+{
+        struct pca953x_chip *chip = devid;
+        uint16_t pending;
+        uint16_t level;
+        pending = pca953x_irq_pending(chip);
+        if (!pending)
+                return IRQ_HANDLED;
+        do {
+                level = __ffs(pending);
+                handle_nested_irq(level + chip->irq_base);
+                pending &= ~(1 << level);
+        } while (pending);
+        return IRQ_HANDLED;
+}
+static int pca953x_irq_setup(struct pca953x_chip *chip,
+                             const struct i2c_device_id *id)
+{
+        struct i2c_client *client = chip->client;
+        struct pca953x_platform_data *pdata = client->dev.platform_data;
+        int ret;
+        if (pdata->irq_base && (id->driver_data & PCA953X_INT)) {
+                int lvl;
+                ret = pca953x_read_reg(chip, PCA953X_INPUT,
+                                       &chip->irq_stat);
+                if (ret)
+                        goto out_failed;
+                /*
+                 * There is no way to know which GPIO line generated the
+                 * interrupt.  We have to rely on the previous read for
+                 * this purpose.
+                 */
+                chip->irq_stat &= chip->reg_direction;
+                chip->irq_base = pdata->irq_base;
+                mutex_init(&chip->irq_lock);
+                for (lvl = 0; lvl < chip->gpio_chip.ngpio; lvl++) {
+                        int irq = lvl + chip->irq_base;
+                        set_irq_chip_data(irq, chip);
+                        set_irq_chip_and_handler(irq, &pca953x_irq_chip,
+                                                 handle_edge_irq);
+                        set_irq_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+                        set_irq_flags(irq, IRQF_VALID);
+#else
+                        set_irq_noprobe(irq);
+#endif
+                }
+                ret = request_threaded_irq(client->irq,
+                                           NULL,
+                                           pca953x_irq_handler,
+                                           IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                           dev_name(&client->dev), chip);
+                if (ret) {
+                        dev_err(&client->dev, "failed to request irq %d\n",
+                                client->irq);
+                        goto out_failed;
+                }
+                chip->gpio_chip.to_irq = pca953x_gpio_to_irq;
+        }
+        return 0;
+out_failed:
+        chip->irq_base = 0;
+        return ret;
+}
+static void pca953x_irq_teardown(struct pca953x_chip *chip)
+{
+        if (chip->irq_base)
+                free_irq(chip->client->irq, chip);
+}
+#else /* CONFIG_GPIO_PCA953X_IRQ */
+static int pca953x_irq_setup(struct pca953x_chip *chip,
+                             const struct i2c_device_id *id)
+{
+        struct i2c_client *client = chip->client;
+        struct pca953x_platform_data *pdata = client->dev.platform_data;
+        if (pdata->irq_base && (id->driver_data & PCA953X_INT))
+                dev_warn(&client->dev, "interrupt support not compiled in\n");
+        return 0;
+}
+static void pca953x_irq_teardown(struct pca953x_chip *chip)
+{
+}
+#endif
 /*
 * Handlers for alternative sources of platform_data
 */
@@ -286,7 +506,7 @@ static int __devinit pca953x_probe(struct i2c_client *client,
        /* initialize cached registers from their original values.
         * we can't share this chip with another i2c master.
         */
-        pca953x_setup_gpio(chip, id->driver_data);
+        pca953x_setup_gpio(chip, id->driver_data & PCA953X_GPIOS);
        ret = pca953x_read_reg(chip, PCA953X_OUTPUT, &chip->reg_output);
        if (ret)
@@ -301,6 +521,9 @@ static int __devinit pca953x_probe(struct i2c_client *client,
        if (ret)
                goto out_failed;
+        ret = pca953x_irq_setup(chip, id);
+        if (ret)
+                goto out_failed;
        ret = gpiochip_add(&chip->gpio_chip);
        if (ret)
@@ -317,6 +540,7 @@ static int __devinit pca953x_probe(struct i2c_client *client,
        return 0;
 out_failed:
+        pca953x_irq_teardown(chip);
        kfree(chip->dyn_pdata);
        kfree(chip);
        return ret;
@@ -345,6 +569,7 @@ static int pca953x_remove(struct i2c_client *client)
                return ret;
        }
+        pca953x_irq_teardown(chip);
        kfree(chip->dyn_pdata);
        kfree(chip);
        return 0;
diff --git a/drivers/gpio/pl061.c b/drivers/gpio/pl061.c
index 4ee4c8367a3f..3ad1eeb49609 100644
--- a/drivers/gpio/pl061.c
+++ b/drivers/gpio/pl061.c
@@ -219,7 +219,7 @@ static void pl061_irq_handler(unsigned irq, struct irq_desc *desc)
                if (pending == 0)
                        continue;
-                for_each_bit(offset, &pending, PL061_GPIO_NR)
+                for_each_set_bit(offset, &pending, PL061_GPIO_NR)
                        generic_handle_irq(pl061_to_irq(&chip->gc, offset));
        }
        desc->chip->unmask(irq);
diff --git a/drivers/gpio/timbgpio.c b/drivers/gpio/timbgpio.c
index a4d344ba8e5c..d4295fa5369e 100644
--- a/drivers/gpio/timbgpio.c
+++ b/drivers/gpio/timbgpio.c
@@ -23,6 +23,7 @@
 #include <linux/module.h>
 #include <linux/gpio.h>
 #include <linux/platform_device.h>
+#include <linux/irq.h>
 #include <linux/io.h>
 #include <linux/timb_gpio.h>
 #include <linux/interrupt.h>
@@ -37,6 +38,8 @@
 #define TGPIO_ICR       0x14
 #define TGPIO_FLR       0x18
 #define TGPIO_LVR       0x1c
+#define TGPIO_VER       0x20
+#define TGPIO_BFLR      0x24
 struct timbgpio {
        void __iomem            *membase;
@@ -125,17 +128,23 @@ static int timbgpio_irq_type(unsigned irq, unsigned trigger)
        struct timbgpio *tgpio = get_irq_chip_data(irq);
        int offset = irq - tgpio->irq_base;
        unsigned long flags;
-        u32 lvr, flr;
+        u32 lvr, flr, bflr = 0;
+        u32 ver;
        if (offset < 0 || offset > tgpio->gpio.ngpio)
                return -EINVAL;
+        ver = ioread32(tgpio->membase + TGPIO_VER);
        spin_lock_irqsave(&tgpio->lock, flags);
        lvr = ioread32(tgpio->membase + TGPIO_LVR);
        flr = ioread32(tgpio->membase + TGPIO_FLR);
+        if (ver > 2)
+                bflr = ioread32(tgpio->membase + TGPIO_BFLR);
        if (trigger & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW)) {
+                bflr &= ~(1 << offset);
                flr &= ~(1 << offset);
                if (trigger & IRQ_TYPE_LEVEL_HIGH)
                        lvr |= 1 << offset;
@@ -143,21 +152,27 @@ static int timbgpio_irq_type(unsigned irq, unsigned trigger)
                        lvr &= ~(1 << offset);
        }
-        if ((trigger & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH)
+        if ((trigger & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH) {
-                return -EINVAL;
+                if (ver < 3)
-        else {
+                        return -EINVAL;
+                else {
+                        flr |= 1 << offset;
+                        bflr |= 1 << offset;
+                }
+        } else {
+                bflr &= ~(1 << offset);
                flr |= 1 << offset;
-                /* opposite compared to the datasheet, but it mirrors the
-                 * reality
-                 */
                if (trigger & IRQ_TYPE_EDGE_FALLING)
-                        lvr |= 1 << offset;
-                else
                        lvr &= ~(1 << offset);
+                else
+                        lvr |= 1 << offset;
        }
        iowrite32(lvr, tgpio->membase + TGPIO_LVR);
        iowrite32(flr, tgpio->membase + TGPIO_FLR);
+        if (ver > 2)
+                iowrite32(bflr, tgpio->membase + TGPIO_BFLR);
        iowrite32(1 << offset, tgpio->membase + TGPIO_ICR);
        spin_unlock_irqrestore(&tgpio->lock, flags);
@@ -174,7 +189,7 @@ static void timbgpio_irq(unsigned int irq, struct irq_desc *desc)
        ipr = ioread32(tgpio->membase + TGPIO_IPR);
        iowrite32(ipr, tgpio->membase + TGPIO_ICR);
-        for_each_bit(offset, &ipr, tgpio->gpio.ngpio)
+        for_each_set_bit(offset, &ipr, tgpio->gpio.ngpio)
                generic_handle_irq(timbgpio_to_irq(&tgpio->gpio, offset));
 }
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index 305c59003963..3d2ab03f1296 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -9,6 +9,7 @@ menuconfig DRM
        depends on (AGP || AGP=n) && PCI && !EMULATED_CMPXCHG && MMU
        select I2C
        select I2C_ALGOBIT
+        select LIST_SORT
        help
          Kernel-level support for the Direct Rendering Infrastructure (DRI)
          introduced in XFree86 4.0. If you say Y here, you need to select
diff --git a/drivers/hwmon/adcxx.c b/drivers/hwmon/adcxx.c
index 5e9e095f1136..74d9c5195e44 100644
--- a/drivers/hwmon/adcxx.c
+++ b/drivers/hwmon/adcxx.c
@@ -62,18 +62,23 @@ static ssize_t adcxx_read(struct device *dev,
        struct spi_device *spi = to_spi_device(dev);
        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
        struct adcxx *adc = dev_get_drvdata(&spi->dev);
-        u8 tx_buf[2] = { attr->index << 3 }; /* other bits are don't care */
+        u8 tx_buf[2];
        u8 rx_buf[2];
        int status;
-        int value;
+        u32 value;
        if (mutex_lock_interruptible(&adc->lock))
                return -ERESTARTSYS;
-        status = spi_write_then_read(spi, tx_buf, sizeof(tx_buf),
+        if (adc->channels == 1) {
-                                        rx_buf, sizeof(rx_buf));
+                status = spi_read(spi, rx_buf, sizeof(rx_buf));
+        } else {
+                tx_buf[0] = attr->index << 3; /* other bits are don't care */
+                status = spi_write_then_read(spi, tx_buf, sizeof(tx_buf),
+                                                rx_buf, sizeof(rx_buf));
+        }
        if (status < 0) {
-                dev_warn(dev, "spi_write_then_read failed with status %d\n",
+                dev_warn(dev, "SPI synch. transfer failed with status %d\n",
                                status);
                goto out;
        }
diff --git a/drivers/hwmon/vt8231.c b/drivers/hwmon/vt8231.c
index d47b4c9949c2..e6078c9f0e27 100644
--- a/drivers/hwmon/vt8231.c
+++ b/drivers/hwmon/vt8231.c
@@ -948,8 +948,7 @@ static int __devinit vt8231_pci_probe(struct pci_dev *dev,
        address = val & ~(VT8231_EXTENT - 1);
        if (address == 0) {
-                dev_err(&dev->dev, "base address not set -\
+                dev_err(&dev->dev, "base address not set - upgrade BIOS or use force_addr=0xaddr\n");
-                                 upgrade BIOS or use force_addr=0xaddr\n");
                return -ENODEV;
        }
diff --git a/drivers/i2c/busses/i2c-designware.c b/drivers/i2c/busses/i2c-designware.c
index 9e18ef97f156..3e72b69aa7f8 100644
--- a/drivers/i2c/busses/i2c-designware.c
+++ b/drivers/i2c/busses/i2c-designware.c
@@ -497,13 +497,13 @@ static int i2c_dw_handle_tx_abort(struct dw_i2c_dev *dev)
        int i;
        if (abort_source & DW_IC_TX_ABRT_NOACK) {
-                for_each_bit(i, &abort_source, ARRAY_SIZE(abort_sources))
+                for_each_set_bit(i, &abort_source, ARRAY_SIZE(abort_sources))
                        dev_dbg(dev->dev,
                                "%s: %s\n", __func__, abort_sources[i]);
                return -EREMOTEIO;
        }
-        for_each_bit(i, &abort_source, ARRAY_SIZE(abort_sources))
+        for_each_set_bit(i, &abort_source, ARRAY_SIZE(abort_sources))
                dev_err(dev->dev, "%s: %s\n", __func__, abort_sources[i]);
        if (abort_source & DW_IC_TX_ARB_LOST)
diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c
index 7522008fda86..58463da814d1 100644
--- a/drivers/infiniband/core/mad.c
+++ b/drivers/infiniband/core/mad.c
@@ -1193,10 +1193,7 @@ static int method_in_use(struct ib_mad_mgmt_method_table **method,
 {
        int i;
-        for (i = find_first_bit(mad_reg_req->method_mask, IB_MGMT_MAX_METHODS);
+        for_each_set_bit(i, mad_reg_req->method_mask, IB_MGMT_MAX_METHODS) {
-             i < IB_MGMT_MAX_METHODS;
-             i = find_next_bit(mad_reg_req->method_mask, IB_MGMT_MAX_METHODS,
-                               1+i)) {
                if ((*method)->agent[i]) {
                        printk(KERN_ERR PFX "Method %d already in use\n", i);
                        return -EINVAL;
@@ -1330,13 +1327,9 @@ static int add_nonoui_reg_req(struct ib_mad_reg_req *mad_reg_req,
                goto error3;
        /* Finally, add in methods being registered */
-        for (i = find_first_bit(mad_reg_req->method_mask,
+        for_each_set_bit(i, mad_reg_req->method_mask, IB_MGMT_MAX_METHODS)
-                                IB_MGMT_MAX_METHODS);
-             i < IB_MGMT_MAX_METHODS;
-             i = find_next_bit(mad_reg_req->method_mask, IB_MGMT_MAX_METHODS,
-                               1+i)) {
                (*method)->agent[i] = agent_priv;
-        }
        return 0;
 error3:
@@ -1429,13 +1422,9 @@ check_in_use:
                goto error4;
        /* Finally, add in methods being registered */
-        for (i = find_first_bit(mad_reg_req->method_mask,
+        for_each_set_bit(i, mad_reg_req->method_mask, IB_MGMT_MAX_METHODS)
-                                IB_MGMT_MAX_METHODS);
-             i < IB_MGMT_MAX_METHODS;
-             i = find_next_bit(mad_reg_req->method_mask, IB_MGMT_MAX_METHODS,
-                               1+i)) {
                (*method)->agent[i] = agent_priv;
-        }
        return 0;
 error4:
diff --git a/drivers/input/touchscreen/mc13783_ts.c b/drivers/input/touchscreen/mc13783_ts.c
index be115b3b65eb..be54fd639aca 100644
--- a/drivers/input/touchscreen/mc13783_ts.c
+++ b/drivers/input/touchscreen/mc13783_ts.c
@@ -44,7 +44,7 @@ static irqreturn_t mc13783_ts_handler(int irq, void *data)
 {
        struct mc13783_ts_priv *priv = data;
-        mc13783_ackirq(priv->mc13783, irq);
+        mc13783_irq_ack(priv->mc13783, irq);
        /*
         * Kick off reading coordinates. Note that if work happens already
@@ -135,7 +135,7 @@ static int mc13783_ts_open(struct input_dev *dev)
        mc13783_lock(priv->mc13783);
-        mc13783_ackirq(priv->mc13783, MC13783_IRQ_TS);
+        mc13783_irq_ack(priv->mc13783, MC13783_IRQ_TS);
        ret = mc13783_irq_request(priv->mc13783, MC13783_IRQ_TS,
                mc13783_ts_handler, MC13783_TS_NAME, priv);
diff --git a/drivers/mfd/htc-egpio.c b/drivers/mfd/htc-egpio.c
index aa266e1f69b2..addb846c1e34 100644
--- a/drivers/mfd/htc-egpio.c
+++ b/drivers/mfd/htc-egpio.c
@@ -108,7 +108,7 @@ static void egpio_handler(unsigned int irq, struct irq_desc *desc)
        ack_irqs(ei);
        /* Process all set pins. */
        readval &= ei->irqs_enabled;
-        for_each_bit(irqpin, &readval, ei->nirqs) {
+        for_each_set_bit(irqpin, &readval, ei->nirqs) {
                /* Run irq handler */
                pr_debug("got IRQ %d\n", irqpin);
                irq = ei->irq_start + irqpin;
diff --git a/drivers/mfd/mc13783-core.c b/drivers/mfd/mc13783-core.c
index 735c8a4d164f..62a847e4c2d8 100644
--- a/drivers/mfd/mc13783-core.c
+++ b/drivers/mfd/mc13783-core.c
@@ -225,7 +225,7 @@ int mc13783_reg_rmw(struct mc13783 *mc13783, unsigned int offset,
 }
 EXPORT_SYMBOL(mc13783_reg_rmw);
-int mc13783_mask(struct mc13783 *mc13783, int irq)
+int mc13783_irq_mask(struct mc13783 *mc13783, int irq)
 {
        int ret;
        unsigned int offmask = irq < 24 ? MC13783_IRQMASK0 : MC13783_IRQMASK1;
@@ -245,9 +245,9 @@ int mc13783_mask(struct mc13783 *mc13783, int irq)
        return mc13783_reg_write(mc13783, offmask, mask | irqbit);
 }
-EXPORT_SYMBOL(mc13783_mask);
+EXPORT_SYMBOL(mc13783_irq_mask);
-int mc13783_unmask(struct mc13783 *mc13783, int irq)
+int mc13783_irq_unmask(struct mc13783 *mc13783, int irq)
 {
        int ret;
        unsigned int offmask = irq < 24 ? MC13783_IRQMASK0 : MC13783_IRQMASK1;
@@ -267,7 +267,53 @@ int mc13783_unmask(struct mc13783 *mc13783, int irq)
        return mc13783_reg_write(mc13783, offmask, mask & ~irqbit);
 }
-EXPORT_SYMBOL(mc13783_unmask);
+EXPORT_SYMBOL(mc13783_irq_unmask);
+int mc13783_irq_status(struct mc13783 *mc13783, int irq,
+                int *enabled, int *pending)
+{
+        int ret;
+        unsigned int offmask = irq < 24 ? MC13783_IRQMASK0 : MC13783_IRQMASK1;
+        unsigned int offstat = irq < 24 ? MC13783_IRQSTAT0 : MC13783_IRQSTAT1;
+        u32 irqbit = 1 << (irq < 24 ? irq : irq - 24);
+        if (irq < 0 || irq >= MC13783_NUM_IRQ)
+                return -EINVAL;
+        if (enabled) {
+                u32 mask;
+                ret = mc13783_reg_read(mc13783, offmask, &mask);
+                if (ret)
+                        return ret;
+                *enabled = mask & irqbit;
+        }
+        if (pending) {
+                u32 stat;
+                ret = mc13783_reg_read(mc13783, offstat, &stat);
+                if (ret)
+                        return ret;
+                *pending = stat & irqbit;
+        }
+        return 0;
+}
+EXPORT_SYMBOL(mc13783_irq_status);
+int mc13783_irq_ack(struct mc13783 *mc13783, int irq)
+{
+        unsigned int offstat = irq < 24 ? MC13783_IRQSTAT0 : MC13783_IRQSTAT1;
+        unsigned int val = 1 << (irq < 24 ? irq : irq - 24);
+        BUG_ON(irq < 0 || irq >= MC13783_NUM_IRQ);
+        return mc13783_reg_write(mc13783, offstat, val);
+}
+EXPORT_SYMBOL(mc13783_irq_ack);
 int mc13783_irq_request_nounmask(struct mc13783 *mc13783, int irq,
                irq_handler_t handler, const char *name, void *dev)
@@ -297,7 +343,7 @@ int mc13783_irq_request(struct mc13783 *mc13783, int irq,
        if (ret)
                return ret;
-        ret = mc13783_unmask(mc13783, irq);
+        ret = mc13783_irq_unmask(mc13783, irq);
        if (ret) {
                mc13783->irqhandler[irq] = NULL;
                mc13783->irqdata[irq] = NULL;
@@ -317,7 +363,7 @@ int mc13783_irq_free(struct mc13783 *mc13783, int irq, void *dev)
                        mc13783->irqdata[irq] != dev)
                return -EINVAL;
-        ret = mc13783_mask(mc13783, irq);
+        ret = mc13783_irq_mask(mc13783, irq);
        if (ret)
                return ret;
@@ -333,17 +379,6 @@ static inline irqreturn_t mc13783_irqhandler(struct mc13783 *mc13783, int irq)
        return mc13783->irqhandler[irq](irq, mc13783->irqdata[irq]);
 }
-int mc13783_ackirq(struct mc13783 *mc13783, int irq)
-{
-        unsigned int offstat = irq < 24 ? MC13783_IRQSTAT0 : MC13783_IRQSTAT1;
-        unsigned int val = 1 << (irq < 24 ? irq : irq - 24);
-        BUG_ON(irq < 0 || irq >= MC13783_NUM_IRQ);
-        return mc13783_reg_write(mc13783, offstat, val);
-}
-EXPORT_SYMBOL(mc13783_ackirq);
 /*
 * returns: number of handled irqs or negative error
 * locking: holds mc13783->lock
@@ -422,7 +457,7 @@ static irqreturn_t mc13783_handler_adcdone(int irq, void *data)
 {
        struct mc13783_adcdone_data *adcdone_data = data;
-        mc13783_ackirq(adcdone_data->mc13783, irq);
+        mc13783_irq_ack(adcdone_data->mc13783, irq);
        complete_all(&adcdone_data->done);
@@ -486,7 +521,7 @@ int mc13783_adc_do_conversion(struct mc13783 *mc13783, unsigned int mode,
        dev_dbg(&mc13783->spidev->dev, "%s: request irq\n", __func__);
        mc13783_irq_request(mc13783, MC13783_IRQ_ADCDONE,
                        mc13783_handler_adcdone, __func__, &adcdone_data);
-        mc13783_ackirq(mc13783, MC13783_IRQ_ADCDONE);
+        mc13783_irq_ack(mc13783, MC13783_IRQ_ADCDONE);
        mc13783_reg_write(mc13783, MC13783_REG_ADC_0, adc0);
        mc13783_reg_write(mc13783, MC13783_REG_ADC_1, adc1);
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index e3551d20464f..d16af6a423fb 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -212,6 +212,15 @@ config CS5535_MFGPT_DEFAULT_IRQ
          want to use a different IRQ by default.  This is here for
          architectures to set as necessary.
+config CS5535_CLOCK_EVENT_SRC
+        tristate "CS5535/CS5536 high-res timer (MFGPT) events"
+        depends on GENERIC_TIME && GENERIC_CLOCKEVENTS && CS5535_MFGPT
+        help
+          This driver provides a clock event source based on the MFGPT
+          timer(s) in the CS5535 and CS5536 companion chips.
+          MFGPTs have a better resolution and max interval than the
+          generic PIT, and are suitable for use as high-res timers.
 config HP_ILO
        tristate "Channel interface driver for HP iLO/iLO2 processor"
        depends on PCI
diff --git a/drivers/misc/iwmc3200top/main.c b/drivers/misc/iwmc3200top/main.c
index dd0a3913bf6d..3b7292a5cea9 100644
--- a/drivers/misc/iwmc3200top/main.c
+++ b/drivers/misc/iwmc3200top/main.c
@@ -597,8 +597,6 @@ static void iwmct_remove(struct sdio_func *func)
        struct iwmct_work_struct *read_req;
        struct iwmct_priv *priv = sdio_get_drvdata(func);
-        priv = sdio_get_drvdata(func);
        LOG_INFO(priv, INIT, "enter\n");
        sdio_claim_host(func);
diff --git a/drivers/misc/lkdtm.c b/drivers/misc/lkdtm.c
index 3648b23d5c92..4a0648301fdf 100644
--- a/drivers/misc/lkdtm.c
+++ b/drivers/misc/lkdtm.c
@@ -26,21 +26,9 @@
 * It is adapted from the Linux Kernel Dump Test Tool by
 * Fernando Luis Vazquez Cao <http://lkdtt.sourceforge.net>
 *
- * Usage :  insmod lkdtm.ko [recur_count={>0}] cpoint_name=<> cpoint_type=<>
+ * Debugfs support added by Simon Kagstrom <simon.kagstrom@netinsight.net>
- *                                                      [cpoint_count={>0}]
 *
- * recur_count : Recursion level for the stack overflow test. Default is 10.
+ * See Documentation/fault-injection/provoke-crashes.txt for instructions
- *
- * cpoint_name : Crash point where the kernel is to be crashed. It can be
- *               one of INT_HARDWARE_ENTRY, INT_HW_IRQ_EN, INT_TASKLET_ENTRY,
- *               FS_DEVRW, MEM_SWAPOUT, TIMERADD, SCSI_DISPATCH_CMD,
- *               IDE_CORE_CP
- *
- * cpoint_type : Indicates the action to be taken on hitting the crash point.
- *               It can be one of PANIC, BUG, EXCEPTION, LOOP, OVERFLOW
- *
- * cpoint_count : Indicates the number of times the crash point is to be hit
- *                to trigger an action. The default is 10.
 */
 #include <linux/kernel.h>
@@ -53,13 +41,12 @@
 #include <linux/interrupt.h>
 #include <linux/hrtimer.h>
 #include <scsi/scsi_cmnd.h>
+#include <linux/debugfs.h>
 #ifdef CONFIG_IDE
 #include <linux/ide.h>
 #endif
-#define NUM_CPOINTS 8
-#define NUM_CPOINT_TYPES 5
 #define DEFAULT_COUNT 10
 #define REC_NUM_DEFAULT 10
@@ -72,7 +59,8 @@ enum cname {
        MEM_SWAPOUT,
        TIMERADD,
        SCSI_DISPATCH_CMD,
-        IDE_CORE_CP
+        IDE_CORE_CP,
+        DIRECT,
 };
 enum ctype {
@@ -81,7 +69,11 @@ enum ctype {
        BUG,
        EXCEPTION,
        LOOP,
-        OVERFLOW
+        OVERFLOW,
+        CORRUPT_STACK,
+        UNALIGNED_LOAD_STORE_WRITE,
+        OVERWRITE_ALLOCATION,
+        WRITE_AFTER_FREE,
 };
 static char* cp_name[] = {
@@ -92,7 +84,8 @@ static char* cp_name[] = {
        "MEM_SWAPOUT",
        "TIMERADD",
        "SCSI_DISPATCH_CMD",
-        "IDE_CORE_CP"
+        "IDE_CORE_CP",
+        "DIRECT",
 };
 static char* cp_type[] = {
@@ -100,7 +93,11 @@ static char* cp_type[] = {
        "BUG",
        "EXCEPTION",
        "LOOP",
-        "OVERFLOW"
+        "OVERFLOW",
+        "CORRUPT_STACK",
+        "UNALIGNED_LOAD_STORE_WRITE",
+        "OVERWRITE_ALLOCATION",
+        "WRITE_AFTER_FREE",
 };
 static struct jprobe lkdtm;
@@ -193,34 +190,66 @@ int jp_generic_ide_ioctl(ide_drive_t *drive, struct file *file,
 }
 #endif
+/* Return the crashpoint number or NONE if the name is invalid */
+static enum ctype parse_cp_type(const char *what, size_t count)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(cp_type); i++) {
+                if (!strcmp(what, cp_type[i]))
+                        return i + 1;
+        }
+        return NONE;
+}
+static const char *cp_type_to_str(enum ctype type)
+{
+        if (type == NONE || type < 0 || type > ARRAY_SIZE(cp_type))
+                return "None";
+        return cp_type[type - 1];
+}
+static const char *cp_name_to_str(enum cname name)
+{
+        if (name == INVALID || name < 0 || name > ARRAY_SIZE(cp_name))
+                return "INVALID";
+        return cp_name[name - 1];
+}
 static int lkdtm_parse_commandline(void)
 {
        int i;
-        if (cpoint_name == NULL || cpoint_type == NULL ||
+        if (cpoint_count < 1 || recur_count < 1)
-                                        cpoint_count < 1 || recur_count < 1)
                return -EINVAL;
-        for (i = 0; i < NUM_CPOINTS; ++i) {
+        count = cpoint_count;
+        /* No special parameters */
+        if (!cpoint_type && !cpoint_name)
+                return 0;
+        /* Neither or both of these need to be set */
+        if (!cpoint_type || !cpoint_name)
+                return -EINVAL;
+        cptype = parse_cp_type(cpoint_type, strlen(cpoint_type));
+        if (cptype == NONE)
+                return -EINVAL;
+        for (i = 0; i < ARRAY_SIZE(cp_name); i++) {
                if (!strcmp(cpoint_name, cp_name[i])) {
                        cpoint = i + 1;
-                        break;
+                        return 0;
-                }
-        }
-        for (i = 0; i < NUM_CPOINT_TYPES; ++i) {
-                if (!strcmp(cpoint_type, cp_type[i])) {
-                        cptype = i + 1;
-                        break;
                }
        }
-        if (cpoint == INVALID || cptype == NONE)
+        /* Could not find a valid crash point */
-                return -EINVAL;
+        return -EINVAL;
-        count = cpoint_count;
-        return 0;
 }
 static int recursive_loop(int a)
@@ -235,53 +264,92 @@ static int recursive_loop(int a)
                return recursive_loop(a);
 }
-void lkdtm_handler(void)
+static void lkdtm_do_action(enum ctype which)
 {
-        printk(KERN_INFO "lkdtm : Crash point %s of type %s hit\n",
+        switch (which) {
-                                         cpoint_name, cpoint_type);
+        case PANIC:
-        --count;
+                panic("dumptest");
+                break;
+        case BUG:
+                BUG();
+                break;
+        case EXCEPTION:
+                *((int *) 0) = 0;
+                break;
+        case LOOP:
+                for (;;)
+                        ;
+                break;
+        case OVERFLOW:
+                (void) recursive_loop(0);
+                break;
+        case CORRUPT_STACK: {
+                volatile u32 data[8];
+                volatile u32 *p = data;
+                p[12] = 0x12345678;
+                break;
+        }
+        case UNALIGNED_LOAD_STORE_WRITE: {
+                static u8 data[5] __attribute__((aligned(4))) = {1, 2,
+                                3, 4, 5};
+                u32 *p;
+                u32 val = 0x12345678;
+                p = (u32 *)(data + 1);
+                if (*p == 0)
+                        val = 0x87654321;
+                *p = val;
+                 break;
+        }
+        case OVERWRITE_ALLOCATION: {
+                size_t len = 1020;
+                u32 *data = kmalloc(len, GFP_KERNEL);
+                data[1024 / sizeof(u32)] = 0x12345678;
+                kfree(data);
+                break;
+        }
+        case WRITE_AFTER_FREE: {
+                size_t len = 1024;
+                u32 *data = kmalloc(len, GFP_KERNEL);
+                kfree(data);
+                schedule();
+                memset(data, 0x78, len);
+                break;
+        }
+        case NONE:
+        default:
+                break;
+        }
+}
+static void lkdtm_handler(void)
+{
+        count--;
+        printk(KERN_INFO "lkdtm: Crash point %s of type %s hit, trigger in %d rounds\n",
+                        cp_name_to_str(cpoint), cp_type_to_str(cptype), count);
        if (count == 0) {
-                switch (cptype) {
+                lkdtm_do_action(cptype);
-                case NONE:
-                        break;
-                case PANIC:
-                        printk(KERN_INFO "lkdtm : PANIC\n");
-                        panic("dumptest");
-                        break;
-                case BUG:
-                        printk(KERN_INFO "lkdtm : BUG\n");
-                        BUG();
-                        break;
-                case EXCEPTION:
-                        printk(KERN_INFO "lkdtm : EXCEPTION\n");
-                        *((int *) 0) = 0;
-                        break;
-                case LOOP:
-                        printk(KERN_INFO "lkdtm : LOOP\n");
-                        for (;;);
-                        break;
-                case OVERFLOW:
-                        printk(KERN_INFO "lkdtm : OVERFLOW\n");
-                        (void) recursive_loop(0);
-                        break;
-                default:
-                        break;
-                }
                count = cpoint_count;
        }
 }
-static int __init lkdtm_module_init(void)
+static int lkdtm_register_cpoint(enum cname which)
 {
        int ret;
-        if (lkdtm_parse_commandline() == -EINVAL) {
+        cpoint = INVALID;
-                printk(KERN_INFO "lkdtm : Invalid command\n");
+        if (lkdtm.entry != NULL)
-                return -EINVAL;
+                unregister_jprobe(&lkdtm);
-        }
-        switch (cpoint) {
+        switch (which) {
+        case DIRECT:
+                lkdtm_do_action(cptype);
+                return 0;
        case INT_HARDWARE_ENTRY:
                lkdtm.kp.symbol_name = "do_IRQ";
                lkdtm.entry = (kprobe_opcode_t*) jp_do_irq;
@@ -315,28 +383,268 @@ static int __init lkdtm_module_init(void)
                lkdtm.kp.symbol_name = "generic_ide_ioctl";
                lkdtm.entry = (kprobe_opcode_t*) jp_generic_ide_ioctl;
 #else
-                printk(KERN_INFO "lkdtm : Crash point not available\n");
+                printk(KERN_INFO "lkdtm: Crash point not available\n");
+                return -EINVAL;
 #endif
                break;
        default:
-                printk(KERN_INFO "lkdtm : Invalid Crash Point\n");
+                printk(KERN_INFO "lkdtm: Invalid Crash Point\n");
-                break;
+                return -EINVAL;
        }
+        cpoint = which;
        if ((ret = register_jprobe(&lkdtm)) < 0) {
-                printk(KERN_INFO "lkdtm : Couldn't register jprobe\n");
+                printk(KERN_INFO "lkdtm: Couldn't register jprobe\n");
-                return ret;
+                cpoint = INVALID;
+        }
+        return ret;
+}
+static ssize_t do_register_entry(enum cname which, struct file *f,
+                const char __user *user_buf, size_t count, loff_t *off)
+{
+        char *buf;
+        int err;
+        if (count >= PAGE_SIZE)
+                return -EINVAL;
+        buf = (char *)__get_free_page(GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        if (copy_from_user(buf, user_buf, count)) {
+                free_page((unsigned long) buf);
+                return -EFAULT;
+        }
+        /* NULL-terminate and remove enter */
+        buf[count] = '\0';
+        strim(buf);
+        cptype = parse_cp_type(buf, count);
+        free_page((unsigned long) buf);
+        if (cptype == NONE)
+                return -EINVAL;
+        err = lkdtm_register_cpoint(which);
+        if (err < 0)
+                return err;
+        *off += count;
+        return count;
+}
+/* Generic read callback that just prints out the available crash types */
+static ssize_t lkdtm_debugfs_read(struct file *f, char __user *user_buf,
+                size_t count, loff_t *off)
+{
+        char *buf;
+        int i, n, out;
+        buf = (char *)__get_free_page(GFP_KERNEL);
+        n = snprintf(buf, PAGE_SIZE, "Available crash types:\n");
+        for (i = 0; i < ARRAY_SIZE(cp_type); i++)
+                n += snprintf(buf + n, PAGE_SIZE - n, "%s\n", cp_type[i]);
+        buf[n] = '\0';
+        out = simple_read_from_buffer(user_buf, count, off,
+                                      buf, n);
+        free_page((unsigned long) buf);
+        return out;
+}
+static int lkdtm_debugfs_open(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+static ssize_t int_hardware_entry(struct file *f, const char __user *buf,
+                size_t count, loff_t *off)
+{
+        return do_register_entry(INT_HARDWARE_ENTRY, f, buf, count, off);
+}
+static ssize_t int_hw_irq_en(struct file *f, const char __user *buf,
+                size_t count, loff_t *off)
+{
+        return do_register_entry(INT_HW_IRQ_EN, f, buf, count, off);
+}
+static ssize_t int_tasklet_entry(struct file *f, const char __user *buf,
+                size_t count, loff_t *off)
+{
+        return do_register_entry(INT_TASKLET_ENTRY, f, buf, count, off);
+}
+static ssize_t fs_devrw_entry(struct file *f, const char __user *buf,
+                size_t count, loff_t *off)
+{
+        return do_register_entry(FS_DEVRW, f, buf, count, off);
+}
+static ssize_t mem_swapout_entry(struct file *f, const char __user *buf,
+                size_t count, loff_t *off)
+{
+        return do_register_entry(MEM_SWAPOUT, f, buf, count, off);
+}
+static ssize_t timeradd_entry(struct file *f, const char __user *buf,
+                size_t count, loff_t *off)
+{
+        return do_register_entry(TIMERADD, f, buf, count, off);
+}
+static ssize_t scsi_dispatch_cmd_entry(struct file *f,
+                const char __user *buf, size_t count, loff_t *off)
+{
+        return do_register_entry(SCSI_DISPATCH_CMD, f, buf, count, off);
+}
+static ssize_t ide_core_cp_entry(struct file *f, const char __user *buf,
+                size_t count, loff_t *off)
+{
+        return do_register_entry(IDE_CORE_CP, f, buf, count, off);
+}
+/* Special entry to just crash directly. Available without KPROBEs */
+static ssize_t direct_entry(struct file *f, const char __user *user_buf,
+                size_t count, loff_t *off)
+{
+        enum ctype type;
+        char *buf;
+        if (count >= PAGE_SIZE)
+                return -EINVAL;
+        if (count < 1)
+                return -EINVAL;
+        buf = (char *)__get_free_page(GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        if (copy_from_user(buf, user_buf, count)) {
+                free_page((unsigned long) buf);
+                return -EFAULT;
+        }
+        /* NULL-terminate and remove enter */
+        buf[count] = '\0';
+        strim(buf);
+        type = parse_cp_type(buf, count);
+        free_page((unsigned long) buf);
+        if (type == NONE)
+                return -EINVAL;
+        printk(KERN_INFO "lkdtm: Performing direct entry %s\n",
+                        cp_type_to_str(type));
+        lkdtm_do_action(type);
+        *off += count;
+        return count;
+}
+struct crash_entry {
+        const char *name;
+        const struct file_operations fops;
+};
+static const struct crash_entry crash_entries[] = {
+        {"DIRECT", {.read = lkdtm_debugfs_read,
+                        .open = lkdtm_debugfs_open,
+                        .write = direct_entry} },
+        {"INT_HARDWARE_ENTRY", {.read = lkdtm_debugfs_read,
+                        .open = lkdtm_debugfs_open,
+                        .write = int_hardware_entry} },
+        {"INT_HW_IRQ_EN", {.read = lkdtm_debugfs_read,
+                        .open = lkdtm_debugfs_open,
+                        .write = int_hw_irq_en} },
+        {"INT_TASKLET_ENTRY", {.read = lkdtm_debugfs_read,
+                        .open = lkdtm_debugfs_open,
+                        .write = int_tasklet_entry} },
+        {"FS_DEVRW", {.read = lkdtm_debugfs_read,
+                        .open = lkdtm_debugfs_open,
+                        .write = fs_devrw_entry} },
+        {"MEM_SWAPOUT", {.read = lkdtm_debugfs_read,
+                        .open = lkdtm_debugfs_open,
+                        .write = mem_swapout_entry} },
+        {"TIMERADD", {.read = lkdtm_debugfs_read,
+                        .open = lkdtm_debugfs_open,
+                        .write = timeradd_entry} },
+        {"SCSI_DISPATCH_CMD", {.read = lkdtm_debugfs_read,
+                        .open = lkdtm_debugfs_open,
+                        .write = scsi_dispatch_cmd_entry} },
+        {"IDE_CORE_CP", {.read = lkdtm_debugfs_read,
+                        .open = lkdtm_debugfs_open,
+                        .write = ide_core_cp_entry} },
+};
+static struct dentry *lkdtm_debugfs_root;
+static int __init lkdtm_module_init(void)
+{
+        int ret = -EINVAL;
+        int n_debugfs_entries = 1; /* Assume only the direct entry */
+        int i;
+        /* Register debugfs interface */
+        lkdtm_debugfs_root = debugfs_create_dir("provoke-crash", NULL);
+        if (!lkdtm_debugfs_root) {
+                printk(KERN_ERR "lkdtm: creating root dir failed\n");
+                return -ENODEV;
+        }
+#ifdef CONFIG_KPROBES
+        n_debugfs_entries = ARRAY_SIZE(crash_entries);
+#endif
+        for (i = 0; i < n_debugfs_entries; i++) {
+                const struct crash_entry *cur = &crash_entries[i];
+                struct dentry *de;
+                de = debugfs_create_file(cur->name, 0644, lkdtm_debugfs_root,
+                                NULL, &cur->fops);
+                if (de == NULL) {
+                        printk(KERN_ERR "lkdtm: could not create %s\n",
+                                        cur->name);
+                        goto out_err;
+                }
+        }
+        if (lkdtm_parse_commandline() == -EINVAL) {
+                printk(KERN_INFO "lkdtm: Invalid command\n");
+                goto out_err;
+        }
+        if (cpoint != INVALID && cptype != NONE) {
+                ret = lkdtm_register_cpoint(cpoint);
+                if (ret < 0) {
+                        printk(KERN_INFO "lkdtm: Invalid crash point %d\n",
+                                        cpoint);
+                        goto out_err;
+                }
+                printk(KERN_INFO "lkdtm: Crash point %s of type %s registered\n",
+                                cpoint_name, cpoint_type);
+        } else {
+                printk(KERN_INFO "lkdtm: No crash points registered, enable through debugfs\n");
        }
-        printk(KERN_INFO "lkdtm : Crash point %s of type %s registered\n",
-                                                cpoint_name, cpoint_type);
        return 0;
+out_err:
+        debugfs_remove_recursive(lkdtm_debugfs_root);
+        return ret;
 }
 static void __exit lkdtm_module_exit(void)
 {
-        unregister_jprobe(&lkdtm);
+        debugfs_remove_recursive(lkdtm_debugfs_root);
-        printk(KERN_INFO "lkdtm : Crash point unregistered\n");
+        unregister_jprobe(&lkdtm);
+        printk(KERN_INFO "lkdtm: Crash point unregistered\n");
 }
 module_init(lkdtm_module_init);
diff --git a/drivers/misc/sgi-xp/xpnet.c b/drivers/misc/sgi-xp/xpnet.c
index 16f0abda1423..57b152f8d1b9 100644
--- a/drivers/misc/sgi-xp/xpnet.c
+++ b/drivers/misc/sgi-xp/xpnet.c
@@ -475,7 +475,7 @@ xpnet_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
        if (skb->data[0] == 0xff) {
                /* we are being asked to broadcast to all partitions */
-                for_each_bit(dest_partid, xpnet_broadcast_partitions,
+                for_each_set_bit(dest_partid, xpnet_broadcast_partitions,
                             xp_max_npartitions) {
                        xpnet_send(skb, queued_msg, start_addr, end_addr,
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 30acd5265821..f4b97d3c3d0f 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -1151,6 +1151,9 @@ void mmc_stop_host(struct mmc_host *host)
        cancel_delayed_work(&host->detect);
        mmc_flush_scheduled_work();
+        /* clear pm flags now and let card drivers set them as needed */
+        host->pm_flags = 0;
        mmc_bus_get(host);
        if (host->bus_ops && !host->bus_dead) {
                if (host->bus_ops->remove)
@@ -1273,12 +1276,13 @@ int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
                        mmc_claim_host(host);
                        mmc_detach_bus(host);
                        mmc_release_host(host);
+                        host->pm_flags = 0;
                        err = 0;
                }
        }
        mmc_bus_put(host);
-        if (!err)
+        if (!err && !(host->pm_flags & MMC_PM_KEEP_POWER))
                mmc_power_off(host);
        return err;
@@ -1296,8 +1300,10 @@ int mmc_resume_host(struct mmc_host *host)
        mmc_bus_get(host);
        if (host->bus_ops && !host->bus_dead) {
-                mmc_power_up(host);
+                if (!(host->pm_flags & MMC_PM_KEEP_POWER)) {
-                mmc_select_voltage(host, host->ocr);
+                        mmc_power_up(host);
+                        mmc_select_voltage(host, host->ocr);
+                }
                BUG_ON(!host->bus_ops->resume);
                err = host->bus_ops->resume(host);
                if (err) {
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index 06b64085a355..2dd4cfe7ca17 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -188,6 +188,40 @@ static int sdio_disable_cd(struct mmc_card *card)
 }
 /*
+ * Devices that remain active during a system suspend are
+ * put back into 1-bit mode.
+ */
+static int sdio_disable_wide(struct mmc_card *card)
+{
+        int ret;
+        u8 ctrl;
+        if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
+                return 0;
+        if (card->cccr.low_speed && !card->cccr.wide_bus)
+                return 0;
+        ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
+        if (ret)
+                return ret;
+        if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
+                return 0;
+        ctrl &= ~SDIO_BUS_WIDTH_4BIT;
+        ctrl |= SDIO_BUS_ASYNC_INT;
+        ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
+        if (ret)
+                return ret;
+        mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1);
+        return 0;
+}
+/*
 * Test if the card supports high-speed mode and, if so, switch to it.
 */
 static int sdio_enable_hs(struct mmc_card *card)
@@ -224,7 +258,7 @@ static int sdio_enable_hs(struct mmc_card *card)
 * we're trying to reinitialise.
 */
 static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
-                              struct mmc_card *oldcard)
+                              struct mmc_card *oldcard, int powered_resume)
 {
        struct mmc_card *card;
        int err;
@@ -235,9 +269,11 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
        /*
         * Inform the card of the voltage
         */
-        err = mmc_send_io_op_cond(host, host->ocr, &ocr);
+        if (!powered_resume) {
-        if (err)
+                err = mmc_send_io_op_cond(host, host->ocr, &ocr);
-                goto err;
+                if (err)
+                        goto err;
+        }
        /*
         * For SPI, enable CRC as appropriate.
@@ -262,7 +298,7 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
        /*
         * For native busses:  set card RCA and quit open drain mode.
         */
-        if (!mmc_host_is_spi(host)) {
+        if (!powered_resume && !mmc_host_is_spi(host)) {
                err = mmc_send_relative_addr(host, &card->rca);
                if (err)
                        goto remove;
@@ -273,7 +309,7 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
        /*
         * Select card, as all following commands rely on that.
         */
-        if (!mmc_host_is_spi(host)) {
+        if (!powered_resume && !mmc_host_is_spi(host)) {
                err = mmc_select_card(card);
                if (err)
                        goto remove;
@@ -425,6 +461,12 @@ static int mmc_sdio_suspend(struct mmc_host *host)
                }
        }
+        if (!err && host->pm_flags & MMC_PM_KEEP_POWER) {
+                mmc_claim_host(host);
+                sdio_disable_wide(host->card);
+                mmc_release_host(host);
+        }
        return err;
 }
@@ -437,7 +479,13 @@ static int mmc_sdio_resume(struct mmc_host *host)
        /* Basic card reinitialization. */
        mmc_claim_host(host);
-        err = mmc_sdio_init_card(host, host->ocr, host->card);
+        err = mmc_sdio_init_card(host, host->ocr, host->card,
+                                 (host->pm_flags & MMC_PM_KEEP_POWER));
+        if (!err)
+                /* We may have switched to 1-bit mode during suspend. */
+                err = sdio_enable_wide(host->card);
+        if (!err && host->sdio_irqs)
+                mmc_signal_sdio_irq(host);
        mmc_release_host(host);
        /*
@@ -507,7 +555,7 @@ int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
        /*
         * Detect and init the card.
         */
-        err = mmc_sdio_init_card(host, host->ocr, NULL);
+        err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
        if (err)
                goto err;
        card = host->card;
diff --git a/drivers/mmc/core/sdio_io.c b/drivers/mmc/core/sdio_io.c
index f9aa8a7deffa..ff27c8c71355 100644
--- a/drivers/mmc/core/sdio_io.c
+++ b/drivers/mmc/core/sdio_io.c
@@ -189,7 +189,12 @@ static inline unsigned int sdio_max_byte_size(struct sdio_func *func)
 {
        unsigned mval = min(func->card->host->max_seg_size,
                            func->card->host->max_blk_size);
-        mval = min(mval, func->max_blksize);
+        if (mmc_blksz_for_byte_mode(func->card))
+                mval = min(mval, func->cur_blksize);
+        else
+                mval = min(mval, func->max_blksize);
        return min(mval, 512u); /* maximum size for byte mode */
 }
@@ -635,3 +640,52 @@ void sdio_f0_writeb(struct sdio_func *func, unsigned char b, unsigned int addr,
                *err_ret = ret;
 }
 EXPORT_SYMBOL_GPL(sdio_f0_writeb);
+/**
+ *      sdio_get_host_pm_caps - get host power management capabilities
+ *      @func: SDIO function attached to host
+ *
+ *      Returns a capability bitmask corresponding to power management
+ *      features supported by the host controller that the card function
+ *      might rely upon during a system suspend.  The host doesn't need
+ *      to be claimed, nor the function active, for this information to be
+ *      obtained.
+ */
+mmc_pm_flag_t sdio_get_host_pm_caps(struct sdio_func *func)
+{
+        BUG_ON(!func);
+        BUG_ON(!func->card);
+        return func->card->host->pm_caps;
+}
+EXPORT_SYMBOL_GPL(sdio_get_host_pm_caps);
+/**
+ *      sdio_set_host_pm_flags - set wanted host power management capabilities
+ *      @func: SDIO function attached to host
+ *
+ *      Set a capability bitmask corresponding to wanted host controller
+ *      power management features for the upcoming suspend state.
+ *      This must be called, if needed, each time the suspend method of
+ *      the function driver is called, and must contain only bits that
+ *      were returned by sdio_get_host_pm_caps().
+ *      The host doesn't need to be claimed, nor the function active,
+ *      for this information to be set.
+ */
+int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags)
+{
+        struct mmc_host *host;
+        BUG_ON(!func);
+        BUG_ON(!func->card);
+        host = func->card->host;
+        if (flags & ~host->pm_caps)
+                return -EINVAL;
+        /* function suspend methods are serialized, hence no lock needed */
+        host->pm_flags |= flags;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(sdio_set_host_pm_flags);
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index ce1d28884e29..7b431bbab7f1 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -69,20 +69,16 @@ config MMC_SDHCI_PCI
          If unsure, say N.
 config MMC_RICOH_MMC
-        tristate "Ricoh MMC Controller Disabler  (EXPERIMENTAL)"
+        bool "Ricoh MMC Controller Disabler  (EXPERIMENTAL)"
        depends on MMC_SDHCI_PCI
        help
-          This selects the disabler for the Ricoh MMC Controller. This
+          This adds a pci quirk to disable Ricoh MMC Controller. This
          proprietary controller is unnecessary because the SDHCI driver
          supports MMC cards on the SD controller, but if it is not
          disabled, it will steal the MMC cards away - rendering them
-          useless. It is safe to select this driver even if you don't
+          useless. It is safe to select this even if you don't
          have a Ricoh based card reader.
-          To compile this driver as a module, choose M here:
-          the module will be called ricoh_mmc.
          If unsure, say Y.
 config MMC_SDHCI_OF
@@ -193,6 +189,7 @@ config MMC_AU1X
 choice
        prompt "Atmel SD/MMC Driver"
+        depends on AVR32 || ARCH_AT91
        default MMC_ATMELMCI if AVR32
        help
          Choose which driver to use for the Atmel MCI Silicon
@@ -399,7 +396,7 @@ config MMC_VIA_SDMMC
 config SDH_BFIN
        tristate "Blackfin Secure Digital Host support"
-        depends on MMC && ((BF54x && !BF544) || (BF51x && !BF512))
+        depends on (BF54x && !BF544) || (BF51x && !BF512)
        help
          If you say yes here you will get support for the Blackfin on-chip
          Secure Digital Host interface.  This includes support for MMC and
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index 3d253dd4240f..f4803977dfce 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -12,7 +12,6 @@ obj-$(CONFIG_MMC_IMX)		+= imxmmc.o
 obj-$(CONFIG_MMC_MXC)           += mxcmmc.o
 obj-$(CONFIG_MMC_SDHCI)         += sdhci.o
 obj-$(CONFIG_MMC_SDHCI_PCI)     += sdhci-pci.o
-obj-$(CONFIG_MMC_RICOH_MMC)     += ricoh_mmc.o
 obj-$(CONFIG_MMC_SDHCI_PLTFM)   += sdhci-pltfm.o
 obj-$(CONFIG_MMC_SDHCI_S3C)     += sdhci-s3c.o
 obj-$(CONFIG_MMC_WBSD)          += wbsd.o
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 63924e0c7ea9..91dc60cd032b 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -78,6 +78,17 @@
 #define DRIVER_NAME "at91_mci"
+static inline int at91mci_is_mci1rev2xx(void)
+{
+        return (   cpu_is_at91sam9260()
+                || cpu_is_at91sam9263()
+                || cpu_is_at91cap9()
+                || cpu_is_at91sam9rl()
+                || cpu_is_at91sam9g10()
+                || cpu_is_at91sam9g20()
+                );
+}
 #define FL_SENT_COMMAND (1 << 0)
 #define FL_SENT_STOP    (1 << 1)
@@ -88,6 +99,10 @@
 #define at91_mci_read(host, reg)        __raw_readl((host)->baseaddr + (reg))
 #define at91_mci_write(host, reg, val)  __raw_writel((val), (host)->baseaddr + (reg))
+#define MCI_BLKSIZE             512
+#define MCI_MAXBLKSIZE          4095
+#define MCI_BLKATONCE           256
+#define MCI_BUFSIZE             (MCI_BLKSIZE * MCI_BLKATONCE)
 /*
 * Low level type for this driver
@@ -200,8 +215,8 @@ static inline void at91_mci_sg_to_dma(struct at91mci_host *host, struct mmc_data
        size = data->blksz * data->blocks;
        len = data->sg_len;
-        /* AT91SAM926[0/3] Data Write Operation and number of bytes erratum */
+        /* MCI1 rev2xx Data Write Operation and number of bytes erratum */
-        if (cpu_is_at91sam9260() || cpu_is_at91sam9263())
+        if (at91mci_is_mci1rev2xx())
                if (host->total_length == 12)
                        memset(dmabuf, 0, 12);
@@ -227,8 +242,10 @@ static inline void at91_mci_sg_to_dma(struct at91mci_host *host, struct mmc_data
                        for (index = 0; index < (amount / 4); index++)
                                *dmabuf++ = swab32(sgbuffer[index]);
                } else {
-                        memcpy(dmabuf, sgbuffer, amount);
+                        char *tmpv = (char *)dmabuf;
-                        dmabuf += amount;
+                        memcpy(tmpv, sgbuffer, amount);
+                        tmpv += amount;
+                        dmabuf = (unsigned *)tmpv;
                }
                kunmap_atomic(sgbuffer, KM_BIO_SRC_IRQ);
@@ -245,80 +262,14 @@ static inline void at91_mci_sg_to_dma(struct at91mci_host *host, struct mmc_data
 }
 /*
- * Prepare a dma read
- */
-static void at91_mci_pre_dma_read(struct at91mci_host *host)
-{
-        int i;
-        struct scatterlist *sg;
-        struct mmc_command *cmd;
-        struct mmc_data *data;
-        pr_debug("pre dma read\n");
-        cmd = host->cmd;
-        if (!cmd) {
-                pr_debug("no command\n");
-                return;
-        }
-        data = cmd->data;
-        if (!data) {
-                pr_debug("no data\n");
-                return;
-        }
-        for (i = 0; i < 2; i++) {
-                /* nothing left to transfer */
-                if (host->transfer_index >= data->sg_len) {
-                        pr_debug("Nothing left to transfer (index = %d)\n", host->transfer_index);
-                        break;
-                }
-                /* Check to see if this needs filling */
-                if (i == 0) {
-                        if (at91_mci_read(host, ATMEL_PDC_RCR) != 0) {
-                                pr_debug("Transfer active in current\n");
-                                continue;
-                        }
-                }
-                else {
-                        if (at91_mci_read(host, ATMEL_PDC_RNCR) != 0) {
-                                pr_debug("Transfer active in next\n");
-                                continue;
-                        }
-                }
-                /* Setup the next transfer */
-                pr_debug("Using transfer index %d\n", host->transfer_index);
-                sg = &data->sg[host->transfer_index++];
-                pr_debug("sg = %p\n", sg);
-                sg->dma_address = dma_map_page(NULL, sg_page(sg), sg->offset, sg->length, DMA_FROM_DEVICE);
-                pr_debug("dma address = %08X, length = %d\n", sg->dma_address, sg->length);
-                if (i == 0) {
-                        at91_mci_write(host, ATMEL_PDC_RPR, sg->dma_address);
-                        at91_mci_write(host, ATMEL_PDC_RCR, (data->blksz & 0x3) ? sg->length : sg->length / 4);
-                }
-                else {
-                        at91_mci_write(host, ATMEL_PDC_RNPR, sg->dma_address);
-                        at91_mci_write(host, ATMEL_PDC_RNCR, (data->blksz & 0x3) ? sg->length : sg->length / 4);
-                }
-        }
-        pr_debug("pre dma read done\n");
-}
-/*
 * Handle after a dma read
 */
 static void at91_mci_post_dma_read(struct at91mci_host *host)
 {
        struct mmc_command *cmd;
        struct mmc_data *data;
+        unsigned int len, i, size;
+        unsigned *dmabuf = host->buffer;
        pr_debug("post dma read\n");
@@ -334,42 +285,39 @@ static void at91_mci_post_dma_read(struct at91mci_host *host)
                return;
        }
-        while (host->in_use_index < host->transfer_index) {
+        size = data->blksz * data->blocks;
-                struct scatterlist *sg;
+        len = data->sg_len;
-                pr_debug("finishing index %d\n", host->in_use_index);
+        at91_mci_write(host, AT91_MCI_IDR, AT91_MCI_ENDRX);
+        at91_mci_write(host, AT91_MCI_IER, AT91_MCI_RXBUFF);
-                sg = &data->sg[host->in_use_index++];
+        for (i = 0; i < len; i++) {
+                struct scatterlist *sg;
+                int amount;
+                unsigned int *sgbuffer;
-                pr_debug("Unmapping page %08X\n", sg->dma_address);
+                sg = &data->sg[i];
-                dma_unmap_page(NULL, sg->dma_address, sg->length, DMA_FROM_DEVICE);
+                sgbuffer = kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
+                amount = min(size, sg->length);
+                size -= amount;
                if (cpu_is_at91rm9200()) {      /* AT91RM9200 errata */
-                        unsigned int *buffer;
                        int index;
+                        for (index = 0; index < (amount / 4); index++)
-                        /* Swap the contents of the buffer */
+                                sgbuffer[index] = swab32(*dmabuf++);
-                        buffer = kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
+                } else {
-                        pr_debug("buffer = %p, length = %d\n", buffer, sg->length);
+                        char *tmpv = (char *)dmabuf;
+                        memcpy(sgbuffer, tmpv, amount);
-                        for (index = 0; index < (sg->length / 4); index++)
+                        tmpv += amount;
-                                buffer[index] = swab32(buffer[index]);
+                        dmabuf = (unsigned *)tmpv;
-                        kunmap_atomic(buffer, KM_BIO_SRC_IRQ);
                }
-                flush_dcache_page(sg_page(sg));
+                kunmap_atomic(sgbuffer, KM_BIO_SRC_IRQ);
+                dmac_flush_range((void *)sgbuffer, ((void *)sgbuffer) + amount);
-                data->bytes_xfered += sg->length;
+                data->bytes_xfered += amount;
-        }
+                if (size == 0)
+                        break;
-        /* Is there another transfer to trigger? */
-        if (host->transfer_index < data->sg_len)
-                at91_mci_pre_dma_read(host);
-        else {
-                at91_mci_write(host, AT91_MCI_IDR, AT91_MCI_ENDRX);
-                at91_mci_write(host, AT91_MCI_IER, AT91_MCI_RXBUFF);
        }
        pr_debug("post dma read done\n");
@@ -461,7 +409,7 @@ static void at91_mci_enable(struct at91mci_host *host)
        at91_mci_write(host, AT91_MCI_DTOR, AT91_MCI_DTOMUL_1M | AT91_MCI_DTOCYC);
        mr = AT91_MCI_PDCMODE | 0x34a;
-        if (cpu_is_at91sam9260() || cpu_is_at91sam9263())
+        if (at91mci_is_mci1rev2xx())
                mr |= AT91_MCI_RDPROOF | AT91_MCI_WRPROOF;
        at91_mci_write(host, AT91_MCI_MR, mr);
@@ -602,10 +550,14 @@ static void at91_mci_send_command(struct at91mci_host *host, struct mmc_command
                                /*
                                 * Handle a read
                                 */
-                                host->buffer = NULL;
                                host->total_length = 0;
-                                at91_mci_pre_dma_read(host);
+                                at91_mci_write(host, ATMEL_PDC_RPR, host->physical_address);
+                                at91_mci_write(host, ATMEL_PDC_RCR, (data->blksz & 0x3) ?
+                                        (blocks * block_length) : (blocks * block_length) / 4);
+                                at91_mci_write(host, ATMEL_PDC_RNPR, 0);
+                                at91_mci_write(host, ATMEL_PDC_RNCR, 0);
                                ier = AT91_MCI_ENDRX /* | AT91_MCI_RXBUFF */;
                        }
                        else {
@@ -614,27 +566,15 @@ static void at91_mci_send_command(struct at91mci_host *host, struct mmc_command
                                 */
                                host->total_length = block_length * blocks;
                                /*
-                                 * AT91SAM926[0/3] Data Write Operation and
+                                 * MCI1 rev2xx Data Write Operation and
                                 * number of bytes erratum
                                 */
-                                if (cpu_is_at91sam9260 () || cpu_is_at91sam9263())
+                                if (at91mci_is_mci1rev2xx())
                                        if (host->total_length < 12)
                                                host->total_length = 12;
-                                host->buffer = kmalloc(host->total_length, GFP_KERNEL);
-                                if (!host->buffer) {
-                                        pr_debug("Can't alloc tx buffer\n");
-                                        cmd->error = -ENOMEM;
-                                        mmc_request_done(host->mmc, host->request);
-                                        return;
-                                }
                                at91_mci_sg_to_dma(host, data);
-                                host->physical_address = dma_map_single(NULL,
-                                                host->buffer, host->total_length,
-                                                DMA_TO_DEVICE);
                                pr_debug("Transmitting %d bytes\n", host->total_length);
                                at91_mci_write(host, ATMEL_PDC_TPR, host->physical_address);
@@ -701,14 +641,6 @@ static void at91_mci_completed_command(struct at91mci_host *host, unsigned int s
        cmd->resp[2] = at91_mci_read(host, AT91_MCI_RSPR(2));
        cmd->resp[3] = at91_mci_read(host, AT91_MCI_RSPR(3));
-        if (host->buffer) {
-                dma_unmap_single(NULL,
-                                host->physical_address, host->total_length,
-                                DMA_TO_DEVICE);
-                kfree(host->buffer);
-                host->buffer = NULL;
-        }
        pr_debug("Status = %08X/%08x [%08X %08X %08X %08X]\n",
                 status, at91_mci_read(host, AT91_MCI_SR),
                 cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]);
@@ -754,7 +686,8 @@ static void at91_mci_request(struct mmc_host *mmc, struct mmc_request *mrq)
        host->request = mrq;
        host->flags = 0;
-        mod_timer(&host->timer, jiffies +  HZ);
+        /* more than 1s timeout needed with slow SD cards */
+        mod_timer(&host->timer, jiffies +  msecs_to_jiffies(2000));
        at91_mci_process_next(host);
 }
@@ -942,7 +875,8 @@ static irqreturn_t at91_mmc_det_irq(int irq, void *_host)
                        pr_debug("****** Resetting SD-card bus width ******\n");
                        at91_mci_write(host, AT91_MCI_SDCR, at91_mci_read(host, AT91_MCI_SDCR) & ~AT91_MCI_SDCBUS);
                }
-                mmc_detect_change(host->mmc, msecs_to_jiffies(100));
+                /* 0.5s needed because of early card detect switch firing */
+                mmc_detect_change(host->mmc, msecs_to_jiffies(500));
        }
        return IRQ_HANDLED;
 }
@@ -1006,24 +940,42 @@ static int __init at91_mci_probe(struct platform_device *pdev)
        mmc->f_min = 375000;
        mmc->f_max = 25000000;
        mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
-        mmc->caps = MMC_CAP_SDIO_IRQ;
+        mmc->caps = 0;
-        mmc->max_blk_size = 4095;
+        mmc->max_blk_size  = MCI_MAXBLKSIZE;
-        mmc->max_blk_count = mmc->max_req_size;
+        mmc->max_blk_count = MCI_BLKATONCE;
+        mmc->max_req_size  = MCI_BUFSIZE;
+        mmc->max_phys_segs = MCI_BLKATONCE;
+        mmc->max_hw_segs   = MCI_BLKATONCE;
+        mmc->max_seg_size  = MCI_BUFSIZE;
        host = mmc_priv(mmc);
        host->mmc = mmc;
-        host->buffer = NULL;
        host->bus_mode = 0;
        host->board = pdev->dev.platform_data;
        if (host->board->wire4) {
-                if (cpu_is_at91sam9260() || cpu_is_at91sam9263())
+                if (at91mci_is_mci1rev2xx())
                        mmc->caps |= MMC_CAP_4_BIT_DATA;
                else
                        dev_warn(&pdev->dev, "4 wire bus mode not supported"
                                " - using 1 wire\n");
        }
+        host->buffer = dma_alloc_coherent(&pdev->dev, MCI_BUFSIZE,
+                                        &host->physical_address, GFP_KERNEL);
+        if (!host->buffer) {
+                ret = -ENOMEM;
+                dev_err(&pdev->dev, "Can't allocate transmit buffer\n");
+                goto fail5;
+        }
+        /* Add SDIO capability when available */
+        if (at91mci_is_mci1rev2xx()) {
+                /* at91mci MCI1 rev2xx sdio interrupt erratum */
+                if (host->board->wire4 || !host->board->slot_b)
+                        mmc->caps |= MMC_CAP_SDIO_IRQ;
+        }
        /*
         * Reserve GPIOs ... board init code makes sure these pins are set
         * up as GPIOs with the right direction (input, except for vcc)
@@ -1032,7 +984,7 @@ static int __init at91_mci_probe(struct platform_device *pdev)
                ret = gpio_request(host->board->det_pin, "mmc_detect");
                if (ret < 0) {
                        dev_dbg(&pdev->dev, "couldn't claim card detect pin\n");
-                        goto fail5;
+                        goto fail4b;
                }
        }
        if (host->board->wp_pin) {
@@ -1132,6 +1084,10 @@ fail3:
 fail4:
        if (host->board->det_pin)
                gpio_free(host->board->det_pin);
+fail4b:
+        if (host->buffer)
+                dma_free_coherent(&pdev->dev, MCI_BUFSIZE,
+                                host->buffer, host->physical_address);
 fail5:
        mmc_free_host(mmc);
 fail6:
@@ -1154,6 +1110,10 @@ static int __exit at91_mci_remove(struct platform_device *pdev)
        host = mmc_priv(mmc);
+        if (host->buffer)
+                dma_free_coherent(&pdev->dev, MCI_BUFSIZE,
+                                host->buffer, host->physical_address);
        if (host->board->det_pin) {
                if (device_can_wakeup(&pdev->dev))
                        free_irq(gpio_to_irq(host->board->det_pin), host);
diff --git a/drivers/mmc/host/bfin_sdh.c b/drivers/mmc/host/bfin_sdh.c
index 3343a57355cc..56f7b448b911 100644
--- a/drivers/mmc/host/bfin_sdh.c
+++ b/drivers/mmc/host/bfin_sdh.c
@@ -115,7 +115,7 @@ static int sdh_setup_data(struct sdh_host *host, struct mmc_data *data)
        unsigned int length;
        unsigned int data_ctl;
        unsigned int dma_cfg;
-        struct scatterlist *sg;
+        unsigned int cycle_ns, timeout;
        dev_dbg(mmc_dev(host->mmc), "%s enter flags: 0x%x\n", __func__, data->flags);
        host->data = data;
@@ -136,8 +136,11 @@ static int sdh_setup_data(struct sdh_host *host, struct mmc_data *data)
        data_ctl |= ((ffs(data->blksz) - 1) << 4);
        bfin_write_SDH_DATA_CTL(data_ctl);
+        /* the time of a host clock period in ns */
-        bfin_write_SDH_DATA_TIMER(0xFFFF);
+        cycle_ns = 1000000000 / (get_sclk() / (2 * (host->clk_div + 1)));
+        timeout = data->timeout_ns / cycle_ns;
+        timeout += data->timeout_clks;
+        bfin_write_SDH_DATA_TIMER(timeout);
        SSYNC();
        if (data->flags & MMC_DATA_READ) {
@@ -151,6 +154,7 @@ static int sdh_setup_data(struct sdh_host *host, struct mmc_data *data)
 #if defined(CONFIG_BF54x)
        dma_cfg |= DMAFLOW_ARRAY | NDSIZE_5 | RESTART | WDSIZE_32 | DMAEN;
        {
+                struct scatterlist *sg;
                int i;
                for_each_sg(data->sg, sg, host->dma_len, i) {
                        host->sg_cpu[i].start_addr = sg_dma_address(sg);
diff --git a/drivers/mmc/host/davinci_mmc.c b/drivers/mmc/host/davinci_mmc.c
index dd45e7c3517e..3bd0ba294e9d 100644
--- a/drivers/mmc/host/davinci_mmc.c
+++ b/drivers/mmc/host/davinci_mmc.c
@@ -73,6 +73,7 @@
 /* DAVINCI_MMCCTL definitions */
 #define MMCCTL_DATRST         (1 << 0)
 #define MMCCTL_CMDRST         (1 << 1)
+#define MMCCTL_WIDTH_8_BIT    (1 << 8)
 #define MMCCTL_WIDTH_4_BIT    (1 << 2)
 #define MMCCTL_DATEG_DISABLED (0 << 6)
 #define MMCCTL_DATEG_RISING   (1 << 6)
@@ -791,22 +792,42 @@ static void calculate_clk_divider(struct mmc_host *mmc, struct mmc_ios *ios)
 static void mmc_davinci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
-        unsigned int mmc_pclk = 0;
        struct mmc_davinci_host *host = mmc_priv(mmc);
-        mmc_pclk = host->mmc_input_clk;
        dev_dbg(mmc_dev(host->mmc),
                "clock %dHz busmode %d powermode %d Vdd %04x\n",
                ios->clock, ios->bus_mode, ios->power_mode,
                ios->vdd);
-        if (ios->bus_width == MMC_BUS_WIDTH_4) {
-                dev_dbg(mmc_dev(host->mmc), "Enabling 4 bit mode\n");
+        switch (ios->bus_width) {
-                writel(readl(host->base + DAVINCI_MMCCTL) | MMCCTL_WIDTH_4_BIT,
+        case MMC_BUS_WIDTH_8:
-                        host->base + DAVINCI_MMCCTL);
+                dev_dbg(mmc_dev(host->mmc), "Enabling 8 bit mode\n");
-        } else {
+                writel((readl(host->base + DAVINCI_MMCCTL) &
-                dev_dbg(mmc_dev(host->mmc), "Disabling 4 bit mode\n");
+                        ~MMCCTL_WIDTH_4_BIT) | MMCCTL_WIDTH_8_BIT,
-                writel(readl(host->base + DAVINCI_MMCCTL) & ~MMCCTL_WIDTH_4_BIT,
                        host->base + DAVINCI_MMCCTL);
+                break;
+        case MMC_BUS_WIDTH_4:
+                dev_dbg(mmc_dev(host->mmc), "Enabling 4 bit mode\n");
+                if (host->version == MMC_CTLR_VERSION_2)
+                        writel((readl(host->base + DAVINCI_MMCCTL) &
+                                ~MMCCTL_WIDTH_8_BIT) | MMCCTL_WIDTH_4_BIT,
+                                host->base + DAVINCI_MMCCTL);
+                else
+                        writel(readl(host->base + DAVINCI_MMCCTL) |
+                                MMCCTL_WIDTH_4_BIT,
+                                host->base + DAVINCI_MMCCTL);
+                break;
+        case MMC_BUS_WIDTH_1:
+                dev_dbg(mmc_dev(host->mmc), "Enabling 1 bit mode\n");
+                if (host->version == MMC_CTLR_VERSION_2)
+                        writel(readl(host->base + DAVINCI_MMCCTL) &
+                                ~(MMCCTL_WIDTH_8_BIT | MMCCTL_WIDTH_4_BIT),
+                                host->base + DAVINCI_MMCCTL);
+                else
+                        writel(readl(host->base + DAVINCI_MMCCTL) &
+                                ~MMCCTL_WIDTH_4_BIT,
+                                host->base + DAVINCI_MMCCTL);
+                break;
        }
        calculate_clk_divider(mmc, ios);
@@ -1189,10 +1210,14 @@ static int __init davinci_mmcsd_probe(struct platform_device *pdev)
        /* REVISIT:  someday, support IRQ-driven card detection.  */
        mmc->caps |= MMC_CAP_NEEDS_POLL;
+        mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
-        if (!pdata || pdata->wires == 4 || pdata->wires == 0)
+        if (pdata && (pdata->wires == 4 || pdata->wires == 0))
                mmc->caps |= MMC_CAP_4_BIT_DATA;
+        if (pdata && (pdata->wires == 8))
+                mmc->caps |= (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA);
        host->version = pdata->version;
        mmc->ops = &mmc_davinci_ops;
diff --git a/drivers/mmc/host/ricoh_mmc.c b/drivers/mmc/host/ricoh_mmc.c
deleted file mode 100644
index f62790513322..000000000000
--- a/drivers/mmc/host/ricoh_mmc.c
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- *  ricoh_mmc.c - Dummy driver to disable the Rioch MMC controller.
- *
- *  Copyright (C) 2007 Philip Langdale, All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- */
-/*
- * This is a conceptually ridiculous driver, but it is required by the way
- * the Ricoh multi-function chips (R5CXXX) work. These chips implement
- * the four main memory card controllers (SD, MMC, MS, xD) and one or both
- * of cardbus or firewire. It happens that they implement SD and MMC
- * support as separate controllers (and PCI functions). The linux SDHCI
- * driver supports MMC cards but the chip detects MMC cards in hardware
- * and directs them to the MMC controller - so the SDHCI driver never sees
- * them. To get around this, we must disable the useless MMC controller.
- * At that point, the SDHCI controller will start seeing them. As a bonus,
- * a detection event occurs immediately, even if the MMC card is already
- * in the reader.
- *
- * It seems to be the case that the relevant PCI registers to deactivate the
- * MMC controller live on PCI function 0, which might be the cardbus controller
- * or the firewire controller, depending on the particular chip in question. As
- * such, it makes what this driver has to do unavoidably ugly. Such is life.
- */
-#include <linux/pci.h>
-#define DRIVER_NAME "ricoh-mmc"
-static const struct pci_device_id pci_ids[] __devinitdata = {
-        {
-                .vendor         = PCI_VENDOR_ID_RICOH,
-                .device         = PCI_DEVICE_ID_RICOH_R5C843,
-                .subvendor      = PCI_ANY_ID,
-                .subdevice      = PCI_ANY_ID,
-        },
-        { /* end: all zeroes */ },
-};
-MODULE_DEVICE_TABLE(pci, pci_ids);
-static int ricoh_mmc_disable(struct pci_dev *fw_dev)
-{
-        u8 write_enable;
-        u8 write_target;
-        u8 disable;
-        if (fw_dev->device == PCI_DEVICE_ID_RICOH_RL5C476) {
-                /* via RL5C476 */
-                pci_read_config_byte(fw_dev, 0xB7, &disable);
-                if (disable & 0x02) {
-                        printk(KERN_INFO DRIVER_NAME
-                                ": Controller already disabled. " \
-                                "Nothing to do.\n");
-                        return -ENODEV;
-                }
-                pci_read_config_byte(fw_dev, 0x8E, &write_enable);
-                pci_write_config_byte(fw_dev, 0x8E, 0xAA);
-                pci_read_config_byte(fw_dev, 0x8D, &write_target);
-                pci_write_config_byte(fw_dev, 0x8D, 0xB7);
-                pci_write_config_byte(fw_dev, 0xB7, disable | 0x02);
-                pci_write_config_byte(fw_dev, 0x8E, write_enable);
-                pci_write_config_byte(fw_dev, 0x8D, write_target);
-        } else {
-                /* via R5C832 */
-                pci_read_config_byte(fw_dev, 0xCB, &disable);
-                if (disable & 0x02) {
-                        printk(KERN_INFO DRIVER_NAME
-                               ": Controller already disabled. " \
-                                "Nothing to do.\n");
-                        return -ENODEV;
-                }
-                pci_read_config_byte(fw_dev, 0xCA, &write_enable);
-                pci_write_config_byte(fw_dev, 0xCA, 0x57);
-                pci_write_config_byte(fw_dev, 0xCB, disable | 0x02);
-                pci_write_config_byte(fw_dev, 0xCA, write_enable);
-        }
-        printk(KERN_INFO DRIVER_NAME
-               ": Controller is now disabled.\n");
-        return 0;
-}
-static int ricoh_mmc_enable(struct pci_dev *fw_dev)
-{
-        u8 write_enable;
-        u8 write_target;
-        u8 disable;
-        if (fw_dev->device == PCI_DEVICE_ID_RICOH_RL5C476) {
-                /* via RL5C476 */
-                pci_read_config_byte(fw_dev, 0x8E, &write_enable);
-                pci_write_config_byte(fw_dev, 0x8E, 0xAA);
-                pci_read_config_byte(fw_dev, 0x8D, &write_target);
-                pci_write_config_byte(fw_dev, 0x8D, 0xB7);
-                pci_read_config_byte(fw_dev, 0xB7, &disable);
-                pci_write_config_byte(fw_dev, 0xB7, disable & ~0x02);
-                pci_write_config_byte(fw_dev, 0x8E, write_enable);
-                pci_write_config_byte(fw_dev, 0x8D, write_target);
-        } else {
-                /* via R5C832 */
-                pci_read_config_byte(fw_dev, 0xCA, &write_enable);
-                pci_read_config_byte(fw_dev, 0xCB, &disable);
-                pci_write_config_byte(fw_dev, 0xCA, 0x57);
-                pci_write_config_byte(fw_dev, 0xCB, disable & ~0x02);
-                pci_write_config_byte(fw_dev, 0xCA, write_enable);
-        }
-        printk(KERN_INFO DRIVER_NAME
-               ": Controller is now re-enabled.\n");
-        return 0;
-}
-static int __devinit ricoh_mmc_probe(struct pci_dev *pdev,
-                                     const struct pci_device_id *ent)
-{
-        u8 rev;
-        u8 ctrlfound = 0;
-        struct pci_dev *fw_dev = NULL;
-        BUG_ON(pdev == NULL);
-        BUG_ON(ent == NULL);
-        pci_read_config_byte(pdev, PCI_CLASS_REVISION, &rev);
-        printk(KERN_INFO DRIVER_NAME
-                ": Ricoh MMC controller found at %s [%04x:%04x] (rev %x)\n",
-                pci_name(pdev), (int)pdev->vendor, (int)pdev->device,
-                (int)rev);
-        while ((fw_dev =
-                pci_get_device(PCI_VENDOR_ID_RICOH,
-                        PCI_DEVICE_ID_RICOH_RL5C476, fw_dev))) {
-                if (PCI_SLOT(pdev->devfn) == PCI_SLOT(fw_dev->devfn) &&
-                    PCI_FUNC(fw_dev->devfn) == 0 &&
-                    pdev->bus == fw_dev->bus) {
-                        if (ricoh_mmc_disable(fw_dev) != 0)
-                                return -ENODEV;
-                        pci_set_drvdata(pdev, fw_dev);
-                        ++ctrlfound;
-                        break;
-                }
-        }
-        fw_dev = NULL;
-        while (!ctrlfound &&
-            (fw_dev = pci_get_device(PCI_VENDOR_ID_RICOH,
-                                        PCI_DEVICE_ID_RICOH_R5C832, fw_dev))) {
-                if (PCI_SLOT(pdev->devfn) == PCI_SLOT(fw_dev->devfn) &&
-                    PCI_FUNC(fw_dev->devfn) == 0 &&
-                    pdev->bus == fw_dev->bus) {
-                        if (ricoh_mmc_disable(fw_dev) != 0)
-                                return -ENODEV;
-                        pci_set_drvdata(pdev, fw_dev);
-                        ++ctrlfound;
-                }
-        }
-        if (!ctrlfound) {
-                printk(KERN_WARNING DRIVER_NAME
-                       ": Main Ricoh function not found. Cannot disable controller.\n");
-                return -ENODEV;
-        }
-        return 0;
-}
-static void __devexit ricoh_mmc_remove(struct pci_dev *pdev)
-{
-        struct pci_dev *fw_dev = NULL;
-        fw_dev = pci_get_drvdata(pdev);
-        BUG_ON(fw_dev == NULL);
-        ricoh_mmc_enable(fw_dev);
-        pci_set_drvdata(pdev, NULL);
-}
-static int ricoh_mmc_suspend_late(struct pci_dev *pdev, pm_message_t state)
-{
-        struct pci_dev *fw_dev = NULL;
-        fw_dev = pci_get_drvdata(pdev);
-        BUG_ON(fw_dev == NULL);
-        printk(KERN_INFO DRIVER_NAME ": Suspending.\n");
-        ricoh_mmc_enable(fw_dev);
-        return 0;
-}
-static int ricoh_mmc_resume_early(struct pci_dev *pdev)
-{
-        struct pci_dev *fw_dev = NULL;
-        fw_dev = pci_get_drvdata(pdev);
-        BUG_ON(fw_dev == NULL);
-        printk(KERN_INFO DRIVER_NAME ": Resuming.\n");
-        ricoh_mmc_disable(fw_dev);
-        return 0;
-}
-static struct pci_driver ricoh_mmc_driver = {
-        .name =         DRIVER_NAME,
-        .id_table =     pci_ids,
-        .probe =        ricoh_mmc_probe,
-        .remove =       __devexit_p(ricoh_mmc_remove),
-        .suspend_late = ricoh_mmc_suspend_late,
-        .resume_early = ricoh_mmc_resume_early,
-};
-/*****************************************************************************\
- *                                                                           *
- * Driver init/exit                                                          *
- *                                                                           *
-\*****************************************************************************/
-static int __init ricoh_mmc_drv_init(void)
-{
-        printk(KERN_INFO DRIVER_NAME
-                ": Ricoh MMC Controller disabling driver\n");
-        printk(KERN_INFO DRIVER_NAME ": Copyright(c) Philip Langdale\n");
-        return pci_register_driver(&ricoh_mmc_driver);
-}
-static void __exit ricoh_mmc_drv_exit(void)
-{
-        pci_unregister_driver(&ricoh_mmc_driver);
-}
-module_init(ricoh_mmc_drv_init);
-module_exit(ricoh_mmc_drv_exit);
-MODULE_AUTHOR("Philip Langdale <philipl@alumni.utexas.net>");
-MODULE_DESCRIPTION("Ricoh MMC Controller disabling driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index d96e1abf2d64..2fdf7689ae6c 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -1179,7 +1179,7 @@ static int s3cmci_card_present(struct mmc_host *mmc)
        struct s3c24xx_mci_pdata *pdata = host->pdata;
        int ret;
-        if (pdata->gpio_detect == 0)
+        if (pdata->no_detect)
                return -ENOSYS;
        ret = gpio_get_value(pdata->gpio_detect) ? 0 : 1;
@@ -1360,6 +1360,8 @@ static struct mmc_host_ops s3cmci_ops = {
 static struct s3c24xx_mci_pdata s3cmci_def_pdata = {
        /* This is currently here to avoid a number of if (host->pdata)
         * checks. Any zero fields to ensure reasonable defaults are picked. */
+         .no_wprotect = 1,
+         .no_detect = 1,
 };
 #ifdef CONFIG_CPU_FREQ
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 5c3a1767770a..8e1020cf73f4 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -80,9 +80,6 @@ struct sdhci_pci_chip {
 static int ricoh_probe(struct sdhci_pci_chip *chip)
 {
-        if (chip->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
-                chip->quirks |= SDHCI_QUIRK_CLOCK_BEFORE_RESET;
        if (chip->pdev->subsystem_vendor == PCI_VENDOR_ID_SAMSUNG ||
            chip->pdev->subsystem_vendor == PCI_VENDOR_ID_SONY)
                chip->quirks |= SDHCI_QUIRK_NO_CARD_NO_RESET;
@@ -92,7 +89,9 @@ static int ricoh_probe(struct sdhci_pci_chip *chip)
 static const struct sdhci_pci_fixes sdhci_ricoh = {
        .probe          = ricoh_probe,
-        .quirks         = SDHCI_QUIRK_32BIT_DMA_ADDR,
+        .quirks         = SDHCI_QUIRK_32BIT_DMA_ADDR |
+                          SDHCI_QUIRK_FORCE_DMA |
+                          SDHCI_QUIRK_CLOCK_BEFORE_RESET,
 };
 static const struct sdhci_pci_fixes sdhci_ene_712 = {
@@ -501,6 +500,7 @@ static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
 {
        struct sdhci_pci_chip *chip;
        struct sdhci_pci_slot *slot;
+        mmc_pm_flag_t pm_flags = 0;
        int i, ret;
        chip = pci_get_drvdata(pdev);
@@ -519,6 +519,8 @@ static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
                                sdhci_resume_host(chip->slots[i]->host);
                        return ret;
                }
+                pm_flags |= slot->host->mmc->pm_flags;
        }
        if (chip->fixes && chip->fixes->suspend) {
@@ -531,9 +533,15 @@ static int sdhci_pci_suspend (struct pci_dev *pdev, pm_message_t state)
        }
        pci_save_state(pdev);
-        pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
+        if (pm_flags & MMC_PM_KEEP_POWER) {
-        pci_disable_device(pdev);
+                if (pm_flags & MMC_PM_WAKE_SDIO_IRQ)
-        pci_set_power_state(pdev, pci_choose_state(pdev, state));
+                        pci_enable_wake(pdev, PCI_D3hot, 1);
+                pci_set_power_state(pdev, PCI_D3hot);
+        } else {
+                pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
+                pci_disable_device(pdev);
+                pci_set_power_state(pdev, pci_choose_state(pdev, state));
+        }
        return 0;
 }
@@ -653,6 +661,8 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
                        goto unmap;
        }
+        host->mmc->pm_caps = MMC_PM_KEEP_POWER | MMC_PM_WAKE_SDIO_IRQ;
        ret = sdhci_add_host(host);
        if (ret)
                goto remove;
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index c279fbc4c2e5..d6ab62d539fb 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -174,20 +174,31 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
                sdhci_clear_set_irqs(host, SDHCI_INT_ALL_MASK, ier);
 }
-static void sdhci_init(struct sdhci_host *host)
+static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios);
+static void sdhci_init(struct sdhci_host *host, int soft)
 {
-        sdhci_reset(host, SDHCI_RESET_ALL);
+        if (soft)
+                sdhci_reset(host, SDHCI_RESET_CMD|SDHCI_RESET_DATA);
+        else
+                sdhci_reset(host, SDHCI_RESET_ALL);
        sdhci_clear_set_irqs(host, SDHCI_INT_ALL_MASK,
                SDHCI_INT_BUS_POWER | SDHCI_INT_DATA_END_BIT |
                SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_TIMEOUT | SDHCI_INT_INDEX |
                SDHCI_INT_END_BIT | SDHCI_INT_CRC | SDHCI_INT_TIMEOUT |
                SDHCI_INT_DATA_END | SDHCI_INT_RESPONSE);
+        if (soft) {
+                /* force clock reconfiguration */
+                host->clock = 0;
+                sdhci_set_ios(host->mmc, &host->mmc->ios);
+        }
 }
 static void sdhci_reinit(struct sdhci_host *host)
 {
-        sdhci_init(host);
+        sdhci_init(host, 0);
        sdhci_enable_card_detection(host);
 }
@@ -376,6 +387,20 @@ static void sdhci_kunmap_atomic(void *buffer, unsigned long *flags)
        local_irq_restore(*flags);
 }
+static void sdhci_set_adma_desc(u8 *desc, u32 addr, int len, unsigned cmd)
+{
+        __le32 *dataddr = (__le32 __force *)(desc + 4);
+        __le16 *cmdlen = (__le16 __force *)desc;
+        /* SDHCI specification says ADMA descriptors should be 4 byte
+         * aligned, so using 16 or 32bit operations should be safe. */
+        cmdlen[0] = cpu_to_le16(cmd);
+        cmdlen[1] = cpu_to_le16(len);
+        dataddr[0] = cpu_to_le32(addr);
+}
 static int sdhci_adma_table_pre(struct sdhci_host *host,
        struct mmc_data *data)
 {
@@ -443,19 +468,11 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
                                sdhci_kunmap_atomic(buffer, &flags);
                        }
-                        desc[7] = (align_addr >> 24) & 0xff;
+                        /* tran, valid */
-                        desc[6] = (align_addr >> 16) & 0xff;
+                        sdhci_set_adma_desc(desc, align_addr, offset, 0x21);
-                        desc[5] = (align_addr >> 8) & 0xff;
-                        desc[4] = (align_addr >> 0) & 0xff;
                        BUG_ON(offset > 65536);
-                        desc[3] = (offset >> 8) & 0xff;
-                        desc[2] = (offset >> 0) & 0xff;
-                        desc[1] = 0x00;
-                        desc[0] = 0x21; /* tran, valid */
                        align += 4;
                        align_addr += 4;
@@ -465,19 +482,10 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
                        len -= offset;
                }
-                desc[7] = (addr >> 24) & 0xff;
-                desc[6] = (addr >> 16) & 0xff;
-                desc[5] = (addr >> 8) & 0xff;
-                desc[4] = (addr >> 0) & 0xff;
                BUG_ON(len > 65536);
-                desc[3] = (len >> 8) & 0xff;
+                /* tran, valid */
-                desc[2] = (len >> 0) & 0xff;
+                sdhci_set_adma_desc(desc, addr, len, 0x21);
-                desc[1] = 0x00;
-                desc[0] = 0x21; /* tran, valid */
                desc += 8;
                /*
@@ -490,16 +498,9 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
        /*
         * Add a terminating entry.
         */
-        desc[7] = 0;
-        desc[6] = 0;
-        desc[5] = 0;
-        desc[4] = 0;
-        desc[3] = 0;
+        /* nop, end, valid */
-        desc[2] = 0;
+        sdhci_set_adma_desc(desc, 0, 0, 0x3);
-        desc[1] = 0x00;
-        desc[0] = 0x03; /* nop, end, valid */
        /*
         * Resync align buffer as we might have changed it.
@@ -1610,16 +1611,13 @@ int sdhci_resume_host(struct sdhci_host *host)
        if (ret)
                return ret;
-        sdhci_init(host);
+        sdhci_init(host, (host->mmc->pm_flags & MMC_PM_KEEP_POWER));
        mmiowb();
        ret = mmc_resume_host(host->mmc);
-        if (ret)
-                return ret;
        sdhci_enable_card_detection(host);
-        return 0;
+        return ret;
 }
 EXPORT_SYMBOL_GPL(sdhci_resume_host);
@@ -1874,7 +1872,7 @@ int sdhci_add_host(struct sdhci_host *host)
        if (ret)
                goto untasklet;
-        sdhci_init(host);
+        sdhci_init(host, 0);
 #ifdef CONFIG_MMC_DEBUG
        sdhci_dumpregs(host);
diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 14cec04c34f9..bc45ef9af17d 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -37,6 +37,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/stringify.h>
+#include <linux/namei.h>
 #include <linux/stat.h>
 #include <linux/miscdevice.h>
 #include <linux/log2.h>
@@ -50,7 +51,8 @@
 /**
 * struct mtd_dev_param - MTD device parameter description data structure.
- * @name: MTD device name or number string
+ * @name: MTD character device node path, MTD device name, or MTD device number
+ *        string
 * @vid_hdr_offs: VID header offset
 */
 struct mtd_dev_param {
@@ -59,10 +61,10 @@ struct mtd_dev_param {
 };
 /* Numbers of elements set in the @mtd_dev_param array */
-static int mtd_devs;
+static int __initdata mtd_devs;
 /* MTD devices specification parameters */
-static struct mtd_dev_param mtd_dev_param[UBI_MAX_DEVICES];
+static struct mtd_dev_param __initdata mtd_dev_param[UBI_MAX_DEVICES];
 /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
 struct class *ubi_class;
@@ -363,11 +365,13 @@ static void dev_release(struct device *dev)
 /**
 * ubi_sysfs_init - initialize sysfs for an UBI device.
 * @ubi: UBI device description object
+ * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
+ *       taken
 *
 * This function returns zero in case of success and a negative error code in
 * case of failure.
 */
-static int ubi_sysfs_init(struct ubi_device *ubi)
+static int ubi_sysfs_init(struct ubi_device *ubi, int *ref)
 {
        int err;
@@ -379,6 +383,7 @@ static int ubi_sysfs_init(struct ubi_device *ubi)
        if (err)
                return err;
+        *ref = 1;
        err = device_create_file(&ubi->dev, &dev_eraseblock_size);
        if (err)
                return err;
@@ -434,7 +439,7 @@ static void ubi_sysfs_close(struct ubi_device *ubi)
 }
 /**
- * kill_volumes - destroy all volumes.
+ * kill_volumes - destroy all user volumes.
 * @ubi: UBI device description object
 */
 static void kill_volumes(struct ubi_device *ubi)
@@ -447,36 +452,29 @@ static void kill_volumes(struct ubi_device *ubi)
 }
 /**
- * free_user_volumes - free all user volumes.
- * @ubi: UBI device description object
- *
- * Normally the volumes are freed at the release function of the volume device
- * objects. However, on error paths the volumes have to be freed before the
- * device objects have been initialized.
- */
-static void free_user_volumes(struct ubi_device *ubi)
-{
-        int i;
-        for (i = 0; i < ubi->vtbl_slots; i++)
-                if (ubi->volumes[i]) {
-                        kfree(ubi->volumes[i]->eba_tbl);
-                        kfree(ubi->volumes[i]);
-                }
-}
-/**
 * uif_init - initialize user interfaces for an UBI device.
 * @ubi: UBI device description object
+ * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
+ *       taken, otherwise set to %0
+ *
+ * This function initializes various user interfaces for an UBI device. If the
+ * initialization fails at an early stage, this function frees all the
+ * resources it allocated, returns an error, and @ref is set to %0. However,
+ * if the initialization fails after the UBI device was registered in the
+ * driver core subsystem, this function takes a reference to @ubi->dev, because
+ * otherwise the release function ('dev_release()') would free whole @ubi
+ * object. The @ref argument is set to %1 in this case. The caller has to put
+ * this reference.
 *
 * This function returns zero in case of success and a negative error code in
- * case of failure. Note, this function destroys all volumes if it fails.
+ * case of failure.
 */
-static int uif_init(struct ubi_device *ubi)
+static int uif_init(struct ubi_device *ubi, int *ref)
 {
        int i, err;
        dev_t dev;
+        *ref = 0;
        sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
        /*
@@ -504,7 +502,7 @@ static int uif_init(struct ubi_device *ubi)
                goto out_unreg;
        }
-        err = ubi_sysfs_init(ubi);
+        err = ubi_sysfs_init(ubi, ref);
        if (err)
                goto out_sysfs;
@@ -522,6 +520,8 @@ static int uif_init(struct ubi_device *ubi)
 out_volumes:
        kill_volumes(ubi);
 out_sysfs:
+        if (*ref)
+                get_device(&ubi->dev);
        ubi_sysfs_close(ubi);
        cdev_del(&ubi->cdev);
 out_unreg:
@@ -875,7 +875,7 @@ static int ubi_reboot_notifier(struct notifier_block *n, unsigned long state,
 int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
 {
        struct ubi_device *ubi;
-        int i, err, do_free = 1;
+        int i, err, ref = 0;
        /*
         * Check if we already have the same MTD device attached.
@@ -975,9 +975,9 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
                        goto out_detach;
        }
-        err = uif_init(ubi);
+        err = uif_init(ubi, &ref);
        if (err)
-                goto out_nofree;
+                goto out_detach;
        ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name);
        if (IS_ERR(ubi->bgt_thread)) {
@@ -1025,12 +1025,8 @@ int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
 out_uif:
        uif_close(ubi);
-out_nofree:
-        do_free = 0;
 out_detach:
        ubi_wl_close(ubi);
-        if (do_free)
-                free_user_volumes(ubi);
        free_internal_volumes(ubi);
        vfree(ubi->vtbl);
 out_free:
@@ -1039,7 +1035,10 @@ out_free:
 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
        vfree(ubi->dbg_peb_buf);
 #endif
-        kfree(ubi);
+        if (ref)
+                put_device(&ubi->dev);
+        else
+                kfree(ubi);
        return err;
 }
@@ -1096,7 +1095,7 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
        /*
         * Get a reference to the device in order to prevent 'dev_release()'
-         * from freeing @ubi object.
+         * from freeing the @ubi object.
         */
        get_device(&ubi->dev);
@@ -1116,13 +1115,50 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
 }
 /**
- * find_mtd_device - open an MTD device by its name or number.
+ * open_mtd_by_chdev - open an MTD device by its character device node path.
- * @mtd_dev: name or number of the device
+ * @mtd_dev: MTD character device node path
+ *
+ * This helper function opens an MTD device by its character node device path.
+ * Returns MTD device description object in case of success and a negative
+ * error code in case of failure.
+ */
+static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev)
+{
+        int err, major, minor, mode;
+        struct path path;
+        /* Probably this is an MTD character device node path */
+        err = kern_path(mtd_dev, LOOKUP_FOLLOW, &path);
+        if (err)
+                return ERR_PTR(err);
+        /* MTD device number is defined by the major / minor numbers */
+        major = imajor(path.dentry->d_inode);
+        minor = iminor(path.dentry->d_inode);
+        mode = path.dentry->d_inode->i_mode;
+        path_put(&path);
+        if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode))
+                return ERR_PTR(-EINVAL);
+        if (minor & 1)
+                /*
+                 * Just do not think the "/dev/mtdrX" devices support is need,
+                 * so do not support them to avoid doing extra work.
+                 */
+                return ERR_PTR(-EINVAL);
+        return get_mtd_device(NULL, minor / 2);
+}
+/**
+ * open_mtd_device - open MTD device by name, character device path, or number.
+ * @mtd_dev: name, character device node path, or MTD device device number
 *
 * This function tries to open and MTD device described by @mtd_dev string,
- * which is first treated as an ASCII number, and if it is not true, it is
+ * which is first treated as ASCII MTD device number, and if it is not true, it
- * treated as MTD device name. Returns MTD device description object in case of
+ * is treated as MTD device name, and if that is also not true, it is treated
- * success and a negative error code in case of failure.
+ * as MTD character device node path. Returns MTD device description object in
+ * case of success and a negative error code in case of failure.
 */
 static struct mtd_info * __init open_mtd_device(const char *mtd_dev)
 {
@@ -1137,6 +1173,9 @@ static struct mtd_info * __init open_mtd_device(const char *mtd_dev)
                 * MTD device name.
                 */
                mtd = get_mtd_device_nm(mtd_dev);
+                if (IS_ERR(mtd) && PTR_ERR(mtd) == -ENODEV)
+                        /* Probably this is an MTD character device node path */
+                        mtd = open_mtd_by_chdev(mtd_dev);
        } else
                mtd = get_mtd_device(NULL, mtd_num);
@@ -1352,13 +1391,15 @@ static int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp)
 module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000);
 MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: "
-                      "mtd=<name|num>[,<vid_hdr_offs>].\n"
+                      "mtd=<name|num|path>[,<vid_hdr_offs>].\n"
                      "Multiple \"mtd\" parameters may be specified.\n"
-                      "MTD devices may be specified by their number or name.\n"
+                      "MTD devices may be specified by their number, name, or "
+                      "path to the MTD character device node.\n"
                      "Optional \"vid_hdr_offs\" parameter specifies UBI VID "
-                      "header position and data starting position to be used "
+                      "header position to be used by UBI.\n"
-                      "by UBI.\n"
+                      "Example 1: mtd=/dev/mtd0 - attach MTD device "
-                      "Example: mtd=content,1984 mtd=4 - attach MTD device"
+                      "/dev/mtd0.\n"
+                      "Example 2: mtd=content,1984 mtd=4 - attach MTD device "
                      "with name \"content\" using VID header offset 1984, and "
                      "MTD device number 4 with default VID header offset.");
diff --git a/drivers/mtd/ubi/debug.h b/drivers/mtd/ubi/debug.h
index f30bcb372c05..17a107129726 100644
--- a/drivers/mtd/ubi/debug.h
+++ b/drivers/mtd/ubi/debug.h
@@ -96,8 +96,11 @@ void ubi_dbg_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len);
 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
 int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len);
+int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,
+                        int offset, int len);
 #else
 #define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0
+#define ubi_dbg_check_write(ubi, buf, pnum, offset, len) 0
 #endif
 #ifdef CONFIG_MTD_UBI_DEBUG_DISABLE_BGT
@@ -176,6 +179,7 @@ static inline int ubi_dbg_is_erase_failure(void)
 #define ubi_dbg_is_write_failure() 0
 #define ubi_dbg_is_erase_failure() 0
 #define ubi_dbg_check_all_ff(ubi, pnum, offset, len) 0
+#define ubi_dbg_check_write(ubi, buf, pnum, offset, len) 0
 #endif /* !CONFIG_MTD_UBI_DEBUG */
 #endif /* !__UBI_DEBUG_H__ */
diff --git a/drivers/mtd/ubi/io.c b/drivers/mtd/ubi/io.c
index 8aa51e7a6a7d..b4ecc84c7549 100644
--- a/drivers/mtd/ubi/io.c
+++ b/drivers/mtd/ubi/io.c
@@ -143,7 +143,7 @@ int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
        err = paranoid_check_not_bad(ubi, pnum);
        if (err)
-                return err > 0 ? -EINVAL : err;
+                return err;
        addr = (loff_t)pnum * ubi->peb_size + offset;
 retry:
@@ -236,12 +236,12 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
        err = paranoid_check_not_bad(ubi, pnum);
        if (err)
-                return err > 0 ? -EINVAL : err;
+                return err;
        /* The area we are writing to has to contain all 0xFF bytes */
        err = ubi_dbg_check_all_ff(ubi, pnum, offset, len);
        if (err)
-                return err > 0 ? -EINVAL : err;
+                return err;
        if (offset >= ubi->leb_start) {
                /*
@@ -250,10 +250,10 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
                 */
                err = paranoid_check_peb_ec_hdr(ubi, pnum);
                if (err)
-                        return err > 0 ? -EINVAL : err;
+                        return err;
                err = paranoid_check_peb_vid_hdr(ubi, pnum);
                if (err)
-                        return err > 0 ? -EINVAL : err;
+                        return err;
        }
        if (ubi_dbg_is_write_failure()) {
@@ -273,6 +273,21 @@ int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
        } else
                ubi_assert(written == len);
+        if (!err) {
+                err = ubi_dbg_check_write(ubi, buf, pnum, offset, len);
+                if (err)
+                        return err;
+                /*
+                 * Since we always write sequentially, the rest of the PEB has
+                 * to contain only 0xFF bytes.
+                 */
+                offset += len;
+                len = ubi->peb_size - offset;
+                if (len)
+                        err = ubi_dbg_check_all_ff(ubi, pnum, offset, len);
+        }
        return err;
 }
@@ -348,7 +363,7 @@ retry:
        err = ubi_dbg_check_all_ff(ubi, pnum, 0, ubi->peb_size);
        if (err)
-                return err > 0 ? -EINVAL : err;
+                return err;
        if (ubi_dbg_is_erase_failure() && !err) {
                dbg_err("cannot erase PEB %d (emulated)", pnum);
@@ -542,7 +557,7 @@ int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
        err = paranoid_check_not_bad(ubi, pnum);
        if (err != 0)
-                return err > 0 ? -EINVAL : err;
+                return err;
        if (ubi->ro_mode) {
                ubi_err("read-only mode");
@@ -819,7 +834,7 @@ int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
        err = paranoid_check_ec_hdr(ubi, pnum, ec_hdr);
        if (err)
-                return -EINVAL;
+                return err;
        err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
        return err;
@@ -1083,7 +1098,7 @@ int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
        err = paranoid_check_peb_ec_hdr(ubi, pnum);
        if (err)
-                return err > 0 ? -EINVAL : err;
+                return err;
        vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
        vid_hdr->version = UBI_VERSION;
@@ -1092,7 +1107,7 @@ int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
        err = paranoid_check_vid_hdr(ubi, pnum, vid_hdr);
        if (err)
-                return -EINVAL;
+                return err;
        p = (char *)vid_hdr - ubi->vid_hdr_shift;
        err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
@@ -1107,8 +1122,8 @@ int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
 * @ubi: UBI device description object
 * @pnum: physical eraseblock number to check
 *
- * This function returns zero if the physical eraseblock is good, a positive
+ * This function returns zero if the physical eraseblock is good, %-EINVAL if
- * number if it is bad and a negative error code if an error occurred.
+ * it is bad and a negative error code if an error occurred.
 */
 static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum)
 {
@@ -1120,7 +1135,7 @@ static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum)
        ubi_err("paranoid check failed for PEB %d", pnum);
        ubi_dbg_dump_stack();
-        return err;
+        return err > 0 ? -EINVAL : err;
 }
 /**
@@ -1130,7 +1145,7 @@ static int paranoid_check_not_bad(const struct ubi_device *ubi, int pnum)
 * @ec_hdr: the erase counter header to check
 *
 * This function returns zero if the erase counter header contains valid
- * values, and %1 if not.
+ * values, and %-EINVAL if not.
 */
 static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
                                 const struct ubi_ec_hdr *ec_hdr)
@@ -1156,7 +1171,7 @@ static int paranoid_check_ec_hdr(const struct ubi_device *ubi, int pnum,
 fail:
        ubi_dbg_dump_ec_hdr(ec_hdr);
        ubi_dbg_dump_stack();
-        return 1;
+        return -EINVAL;
 }
 /**
@@ -1164,8 +1179,8 @@ fail:
 * @ubi: UBI device description object
 * @pnum: the physical eraseblock number to check
 *
- * This function returns zero if the erase counter header is all right, %1 if
+ * This function returns zero if the erase counter header is all right and and
- * not, and a negative error code if an error occurred.
+ * a negative error code if not or if an error occurred.
 */
 static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
 {
@@ -1188,7 +1203,7 @@ static int paranoid_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
                ubi_err("paranoid check failed for PEB %d", pnum);
                ubi_dbg_dump_ec_hdr(ec_hdr);
                ubi_dbg_dump_stack();
-                err = 1;
+                err = -EINVAL;
                goto exit;
        }
@@ -1206,7 +1221,7 @@ exit:
 * @vid_hdr: the volume identifier header to check
 *
 * This function returns zero if the volume identifier header is all right, and
- * %1 if not.
+ * %-EINVAL if not.
 */
 static int paranoid_check_vid_hdr(const struct ubi_device *ubi, int pnum,
                                  const struct ubi_vid_hdr *vid_hdr)
@@ -1233,7 +1248,7 @@ fail:
        ubi_err("paranoid check failed for PEB %d", pnum);
        ubi_dbg_dump_vid_hdr(vid_hdr);
        ubi_dbg_dump_stack();
-        return 1;
+        return -EINVAL;
 }
@@ -1243,7 +1258,7 @@ fail:
 * @pnum: the physical eraseblock number to check
 *
 * This function returns zero if the volume identifier header is all right,
- * %1 if not, and a negative error code if an error occurred.
+ * and a negative error code if not or if an error occurred.
 */
 static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
 {
@@ -1270,7 +1285,7 @@ static int paranoid_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
                ubi_err("paranoid check failed for PEB %d", pnum);
                ubi_dbg_dump_vid_hdr(vid_hdr);
                ubi_dbg_dump_stack();
-                err = 1;
+                err = -EINVAL;
                goto exit;
        }
@@ -1282,6 +1297,61 @@ exit:
 }
 /**
+ * ubi_dbg_check_write - make sure write succeeded.
+ * @ubi: UBI device description object
+ * @buf: buffer with data which were written
+ * @pnum: physical eraseblock number the data were written to
+ * @offset: offset within the physical eraseblock the data were written to
+ * @len: how many bytes were written
+ *
+ * This functions reads data which were recently written and compares it with
+ * the original data buffer - the data have to match. Returns zero if the data
+ * match and a negative error code if not or in case of failure.
+ */
+int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,
+                        int offset, int len)
+{
+        int err, i;
+        mutex_lock(&ubi->dbg_buf_mutex);
+        err = ubi_io_read(ubi, ubi->dbg_peb_buf, pnum, offset, len);
+        if (err)
+                goto out_unlock;
+        for (i = 0; i < len; i++) {
+                uint8_t c = ((uint8_t *)buf)[i];
+                uint8_t c1 = ((uint8_t *)ubi->dbg_peb_buf)[i];
+                int dump_len;
+                if (c == c1)
+                        continue;
+                ubi_err("paranoid check failed for PEB %d:%d, len %d",
+                        pnum, offset, len);
+                ubi_msg("data differ at position %d", i);
+                dump_len = max_t(int, 128, len - i);
+                ubi_msg("hex dump of the original buffer from %d to %d",
+                        i, i + dump_len);
+                print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
+                               buf + i, dump_len, 1);
+                ubi_msg("hex dump of the read buffer from %d to %d",
+                        i, i + dump_len);
+                print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
+                               ubi->dbg_peb_buf + i, dump_len, 1);
+                ubi_dbg_dump_stack();
+                err = -EINVAL;
+                goto out_unlock;
+        }
+        mutex_unlock(&ubi->dbg_buf_mutex);
+        return 0;
+out_unlock:
+        mutex_unlock(&ubi->dbg_buf_mutex);
+        return err;
+}
+/**
 * ubi_dbg_check_all_ff - check that a region of flash is empty.
 * @ubi: UBI device description object
 * @pnum: the physical eraseblock number to check
@@ -1289,8 +1359,8 @@ exit:
 * @len: the length of the region to check
 *
 * This function returns zero if only 0xFF bytes are present at offset
- * @offset of the physical eraseblock @pnum, %1 if not, and a negative error
+ * @offset of the physical eraseblock @pnum, and a negative error code if not
- * code if an error occurred.
+ * or if an error occurred.
 */
 int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
 {
@@ -1321,7 +1391,7 @@ fail:
        ubi_msg("hex dump of the %d-%d region", offset, offset + len);
        print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
                       ubi->dbg_peb_buf, len, 1);
-        err = 1;
+        err = -EINVAL;
 error:
        ubi_dbg_dump_stack();
        mutex_unlock(&ubi->dbg_buf_mutex);
diff --git a/drivers/mtd/ubi/scan.c b/drivers/mtd/ubi/scan.c
index 90af61a2c3e4..594184bbd56a 100644
--- a/drivers/mtd/ubi/scan.c
+++ b/drivers/mtd/ubi/scan.c
@@ -974,11 +974,8 @@ struct ubi_scan_info *ubi_scan(struct ubi_device *ubi)
                        seb->ec = si->mean_ec;
        err = paranoid_check_si(ubi, si);
-        if (err) {
+        if (err)
-                if (err > 0)
-                        err = -EINVAL;
                goto out_vidh;
-        }
        ubi_free_vid_hdr(ubi, vidh);
        kfree(ech);
@@ -1086,8 +1083,8 @@ void ubi_scan_destroy_si(struct ubi_scan_info *si)
 * @ubi: UBI device description object
 * @si: scanning information
 *
- * This function returns zero if the scanning information is all right, %1 if
+ * This function returns zero if the scanning information is all right, and a
- * not and a negative error code if an error occurred.
+ * negative error code if not or if an error occurred.
 */
 static int paranoid_check_si(struct ubi_device *ubi, struct ubi_scan_info *si)
 {
@@ -1346,7 +1343,7 @@ bad_vid_hdr:
 out:
        ubi_dbg_dump_stack();
-        return 1;
+        return -EINVAL;
 }
 #endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */
diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index 600c7229d5cf..f64ddabd4ac8 100644
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -464,7 +464,7 @@ retry:
                                   ubi->peb_size - ubi->vid_hdr_aloffset);
        if (err) {
                ubi_err("new PEB %d does not contain all 0xFF bytes", e->pnum);
-                return err > 0 ? -EINVAL : err;
+                return err;
        }
        return e->pnum;
@@ -513,7 +513,7 @@ static int sync_erase(struct ubi_device *ubi, struct ubi_wl_entry *e,
        dbg_wl("erase PEB %d, old EC %llu", e->pnum, ec);
        err = paranoid_check_ec(ubi, e->pnum, e->ec);
-        if (err > 0)
+        if (err)
                return -EINVAL;
        ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
@@ -1572,8 +1572,7 @@ void ubi_wl_close(struct ubi_device *ubi)
 * @ec: the erase counter to check
 *
 * This function returns zero if the erase counter of physical eraseblock @pnum
- * is equivalent to @ec, %1 if not, and a negative error code if an error
+ * is equivalent to @ec, and a negative error code if not or if an error occurred.
- * occurred.
 */
 static int paranoid_check_ec(struct ubi_device *ubi, int pnum, int ec)
 {
@@ -1611,8 +1610,8 @@ out_free:
 * @e: the wear-leveling entry to check
 * @root: the root of the tree
 *
- * This function returns zero if @e is in the @root RB-tree and %1 if it is
+ * This function returns zero if @e is in the @root RB-tree and %-EINVAL if it
- * not.
+ * is not.
 */
 static int paranoid_check_in_wl_tree(struct ubi_wl_entry *e,
                                     struct rb_root *root)
@@ -1623,7 +1622,7 @@ static int paranoid_check_in_wl_tree(struct ubi_wl_entry *e,
        ubi_err("paranoid check failed for PEB %d, EC %d, RB-tree %p ",
                e->pnum, e->ec, root);
        ubi_dbg_dump_stack();
-        return 1;
+        return -EINVAL;
 }
 /**
@@ -1632,7 +1631,7 @@ static int paranoid_check_in_wl_tree(struct ubi_wl_entry *e,
 * @ubi: UBI device description object
 * @e: the wear-leveling entry to check
 *
- * This function returns zero if @e is in @ubi->pq and %1 if it is not.
+ * This function returns zero if @e is in @ubi->pq and %-EINVAL if it is not.
 */
 static int paranoid_check_in_pq(struct ubi_device *ubi, struct ubi_wl_entry *e)
 {
@@ -1647,6 +1646,6 @@ static int paranoid_check_in_pq(struct ubi_device *ubi, struct ubi_wl_entry *e)
        ubi_err("paranoid check failed for PEB %d, EC %d, Protect queue",
                e->pnum, e->ec);
        ubi_dbg_dump_stack();
-        return 1;
+        return -EINVAL;
 }
 #endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 6aa526ee9096..61a7b4351e78 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -998,7 +998,7 @@ static int gfar_probe(struct of_device *ofdev,
        }
        /* Need to reverse the bit maps as  bit_map's MSB is q0
-         * but, for_each_bit parses from right to left, which
+         * but, for_each_set_bit parses from right to left, which
         * basically reverses the queue numbers */
        for (i = 0; i< priv->num_grps; i++) {
                priv->gfargrp[i].tx_bit_map = reverse_bitmap(
@@ -1011,7 +1011,7 @@ static int gfar_probe(struct of_device *ofdev,
         * also assign queues to groups */
        for (grp_idx = 0; grp_idx < priv->num_grps; grp_idx++) {
                priv->gfargrp[grp_idx].num_rx_queues = 0x0;
-                for_each_bit(i, &priv->gfargrp[grp_idx].rx_bit_map,
+                for_each_set_bit(i, &priv->gfargrp[grp_idx].rx_bit_map,
                                priv->num_rx_queues) {
                        priv->gfargrp[grp_idx].num_rx_queues++;
                        priv->rx_queue[i]->grp = &priv->gfargrp[grp_idx];
@@ -1019,7 +1019,7 @@ static int gfar_probe(struct of_device *ofdev,
                        rqueue = rqueue | ((RQUEUE_EN0 | RQUEUE_EX0) >> i);
                }
                priv->gfargrp[grp_idx].num_tx_queues = 0x0;
-                for_each_bit (i, &priv->gfargrp[grp_idx].tx_bit_map,
+                for_each_set_bit(i, &priv->gfargrp[grp_idx].tx_bit_map,
                                priv->num_tx_queues) {
                        priv->gfargrp[grp_idx].num_tx_queues++;
                        priv->tx_queue[i]->grp = &priv->gfargrp[grp_idx];
@@ -1709,7 +1709,7 @@ void gfar_configure_coalescing(struct gfar_private *priv,
        if (priv->mode == MQ_MG_MODE) {
                baddr = &regs->txic0;
-                for_each_bit (i, &tx_mask, priv->num_tx_queues) {
+                for_each_set_bit(i, &tx_mask, priv->num_tx_queues) {
                        if (likely(priv->tx_queue[i]->txcoalescing)) {
                                gfar_write(baddr + i, 0);
                                gfar_write(baddr + i, priv->tx_queue[i]->txic);
@@ -1717,7 +1717,7 @@ void gfar_configure_coalescing(struct gfar_private *priv,
                }
                baddr = &regs->rxic0;
-                for_each_bit (i, &rx_mask, priv->num_rx_queues) {
+                for_each_set_bit(i, &rx_mask, priv->num_rx_queues) {
                        if (likely(priv->rx_queue[i]->rxcoalescing)) {
                                gfar_write(baddr + i, 0);
                                gfar_write(baddr + i, priv->rx_queue[i]->rxic);
@@ -2607,7 +2607,7 @@ static int gfar_poll(struct napi_struct *napi, int budget)
                budget_per_queue = left_over_budget/num_queues;
                left_over_budget = 0;
-                for_each_bit(i, &gfargrp->rx_bit_map, priv->num_rx_queues) {
+                for_each_set_bit(i, &gfargrp->rx_bit_map, priv->num_rx_queues) {
                        if (test_bit(i, &serviced_queues))
                                continue;
                        rx_queue = priv->rx_queue[i];
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 45e3532b166f..684af371462d 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -1050,7 +1050,7 @@ static void ixgbe_configure_msix(struct ixgbe_adapter *adapter)
         */
        for (v_idx = 0; v_idx < q_vectors; v_idx++) {
                q_vector = adapter->q_vector[v_idx];
-                /* XXX for_each_bit(...) */
+                /* XXX for_each_set_bit(...) */
                r_idx = find_first_bit(q_vector->rxr_idx,
                                       adapter->num_rx_queues);
diff --git a/drivers/net/ixgbevf/ixgbevf_main.c b/drivers/net/ixgbevf/ixgbevf_main.c
index 235b5fd4b8d4..ca653c49b765 100644
--- a/drivers/net/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ixgbevf/ixgbevf_main.c
@@ -751,7 +751,7 @@ static void ixgbevf_configure_msix(struct ixgbevf_adapter *adapter)
         */
        for (v_idx = 0; v_idx < q_vectors; v_idx++) {
                q_vector = adapter->q_vector[v_idx];
-                /* XXX for_each_bit(...) */
+                /* XXX for_each_set_bit(...) */
                r_idx = find_first_bit(q_vector->rxr_idx,
                                       adapter->num_rx_queues);
diff --git a/drivers/net/wireless/ath/ar9170/main.c b/drivers/net/wireless/ath/ar9170/main.c
index 8a964f130367..a6452af9c6c5 100644
--- a/drivers/net/wireless/ath/ar9170/main.c
+++ b/drivers/net/wireless/ath/ar9170/main.c
@@ -394,7 +394,7 @@ static void ar9170_tx_fake_ampdu_status(struct ar9170 *ar)
                ieee80211_tx_status_irqsafe(ar->hw, skb);
        }
-        for_each_bit(i, &queue_bitmap, BITS_PER_BYTE) {
+        for_each_set_bit(i, &queue_bitmap, BITS_PER_BYTE) {
 #ifdef AR9170_QUEUE_STOP_DEBUG
                printk(KERN_DEBUG "%s: wake queue %d\n",
                       wiphy_name(ar->hw->wiphy), i);
diff --git a/drivers/net/wireless/iwmc3200wifi/debugfs.c b/drivers/net/wireless/iwmc3200wifi/debugfs.c
index be992ca41cf1..c29c994de0e2 100644
--- a/drivers/net/wireless/iwmc3200wifi/debugfs.c
+++ b/drivers/net/wireless/iwmc3200wifi/debugfs.c
@@ -89,7 +89,7 @@ static int iwm_debugfs_dbg_modules_write(void *data, u64 val)
        for (i = 0; i < __IWM_DM_NR; i++)
                iwm->dbg.dbg_module[i] = 0;
-        for_each_bit(bit, &iwm->dbg.dbg_modules, __IWM_DM_NR)
+        for_each_set_bit(bit, &iwm->dbg.dbg_modules, __IWM_DM_NR)
                iwm->dbg.dbg_module[bit] = iwm->dbg.dbg_level;
        return 0;
diff --git a/drivers/net/wireless/iwmc3200wifi/rx.c b/drivers/net/wireless/iwmc3200wifi/rx.c
index ad8f7eabb5aa..8456b4dbd146 100644
--- a/drivers/net/wireless/iwmc3200wifi/rx.c
+++ b/drivers/net/wireless/iwmc3200wifi/rx.c
@@ -1116,7 +1116,7 @@ static int iwm_ntf_stop_resume_tx(struct iwm_priv *iwm, u8 *buf,
                return -EINVAL;
        }
-        for_each_bit(bit, (unsigned long *)&tid_msk, IWM_UMAC_TID_NR) {
+        for_each_set_bit(bit, (unsigned long *)&tid_msk, IWM_UMAC_TID_NR) {
                tid_info = &sta_info->tid_info[bit];
                mutex_lock(&tid_info->mutex);
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 039e87b71442..81d19d5683ac 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -2533,6 +2533,91 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x1518, quirk_i82576_sriov);
 #endif  /* CONFIG_PCI_IOV */
+/*
+ * This is a quirk for the Ricoh MMC controller found as a part of
+ * some mulifunction chips.
+ * This is very similiar and based on the ricoh_mmc driver written by
+ * Philip Langdale. Thank you for these magic sequences.
+ *
+ * These chips implement the four main memory card controllers (SD, MMC, MS, xD)
+ * and one or both of cardbus or firewire.
+ *
+ * It happens that they implement SD and MMC
+ * support as separate controllers (and PCI functions). The linux SDHCI
+ * driver supports MMC cards but the chip detects MMC cards in hardware
+ * and directs them to the MMC controller - so the SDHCI driver never sees
+ * them.
+ *
+ * To get around this, we must disable the useless MMC controller.
+ * At that point, the SDHCI controller will start seeing them
+ * It seems to be the case that the relevant PCI registers to deactivate the
+ * MMC controller live on PCI function 0, which might be the cardbus controller
+ * or the firewire controller, depending on the particular chip in question
+ *
+ * This has to be done early, because as soon as we disable the MMC controller
+ * other pci functions shift up one level, e.g. function #2 becomes function
+ * #1, and this will confuse the pci core.
+ */
+#ifdef CONFIG_MMC_RICOH_MMC
+static void ricoh_mmc_fixup_rl5c476(struct pci_dev *dev)
+{
+        /* disable via cardbus interface */
+        u8 write_enable;
+        u8 write_target;
+        u8 disable;
+        /* disable must be done via function #0 */
+        if (PCI_FUNC(dev->devfn))
+                return;
+        pci_read_config_byte(dev, 0xB7, &disable);
+        if (disable & 0x02)
+                return;
+        pci_read_config_byte(dev, 0x8E, &write_enable);
+        pci_write_config_byte(dev, 0x8E, 0xAA);
+        pci_read_config_byte(dev, 0x8D, &write_target);
+        pci_write_config_byte(dev, 0x8D, 0xB7);
+        pci_write_config_byte(dev, 0xB7, disable | 0x02);
+        pci_write_config_byte(dev, 0x8E, write_enable);
+        pci_write_config_byte(dev, 0x8D, write_target);
+        dev_notice(&dev->dev, "proprietary Ricoh MMC controller disabled (via cardbus function)\n");
+        dev_notice(&dev->dev, "MMC cards are now supported by standard SDHCI controller\n");
+}
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, ricoh_mmc_fixup_rl5c476);
+DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, ricoh_mmc_fixup_rl5c476);
+static void ricoh_mmc_fixup_r5c832(struct pci_dev *dev)
+{
+        /* disable via firewire interface */
+        u8 write_enable;
+        u8 disable;
+        /* disable must be done via function #0 */
+        if (PCI_FUNC(dev->devfn))
+                return;
+        pci_read_config_byte(dev, 0xCB, &disable);
+        if (disable & 0x02)
+                return;
+        pci_read_config_byte(dev, 0xCA, &write_enable);
+        pci_write_config_byte(dev, 0xCA, 0x57);
+        pci_write_config_byte(dev, 0xCB, disable | 0x02);
+        pci_write_config_byte(dev, 0xCA, write_enable);
+        dev_notice(&dev->dev, "proprietary Ricoh MMC controller disabled (via firewire function)\n");
+        dev_notice(&dev->dev, "MMC cards are now supported by standard SDHCI controller\n");
+}
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_R5C832, ricoh_mmc_fixup_r5c832);
+DECLARE_PCI_FIXUP_RESUME_EARLY(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_R5C832, ricoh_mmc_fixup_r5c832);
+#endif /*CONFIG_MMC_RICOH_MMC*/
 static void pci_do_fixups(struct pci_dev *dev, struct pci_fixup *f,
                          struct pci_fixup *end)
 {
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index be5a6b73e601..40845c7e9322 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -226,6 +226,7 @@ static void __exit rtc_exit(void)
 {
        rtc_dev_exit();
        class_destroy(rtc_class);
+        idr_destroy(&rtc_idr);
 }
 subsys_initcall(rtc_init);
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index 86c61f143515..78a018b5c941 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -161,7 +161,7 @@ static int at91_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
        if (offset == 0)
                return -EILSEQ;
-        memset(alrm, 0, sizeof(alrm));
+        memset(alrm, 0, sizeof(*alrm));
        if (alarm != ALARM_DISABLED && offset != 0) {
                rtc_time_to_tm(offset + alarm, tm);
diff --git a/drivers/rtc/rtc-coh901331.c b/drivers/rtc/rtc-coh901331.c
index 03ea530981d1..44c4399ee714 100644
--- a/drivers/rtc/rtc-coh901331.c
+++ b/drivers/rtc/rtc-coh901331.c
@@ -271,12 +271,13 @@ static int coh901331_resume(struct platform_device *pdev)
 {
        struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
-        if (device_may_wakeup(&pdev->dev))
+        if (device_may_wakeup(&pdev->dev)) {
                disable_irq_wake(rtap->irq);
-        else
+        } else {
                clk_enable(rtap->clk);
                writel(rtap->irqmaskstore, rtap->virtbase + COH901331_IRQ_MASK);
                clk_disable(rtap->clk);
+        }
        return 0;
 }
 #else
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 9da02d108b73..91bde976bc0f 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -115,6 +115,15 @@ static ssize_t ep93xx_rtc_show_comp_delete(struct device *dev,
 }
 static DEVICE_ATTR(comp_delete, S_IRUGO, ep93xx_rtc_show_comp_delete, NULL);
+static struct attribute *ep93xx_rtc_attrs[] = {
+        &dev_attr_comp_preload.attr,
+        &dev_attr_comp_delete.attr,
+        NULL
+};
+static const struct attribute_group ep93xx_rtc_sysfs_files = {
+        .attrs  = ep93xx_rtc_attrs,
+};
 static int __init ep93xx_rtc_probe(struct platform_device *pdev)
 {
@@ -123,27 +132,22 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
        struct rtc_device *rtc;
        int err;
-        ep93xx_rtc = kzalloc(sizeof(struct ep93xx_rtc), GFP_KERNEL);
+        ep93xx_rtc = devm_kzalloc(&pdev->dev, sizeof(*ep93xx_rtc), GFP_KERNEL);
-        if (ep93xx_rtc == NULL)
+        if (!ep93xx_rtc)
                return -ENOMEM;
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
+        if (!res)
-                err = -ENXIO;
+                return -ENXIO;
-                goto fail_free;
-        }
-        res = request_mem_region(res->start, resource_size(res), pdev->name);
+        if (!devm_request_mem_region(&pdev->dev, res->start,
-        if (res == NULL) {
+                                     resource_size(res), pdev->name))
-                err = -EBUSY;
+                return -EBUSY;
-                goto fail_free;
-        }
-        ep93xx_rtc->mmio_base = ioremap(res->start, resource_size(res));
+        ep93xx_rtc->mmio_base = devm_ioremap(&pdev->dev, res->start,
-        if (ep93xx_rtc->mmio_base == NULL) {
+                                             resource_size(res));
-                err = -ENXIO;
+        if (!ep93xx_rtc->mmio_base)
-                goto fail;
+                return -ENXIO;
-        }
        pdev->dev.platform_data = ep93xx_rtc;
@@ -151,53 +155,34 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
                                &pdev->dev, &ep93xx_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc)) {
                err = PTR_ERR(rtc);
-                goto fail;
+                goto exit;
        }
        platform_set_drvdata(pdev, rtc);
-        err = device_create_file(&pdev->dev, &dev_attr_comp_preload);
+        err = sysfs_create_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
        if (err)
                goto fail;
-        err = device_create_file(&pdev->dev, &dev_attr_comp_delete);
-        if (err) {
-                device_remove_file(&pdev->dev, &dev_attr_comp_preload);
-                goto fail;
-        }
        return 0;
 fail:
-        if (ep93xx_rtc->mmio_base) {
+        platform_set_drvdata(pdev, NULL);
-                iounmap(ep93xx_rtc->mmio_base);
+        rtc_device_unregister(rtc);
-                pdev->dev.platform_data = NULL;
+exit:
-        }
+        pdev->dev.platform_data = NULL;
-        release_mem_region(res->start, resource_size(res));
-fail_free:
-        kfree(ep93xx_rtc);
        return err;
 }
 static int __exit ep93xx_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_device *rtc = platform_get_drvdata(pdev);
-        struct ep93xx_rtc *ep93xx_rtc = pdev->dev.platform_data;
-        struct resource *res;
-        /* cleanup sysfs */
-        device_remove_file(&pdev->dev, &dev_attr_comp_delete);
-        device_remove_file(&pdev->dev, &dev_attr_comp_preload);
+        sysfs_remove_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
+        platform_set_drvdata(pdev, NULL);
        rtc_device_unregister(rtc);
-        iounmap(ep93xx_rtc->mmio_base);
        pdev->dev.platform_data = NULL;
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(res->start, resource_size(res));
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/rtc/rtc-mc13783.c b/drivers/rtc/rtc-mc13783.c
index 850f983c039c..d60c81b7b693 100644
--- a/drivers/rtc/rtc-mc13783.c
+++ b/drivers/rtc/rtc-mc13783.c
@@ -28,6 +28,34 @@ struct mc13783_rtc {
        int valid;
 };
+static int mc13783_rtc_irq_enable_unlocked(struct device *dev,
+                unsigned int enabled, int irq)
+{
+        struct mc13783_rtc *priv = dev_get_drvdata(dev);
+        int (*func)(struct mc13783 *mc13783, int irq);
+        if (!priv->valid)
+                return -ENODATA;
+        func = enabled ? mc13783_irq_unmask : mc13783_irq_mask;
+        return func(priv->mc13783, irq);
+}
+static int mc13783_rtc_irq_enable(struct device *dev,
+                unsigned int enabled, int irq)
+{
+        struct mc13783_rtc *priv = dev_get_drvdata(dev);
+        int ret;
+        mc13783_lock(priv->mc13783);
+        ret = mc13783_rtc_irq_enable_unlocked(dev, enabled, irq);
+        mc13783_unlock(priv->mc13783);
+        return ret;
+}
 static int mc13783_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
        struct mc13783_rtc *priv = dev_get_drvdata(dev);
@@ -78,6 +106,7 @@ static int mc13783_rtc_set_mmss(struct device *dev, unsigned long secs)
 {
        struct mc13783_rtc *priv = dev_get_drvdata(dev);
        unsigned int seconds, days;
+        unsigned int alarmseconds;
        int ret;
        seconds = secs % 86400;
@@ -86,7 +115,22 @@ static int mc13783_rtc_set_mmss(struct device *dev, unsigned long secs)
        mc13783_lock(priv->mc13783);
        /*
-         * first write seconds=0 to prevent a day switch between writing days
+         * temporarily invalidate alarm to prevent triggering it when the day is
+         * already updated while the time isn't yet.
+         */
+        ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTODA, &alarmseconds);
+        if (unlikely(ret))
+                goto out;
+        if (alarmseconds < 86400) {
+                ret = mc13783_reg_write(priv->mc13783,
+                                MC13783_RTCTODA, 0x1ffff);
+                if (unlikely(ret))
+                        goto out;
+        }
+        /*
+         * write seconds=0 to prevent a day switch between writing days
         * and seconds below
         */
        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTOD, 0);
@@ -101,11 +145,19 @@ static int mc13783_rtc_set_mmss(struct device *dev, unsigned long secs)
        if (unlikely(ret))
                goto out;
-        ret = mc13783_ackirq(priv->mc13783, MC13783_IRQ_RTCRST);
+        /* restore alarm */
+        if (alarmseconds < 86400) {
+                ret = mc13783_reg_write(priv->mc13783,
+                                MC13783_RTCTODA, alarmseconds);
+                if (unlikely(ret))
+                        goto out;
+        }
+        ret = mc13783_irq_ack(priv->mc13783, MC13783_IRQ_RTCRST);
        if (unlikely(ret))
                goto out;
-        ret = mc13783_unmask(priv->mc13783, MC13783_IRQ_RTCRST);
+        ret = mc13783_irq_unmask(priv->mc13783, MC13783_IRQ_RTCRST);
 out:
        priv->valid = !ret;
@@ -114,41 +166,139 @@ out:
        return ret;
 }
-static irqreturn_t mc13783_rtc_update_handler(int irq, void *dev)
+static int mc13783_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
-        struct mc13783_rtc *priv = dev;
+        struct mc13783_rtc *priv = dev_get_drvdata(dev);
-        struct mc13783 *mc13783 = priv->mc13783;
+        unsigned seconds, days;
+        unsigned long s1970;
+        int enabled, pending;
+        int ret;
-        dev_dbg(&priv->rtc->dev, "1HZ\n");
+        mc13783_lock(priv->mc13783);
-        rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_UF);
+        ret = mc13783_reg_read(priv->mc13783, MC13783_RTCTODA, &seconds);
+        if (unlikely(ret))
+                goto out;
+        if (seconds >= 86400) {
+                ret = -ENODATA;
+                goto out;
+        }
+        ret = mc13783_reg_read(priv->mc13783, MC13783_RTCDAY, &days);
+        if (unlikely(ret))
+                goto out;
-        mc13783_ackirq(mc13783, irq);
+        ret = mc13783_irq_status(priv->mc13783, MC13783_IRQ_TODA,
+                        &enabled, &pending);
-        return IRQ_HANDLED;
+out:
+        mc13783_unlock(priv->mc13783);
+        if (ret)
+                return ret;
+        alarm->enabled = enabled;
+        alarm->pending = pending;
+        s1970 = days * 86400 + seconds;
+        rtc_time_to_tm(s1970, &alarm->time);
+        dev_dbg(dev, "%s: %lu\n", __func__, s1970);
+        return 0;
 }
-static int mc13783_rtc_update_irq_enable(struct device *dev,
+static int mc13783_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
-                unsigned int enabled)
 {
        struct mc13783_rtc *priv = dev_get_drvdata(dev);
-        int ret = -ENODATA;
+        unsigned long s1970;
+        unsigned seconds, days;
+        int ret;
        mc13783_lock(priv->mc13783);
-        if (!priv->valid)
+        /* disable alarm to prevent false triggering */
+        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, 0x1ffff);
+        if (unlikely(ret))
                goto out;
-        ret = (enabled ? mc13783_unmask : mc13783_mask)(priv->mc13783,
+        ret = mc13783_irq_ack(priv->mc13783, MC13783_IRQ_TODA);
-                        MC13783_IRQ_1HZ);
+        if (unlikely(ret))
+                goto out;
+        ret = rtc_tm_to_time(&alarm->time, &s1970);
+        if (unlikely(ret))
+                goto out;
+        dev_dbg(dev, "%s: o%2.s %lu\n", __func__, alarm->enabled ? "n" : "ff",
+                        s1970);
+        ret = mc13783_rtc_irq_enable_unlocked(dev, alarm->enabled,
+                        MC13783_IRQ_TODA);
+        if (unlikely(ret))
+                goto out;
+        seconds = s1970 % 86400;
+        days = s1970 / 86400;
+        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCDAYA, days);
+        if (unlikely(ret))
+                goto out;
+        ret = mc13783_reg_write(priv->mc13783, MC13783_RTCTODA, seconds);
 out:
        mc13783_unlock(priv->mc13783);
        return ret;
 }
+static irqreturn_t mc13783_rtc_alarm_handler(int irq, void *dev)
+{
+        struct mc13783_rtc *priv = dev;
+        struct mc13783 *mc13783 = priv->mc13783;
+        dev_dbg(&priv->rtc->dev, "Alarm\n");
+        rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF);
+        mc13783_irq_ack(mc13783, irq);
+        return IRQ_HANDLED;
+}
+static irqreturn_t mc13783_rtc_update_handler(int irq, void *dev)
+{
+        struct mc13783_rtc *priv = dev;
+        struct mc13783 *mc13783 = priv->mc13783;
+        dev_dbg(&priv->rtc->dev, "1HZ\n");
+        rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_UF);
+        mc13783_irq_ack(mc13783, irq);
+        return IRQ_HANDLED;
+}
+static int mc13783_rtc_update_irq_enable(struct device *dev,
+                unsigned int enabled)
+{
+        return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_1HZ);
+}
+static int mc13783_rtc_alarm_irq_enable(struct device *dev,
+                unsigned int enabled)
+{
+        return mc13783_rtc_irq_enable(dev, enabled, MC13783_IRQ_TODA);
+}
 static const struct rtc_class_ops mc13783_rtc_ops = {
        .read_time = mc13783_rtc_read_time,
        .set_mmss = mc13783_rtc_set_mmss,
+        .read_alarm = mc13783_rtc_read_alarm,
+        .set_alarm = mc13783_rtc_set_alarm,
+        .alarm_irq_enable = mc13783_rtc_alarm_irq_enable,
        .update_irq_enable = mc13783_rtc_update_irq_enable,
 };
@@ -160,7 +310,7 @@ static irqreturn_t mc13783_rtc_reset_handler(int irq, void *dev)
        dev_dbg(&priv->rtc->dev, "RTCRST\n");
        priv->valid = 0;
-        mc13783_mask(mc13783, irq);
+        mc13783_irq_mask(mc13783, irq);
        return IRQ_HANDLED;
 }
@@ -169,6 +319,7 @@ static int __devinit mc13783_rtc_probe(struct platform_device *pdev)
 {
        int ret;
        struct mc13783_rtc *priv;
+        int rtcrst_pending;
        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
        if (!priv)
@@ -177,8 +328,6 @@ static int __devinit mc13783_rtc_probe(struct platform_device *pdev)
        priv->mc13783 = dev_get_drvdata(pdev->dev.parent);
        platform_set_drvdata(pdev, priv);
-        priv->valid = 1;
        mc13783_lock(priv->mc13783);
        ret = mc13783_irq_request(priv->mc13783, MC13783_IRQ_RTCRST,
@@ -186,33 +335,45 @@ static int __devinit mc13783_rtc_probe(struct platform_device *pdev)
        if (ret)
                goto err_reset_irq_request;
+        ret = mc13783_irq_status(priv->mc13783, MC13783_IRQ_RTCRST,
+                        NULL, &rtcrst_pending);
+        if (ret)
+                goto err_reset_irq_status;
+        priv->valid = !rtcrst_pending;
        ret = mc13783_irq_request_nounmask(priv->mc13783, MC13783_IRQ_1HZ,
                        mc13783_rtc_update_handler, DRIVER_NAME, priv);
        if (ret)
                goto err_update_irq_request;
-        mc13783_unlock(priv->mc13783);
+        ret = mc13783_irq_request_nounmask(priv->mc13783, MC13783_IRQ_TODA,
+                        mc13783_rtc_alarm_handler, DRIVER_NAME, priv);
+        if (ret)
+                goto err_alarm_irq_request;
        priv->rtc = rtc_device_register(pdev->name,
                        &pdev->dev, &mc13783_rtc_ops, THIS_MODULE);
        if (IS_ERR(priv->rtc)) {
                ret = PTR_ERR(priv->rtc);
-                mc13783_lock(priv->mc13783);
+                mc13783_irq_free(priv->mc13783, MC13783_IRQ_TODA, priv);
+err_alarm_irq_request:
                mc13783_irq_free(priv->mc13783, MC13783_IRQ_1HZ, priv);
 err_update_irq_request:
+err_reset_irq_status:
                mc13783_irq_free(priv->mc13783, MC13783_IRQ_RTCRST, priv);
 err_reset_irq_request:
-                mc13783_unlock(priv->mc13783);
                platform_set_drvdata(pdev, NULL);
                kfree(priv);
        }
+        mc13783_unlock(priv->mc13783);
        return ret;
 }
@@ -220,10 +381,11 @@ static int __devexit mc13783_rtc_remove(struct platform_device *pdev)
 {
        struct mc13783_rtc *priv = platform_get_drvdata(pdev);
-        rtc_device_unregister(priv->rtc);
        mc13783_lock(priv->mc13783);
+        rtc_device_unregister(priv->rtc);
+        mc13783_irq_free(priv->mc13783, MC13783_IRQ_TODA, priv);
        mc13783_irq_free(priv->mc13783, MC13783_IRQ_1HZ, priv);
        mc13783_irq_free(priv->mc13783, MC13783_IRQ_RTCRST, priv);
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 6bd5072d4eb7..8710f9415d98 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -396,8 +396,11 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
        pdata->ioaddr = ioremap(res->start, resource_size(res));
        clk = clk_get(&pdev->dev, "ckil");
-        if (IS_ERR(clk))
+        if (IS_ERR(clk)) {
-                return PTR_ERR(clk);
+                iounmap(pdata->ioaddr);
+                ret = PTR_ERR(clk);
+                goto exit_free_pdata;
+        }
        rate = clk_get_rate(clk);
        clk_put(clk);
diff --git a/drivers/rtc/rtc-pcf2123.c b/drivers/rtc/rtc-pcf2123.c
index e75df9d50e27..2ceb365533b2 100644
--- a/drivers/rtc/rtc-pcf2123.c
+++ b/drivers/rtc/rtc-pcf2123.c
@@ -315,7 +315,7 @@ kfree_exit:
        return ret;
 }
-static int pcf2123_remove(struct spi_device *spi)
+static int __devexit pcf2123_remove(struct spi_device *spi)
 {
        struct pcf2123_plat_data *pdata = spi->dev.platform_data;
        int i;
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index c6a83a2a722c..ed1b86828124 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -57,7 +57,7 @@ enum {
        REG_RTC_COMP_LSB_REG,
        REG_RTC_COMP_MSB_REG,
 };
-const static u8 twl4030_rtc_reg_map[] = {
+static const u8 twl4030_rtc_reg_map[] = {
        [REG_SECONDS_REG] = 0x00,
        [REG_MINUTES_REG] = 0x01,
        [REG_HOURS_REG] = 0x02,
@@ -80,7 +80,7 @@ const static u8 twl4030_rtc_reg_map[] = {
        [REG_RTC_COMP_LSB_REG] = 0x10,
        [REG_RTC_COMP_MSB_REG] = 0x11,
 };
-const static u8 twl6030_rtc_reg_map[] = {
+static const u8 twl6030_rtc_reg_map[] = {
        [REG_SECONDS_REG] = 0x00,
        [REG_MINUTES_REG] = 0x01,
        [REG_HOURS_REG] = 0x02,
diff --git a/drivers/staging/pohmelfs/inode.c b/drivers/staging/pohmelfs/inode.c
index f69b7783027f..11fc4d5c43e1 100644
--- a/drivers/staging/pohmelfs/inode.c
+++ b/drivers/staging/pohmelfs/inode.c
@@ -969,7 +969,7 @@ int pohmelfs_setattr_raw(struct inode *inode, struct iattr *attr)
        if ((attr->ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
            (attr->ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
-                err = vfs_dq_transfer(inode, attr) ? -EDQUOT : 0;
+                err = dquot_transfer(inode, attr);
                if (err)
                        goto err_out_exit;
        }
diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
index fc7d9bbb548c..8e8f18d29d7a 100644
--- a/drivers/video/console/Kconfig
+++ b/drivers/video/console/Kconfig
@@ -37,6 +37,7 @@ config VGACON_SOFT_SCROLLBACK
 config VGACON_SOFT_SCROLLBACK_SIZE
       int "Scrollback Buffer Size (in KB)"
       depends on VGACON_SOFT_SCROLLBACK
+       range 1 1024
       default "64"
       help
         Enter the amount of System RAM to allocate for the scrollback
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index cc4bbbe44aca..182dd6f8aadd 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -112,7 +112,7 @@ static int 		vga_video_font_height;
 static int              vga_scan_lines          __read_mostly;
 static unsigned int     vga_rolled_over;
-int vgacon_text_mode_force = 0;
+static int vgacon_text_mode_force;
 bool vgacon_text_force(void)
 {
diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig
index cab100acf983..fad3df2c1276 100644
--- a/drivers/xen/Kconfig
+++ b/drivers/xen/Kconfig
@@ -1,6 +1,8 @@
+menu "Xen driver support"
+        depends on XEN
 config XEN_BALLOON
        bool "Xen memory balloon driver"
-        depends on XEN
        default y
        help
          The balloon driver allows the Xen domain to request more memory from
@@ -20,7 +22,6 @@ config XEN_SCRUB_PAGES
 config XEN_DEV_EVTCHN
        tristate "Xen /dev/xen/evtchn device"
-        depends on XEN
        default y
        help
          The evtchn driver allows a userspace process to triger event
@@ -30,7 +31,6 @@ config XEN_DEV_EVTCHN
 config XENFS
        tristate "Xen filesystem"
-        depends on XEN
        default y
        help
          The xen filesystem provides a way for domains to share
@@ -53,11 +53,13 @@ config XEN_COMPAT_XENFS
 config XEN_SYS_HYPERVISOR
       bool "Create xen entries under /sys/hypervisor"
-       depends on XEN && SYSFS
+       depends on SYSFS
       select SYS_HYPERVISOR
       default y
       help
         Create entries under /sys/hypervisor describing the Xen
         hypervisor environment.  When running native or in another
         virtual environment, /sys/hypervisor will still be present,
-         but will have no xen contents.
-\ No newline at end of file
+         but will have no xen contents.
+endmenu