Merge commit 'v2.6.39-rc1' into perf/urgent

Merge reason: use the post-merge-window tree.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

119 files changed, 7156 insertions, 2899 deletions

diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index a18e497f1c3c..31e9e10f657e 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -824,11 +824,6 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
                 device->backlight->props.brightness =
                                 acpi_video_get_brightness(device->backlight);
 
-                result = sysfs_create_link(&device->backlight->dev.kobj,
-                                           &device->dev->dev.kobj, "device");
-                if (result)
-                        printk(KERN_ERR PREFIX "Create sysfs link\n");
-
                 device->cooling_dev = thermal_cooling_device_register("LCD",
                                         device->dev, &video_cooling_ops);
                 if (IS_ERR(device->cooling_dev)) {
@@ -1381,7 +1376,6 @@ static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
                        "Cant remove video notify handler\n");
         }
         if (device->backlight) {
-                sysfs_remove_link(&device->backlight->dev.kobj, "device");
                 backlight_device_unregister(device->backlight);
                 device->backlight = NULL;
         }
diff --git a/drivers/ata/pata_ixp4xx_cf.c b/drivers/ata/pata_ixp4xx_cf.c
index 5253b271b3fe..f6b3f995f58a 100644
--- a/drivers/ata/pata_ixp4xx_cf.c
+++ b/drivers/ata/pata_ixp4xx_cf.c
@@ -167,7 +167,7 @@ static __devinit int ixp4xx_pata_probe(struct platform_device *pdev)
 
         irq = platform_get_irq(pdev, 0);
         if (irq)
-                set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
+                irq_set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
 
         /* Setup expansion bus chip selects */
         *data->cs0_cfg = data->cs0_bits;
diff --git a/drivers/ata/pata_rb532_cf.c b/drivers/ata/pata_rb532_cf.c
index baeaf938d55b..1b9d10d9c5d9 100644
--- a/drivers/ata/pata_rb532_cf.c
+++ b/drivers/ata/pata_rb532_cf.c
@@ -60,10 +60,10 @@ static irqreturn_t rb532_pata_irq_handler(int irq, void *dev_instance)
         struct rb532_cf_info *info = ah->private_data;
 
         if (gpio_get_value(info->gpio_line)) {
-                set_irq_type(info->irq, IRQ_TYPE_LEVEL_LOW);
+                irq_set_irq_type(info->irq, IRQ_TYPE_LEVEL_LOW);
                 ata_sff_interrupt(info->irq, dev_instance);
         } else {
-                set_irq_type(info->irq, IRQ_TYPE_LEVEL_HIGH);
+                irq_set_irq_type(info->irq, IRQ_TYPE_LEVEL_HIGH);
         }
 
         return IRQ_HANDLED;
diff --git a/drivers/block/drbd/drbd_bitmap.c b/drivers/block/drbd/drbd_bitmap.c
index f0ae63d2df65..76210ba401ac 100644
--- a/drivers/block/drbd/drbd_bitmap.c
+++ b/drivers/block/drbd/drbd_bitmap.c
@@ -29,8 +29,6 @@
 #include <linux/slab.h>
 #include <asm/kmap_types.h>
 
-#include <asm-generic/bitops/le.h>
-
 #include "drbd_int.h"
 
 
@@ -1184,10 +1182,10 @@ static unsigned long __bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo,
                         p_addr = __bm_map_pidx(b, bm_bit_to_page_idx(b, bm_fo), km);
 
                         if (find_zero_bit)
-                                i = generic_find_next_zero_le_bit(p_addr,
+                                i = find_next_zero_bit_le(p_addr,
                                                 PAGE_SIZE*8, bm_fo & BITS_PER_PAGE_MASK);
                         else
-                                i = generic_find_next_le_bit(p_addr,
+                                i = find_next_bit_le(p_addr,
                                                 PAGE_SIZE*8, bm_fo & BITS_PER_PAGE_MASK);
 
                         __bm_unmap(p_addr, km);
@@ -1287,9 +1285,9 @@ static int __bm_change_bits_to(struct drbd_conf *mdev, const unsigned long s,
                         last_page_nr = page_nr;
                 }
                 if (val)
-                        c += (0 == generic___test_and_set_le_bit(bitnr & BITS_PER_PAGE_MASK, p_addr));
+                        c += (0 == __test_and_set_bit_le(bitnr & BITS_PER_PAGE_MASK, p_addr));
                 else
-                        c -= (0 != generic___test_and_clear_le_bit(bitnr & BITS_PER_PAGE_MASK, p_addr));
+                        c -= (0 != __test_and_clear_bit_le(bitnr & BITS_PER_PAGE_MASK, p_addr));
         }
         if (p_addr)
                 __bm_unmap(p_addr, km);
@@ -1438,7 +1436,7 @@ int drbd_bm_test_bit(struct drbd_conf *mdev, const unsigned long bitnr)
                 bm_print_lock_info(mdev);
         if (bitnr < b->bm_bits) {
                 p_addr = bm_map_pidx(b, bm_bit_to_page_idx(b, bitnr));
-                i = generic_test_le_bit(bitnr & BITS_PER_PAGE_MASK, p_addr) ? 1 : 0;
+                i = test_bit_le(bitnr & BITS_PER_PAGE_MASK, p_addr) ? 1 : 0;
                 bm_unmap(p_addr);
         } else if (bitnr == b->bm_bits) {
                 i = -1;
@@ -1482,7 +1480,7 @@ int drbd_bm_count_bits(struct drbd_conf *mdev, const unsigned long s, const unsi
                 ERR_IF (bitnr >= b->bm_bits) {
                         dev_err(DEV, "bitnr=%lu bm_bits=%lu\n", bitnr, b->bm_bits);
                 } else {
-                        c += (0 != generic_test_le_bit(bitnr - (page_nr << (PAGE_SHIFT+3)), p_addr));
+                        c += (0 != test_bit_le(bitnr - (page_nr << (PAGE_SHIFT+3)), p_addr));
                 }
         }
         if (p_addr)
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index 1f46f1cd9225..7beb0e25f1e1 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -980,7 +980,7 @@ int tpm_open(struct inode *inode, struct file *file)
                 return -EBUSY;
         }
 
-        chip->data_buffer = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
+        chip->data_buffer = kzalloc(TPM_BUFSIZE, GFP_KERNEL);
         if (chip->data_buffer == NULL) {
                 clear_bit(0, &chip->is_open);
                 put_device(chip->dev);
diff --git a/drivers/dma/ipu/ipu_irq.c b/drivers/dma/ipu/ipu_irq.c
index dd8ebc75b667..ab8a4eff072a 100644
--- a/drivers/dma/ipu/ipu_irq.c
+++ b/drivers/dma/ipu/ipu_irq.c
@@ -94,9 +94,9 @@ static struct ipu_irq_map *src2map(unsigned int src)
         return NULL;
 }
 
-static void ipu_irq_unmask(unsigned int irq)
+static void ipu_irq_unmask(struct irq_data *d)
 {
-        struct ipu_irq_map *map = get_irq_chip_data(irq);
+        struct ipu_irq_map *map = irq_data_get_irq_chip_data(d);
         struct ipu_irq_bank *bank;
         uint32_t reg;
         unsigned long lock_flags;
@@ -106,7 +106,7 @@ static void ipu_irq_unmask(unsigned int irq)
         bank = map->bank;
         if (!bank) {
                 spin_unlock_irqrestore(&bank_lock, lock_flags);
-                pr_err("IPU: %s(%u) - unmapped!\n", __func__, irq);
+                pr_err("IPU: %s(%u) - unmapped!\n", __func__, d->irq);
                 return;
         }
 
@@ -117,9 +117,9 @@ static void ipu_irq_unmask(unsigned int irq)
         spin_unlock_irqrestore(&bank_lock, lock_flags);
 }
 
-static void ipu_irq_mask(unsigned int irq)
+static void ipu_irq_mask(struct irq_data *d)
 {
-        struct ipu_irq_map *map = get_irq_chip_data(irq);
+        struct ipu_irq_map *map = irq_data_get_irq_chip_data(d);
         struct ipu_irq_bank *bank;
         uint32_t reg;
         unsigned long lock_flags;
@@ -129,7 +129,7 @@ static void ipu_irq_mask(unsigned int irq)
         bank = map->bank;
         if (!bank) {
                 spin_unlock_irqrestore(&bank_lock, lock_flags);
-                pr_err("IPU: %s(%u) - unmapped!\n", __func__, irq);
+                pr_err("IPU: %s(%u) - unmapped!\n", __func__, d->irq);
                 return;
         }
 
@@ -140,9 +140,9 @@ static void ipu_irq_mask(unsigned int irq)
         spin_unlock_irqrestore(&bank_lock, lock_flags);
 }
 
-static void ipu_irq_ack(unsigned int irq)
+static void ipu_irq_ack(struct irq_data *d)
 {
-        struct ipu_irq_map *map = get_irq_chip_data(irq);
+        struct ipu_irq_map *map = irq_data_get_irq_chip_data(d);
         struct ipu_irq_bank *bank;
         unsigned long lock_flags;
 
@@ -151,7 +151,7 @@ static void ipu_irq_ack(unsigned int irq)
         bank = map->bank;
         if (!bank) {
                 spin_unlock_irqrestore(&bank_lock, lock_flags);
-                pr_err("IPU: %s(%u) - unmapped!\n", __func__, irq);
+                pr_err("IPU: %s(%u) - unmapped!\n", __func__, d->irq);
                 return;
         }
 
@@ -167,7 +167,7 @@ static void ipu_irq_ack(unsigned int irq)
  */
 bool ipu_irq_status(unsigned int irq)
 {
-        struct ipu_irq_map *map = get_irq_chip_data(irq);
+        struct ipu_irq_map *map = irq_get_chip_data(irq);
         struct ipu_irq_bank *bank;
         unsigned long lock_flags;
         bool ret;
@@ -269,7 +269,7 @@ int ipu_irq_unmap(unsigned int source)
 /* Chained IRQ handler for IPU error interrupt */
 static void ipu_irq_err(unsigned int irq, struct irq_desc *desc)
 {
-        struct ipu *ipu = get_irq_data(irq);
+        struct ipu *ipu = irq_get_handler_data(irq);
         u32 status;
         int i, line;
 
@@ -310,7 +310,7 @@ static void ipu_irq_err(unsigned int irq, struct irq_desc *desc)
 /* Chained IRQ handler for IPU function interrupt */
 static void ipu_irq_fn(unsigned int irq, struct irq_desc *desc)
 {
-        struct ipu *ipu = get_irq_data(irq);
+        struct ipu *ipu = irq_desc_get_handler_data(desc);
         u32 status;
         int i, line;
 
@@ -345,10 +345,10 @@ static void ipu_irq_fn(unsigned int irq, struct irq_desc *desc)
 }
 
 static struct irq_chip ipu_irq_chip = {
-        .name   = "ipu_irq",
-        .ack    = ipu_irq_ack,
-        .mask   = ipu_irq_mask,
-        .unmask = ipu_irq_unmask,
+        .name           = "ipu_irq",
+        .irq_ack        = ipu_irq_ack,
+        .irq_mask       = ipu_irq_mask,
+        .irq_unmask     = ipu_irq_unmask,
 };
 
 /* Install the IRQ handler */
@@ -366,26 +366,26 @@ int __init ipu_irq_attach_irq(struct ipu *ipu, struct platform_device *dev)
                 int ret;
 
                 irq = irq_base + i;
-                ret = set_irq_chip(irq, &ipu_irq_chip);
+                ret = irq_set_chip(irq, &ipu_irq_chip);
                 if (ret < 0)
                         return ret;
-                ret = set_irq_chip_data(irq, irq_map + i);
+                ret = irq_set_chip_data(irq, irq_map + i);
                 if (ret < 0)
                         return ret;
                 irq_map[i].ipu = ipu;
                 irq_map[i].irq = irq;
                 irq_map[i].source = -EINVAL;
-                set_irq_handler(irq, handle_level_irq);
+                irq_set_handler(irq, handle_level_irq);
 #ifdef CONFIG_ARM
                 set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
 #endif
         }
 
-        set_irq_data(ipu->irq_fn, ipu);
-        set_irq_chained_handler(ipu->irq_fn, ipu_irq_fn);
+        irq_set_handler_data(ipu->irq_fn, ipu);
+        irq_set_chained_handler(ipu->irq_fn, ipu_irq_fn);
 
-        set_irq_data(ipu->irq_err, ipu);
-        set_irq_chained_handler(ipu->irq_err, ipu_irq_err);
+        irq_set_handler_data(ipu->irq_err, ipu);
+        irq_set_chained_handler(ipu->irq_err, ipu_irq_err);
 
         return 0;
 }
@@ -397,17 +397,17 @@ void ipu_irq_detach_irq(struct ipu *ipu, struct platform_device *dev)
 
         irq_base = pdata->irq_base;
 
-        set_irq_chained_handler(ipu->irq_fn, NULL);
-        set_irq_data(ipu->irq_fn, NULL);
+        irq_set_chained_handler(ipu->irq_fn, NULL);
+        irq_set_handler_data(ipu->irq_fn, NULL);
 
-        set_irq_chained_handler(ipu->irq_err, NULL);
-        set_irq_data(ipu->irq_err, NULL);
+        irq_set_chained_handler(ipu->irq_err, NULL);
+        irq_set_handler_data(ipu->irq_err, NULL);
 
         for (irq = irq_base; irq < irq_base + CONFIG_MX3_IPU_IRQS; irq++) {
 #ifdef CONFIG_ARM
                 set_irq_flags(irq, 0);
 #endif
-                set_irq_chip(irq, NULL);
-                set_irq_chip_data(irq, NULL);
+                irq_set_chip(irq, NULL);
+                irq_set_chip_data(irq, NULL);
         }
 }
diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c
index 0be30e978c85..31e71c4fc831 100644
--- a/drivers/edac/amd64_edac.c
+++ b/drivers/edac/amd64_edac.c
@@ -2679,7 +2679,7 @@ static int __init amd64_edac_init(void)
         mcis      = kzalloc(amd_nb_num() * sizeof(mcis[0]), GFP_KERNEL);
         ecc_stngs = kzalloc(amd_nb_num() * sizeof(ecc_stngs[0]), GFP_KERNEL);
         if (!(mcis && ecc_stngs))
-                goto err_ret;
+                goto err_free;
 
         msrs = msrs_alloc();
         if (!msrs)
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index d8d0cda2641d..d3b295305542 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -414,4 +414,9 @@ config GPIO_JANZ_TTL
           This driver provides support for driving the pins in output
           mode only. Input mode is not supported.
 
+config AB8500_GPIO
+        bool "ST-Ericsson AB8500 Mixed Signal Circuit gpio functions"
+        depends on AB8500_CORE && BROKEN
+        help
+          Select this to enable the AB8500 IC GPIO driver
 endif
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 3351cf87b0ed..becef5954356 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -42,3 +42,4 @@ obj-$(CONFIG_GPIO_JANZ_TTL)	+= janz-ttl.o
 obj-$(CONFIG_GPIO_SX150X)       += sx150x.o
 obj-$(CONFIG_GPIO_VX855)        += vx855_gpio.o
 obj-$(CONFIG_GPIO_ML_IOH)       += ml_ioh_gpio.o
+obj-$(CONFIG_AB8500_GPIO)       += ab8500-gpio.o
diff --git a/drivers/gpio/ab8500-gpio.c b/drivers/gpio/ab8500-gpio.c
new file mode 100644
index 000000000000..e7b834d054b7
--- /dev/null
+++ b/drivers/gpio/ab8500-gpio.c
@@ -0,0 +1,522 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2011
+ *
+ * Author: BIBEK BASU <bibek.basu@stericsson.com>
+ * License terms: GNU General Public License (GPL) version 2
+ *
+ * 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.
+ */
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500.h>
+#include <linux/mfd/ab8500/gpio.h>
+
+/*
+ * GPIO registers offset
+ * Bank: 0x10
+ */
+#define AB8500_GPIO_SEL1_REG    0x00
+#define AB8500_GPIO_SEL2_REG    0x01
+#define AB8500_GPIO_SEL3_REG    0x02
+#define AB8500_GPIO_SEL4_REG    0x03
+#define AB8500_GPIO_SEL5_REG    0x04
+#define AB8500_GPIO_SEL6_REG    0x05
+
+#define AB8500_GPIO_DIR1_REG    0x10
+#define AB8500_GPIO_DIR2_REG    0x11
+#define AB8500_GPIO_DIR3_REG    0x12
+#define AB8500_GPIO_DIR4_REG    0x13
+#define AB8500_GPIO_DIR5_REG    0x14
+#define AB8500_GPIO_DIR6_REG    0x15
+
+#define AB8500_GPIO_OUT1_REG    0x20
+#define AB8500_GPIO_OUT2_REG    0x21
+#define AB8500_GPIO_OUT3_REG    0x22
+#define AB8500_GPIO_OUT4_REG    0x23
+#define AB8500_GPIO_OUT5_REG    0x24
+#define AB8500_GPIO_OUT6_REG    0x25
+
+#define AB8500_GPIO_PUD1_REG    0x30
+#define AB8500_GPIO_PUD2_REG    0x31
+#define AB8500_GPIO_PUD3_REG    0x32
+#define AB8500_GPIO_PUD4_REG    0x33
+#define AB8500_GPIO_PUD5_REG    0x34
+#define AB8500_GPIO_PUD6_REG    0x35
+
+#define AB8500_GPIO_IN1_REG     0x40
+#define AB8500_GPIO_IN2_REG     0x41
+#define AB8500_GPIO_IN3_REG     0x42
+#define AB8500_GPIO_IN4_REG     0x43
+#define AB8500_GPIO_IN5_REG     0x44
+#define AB8500_GPIO_IN6_REG     0x45
+#define AB8500_GPIO_ALTFUN_REG  0x45
+#define ALTFUN_REG_INDEX        6
+#define AB8500_NUM_GPIO         42
+#define AB8500_NUM_VIR_GPIO_IRQ 16
+
+enum ab8500_gpio_action {
+        NONE,
+        STARTUP,
+        SHUTDOWN,
+        MASK,
+        UNMASK
+};
+
+struct ab8500_gpio {
+        struct gpio_chip chip;
+        struct ab8500 *parent;
+        struct device *dev;
+        struct mutex lock;
+        u32 irq_base;
+        enum ab8500_gpio_action irq_action;
+        u16 rising;
+        u16 falling;
+};
+/**
+ * to_ab8500_gpio() - get the pointer to ab8500_gpio
+ * @chip:       Member of the structure ab8500_gpio
+ */
+static inline struct ab8500_gpio *to_ab8500_gpio(struct gpio_chip *chip)
+{
+        return container_of(chip, struct ab8500_gpio, chip);
+}
+
+static int ab8500_gpio_set_bits(struct gpio_chip *chip, u8 reg,
+                                        unsigned offset, int val)
+{
+        struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
+        u8 pos = offset % 8;
+        int ret;
+
+        reg = reg + (offset / 8);
+        ret = abx500_mask_and_set_register_interruptible(ab8500_gpio->dev,
+                                AB8500_MISC, reg, 1 << pos, val << pos);
+        if (ret < 0)
+                dev_err(ab8500_gpio->dev, "%s write failed\n", __func__);
+        return ret;
+}
+/**
+ * ab8500_gpio_get() - Get the particular GPIO value
+ * @chip: Gpio device
+ * @offset: GPIO number to read
+ */
+static int ab8500_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
+        u8 mask = 1 << (offset % 8);
+        u8 reg = AB8500_GPIO_OUT1_REG + (offset / 8);
+        int ret;
+        u8 data;
+        ret = abx500_get_register_interruptible(ab8500_gpio->dev, AB8500_MISC,
+                                                reg, &data);
+        if (ret < 0) {
+                dev_err(ab8500_gpio->dev, "%s read failed\n", __func__);
+                return ret;
+        }
+        return (data & mask) >> (offset % 8);
+}
+
+static void ab8500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
+{
+        struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
+        int ret;
+        /* Write the data */
+        ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, 1);
+        if (ret < 0)
+                dev_err(ab8500_gpio->dev, "%s write failed\n", __func__);
+}
+
+static int ab8500_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
+                                        int val)
+{
+        int ret;
+        /* set direction as output */
+        ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_DIR1_REG, offset, 1);
+        if (ret < 0)
+                return ret;
+        /* disable pull down */
+        ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_PUD1_REG, offset, 1);
+        if (ret < 0)
+                return ret;
+        /* set the output as 1 or 0 */
+        return ab8500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, val);
+
+}
+
+static int ab8500_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        /* set the register as input */
+        return ab8500_gpio_set_bits(chip, AB8500_GPIO_DIR1_REG, offset, 0);
+}
+
+static int ab8500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        /*
+         * Only some GPIOs are interrupt capable, and they are
+         * organized in discontiguous clusters:
+         *
+         *      GPIO6 to GPIO13
+         *      GPIO24 and GPIO25
+         *      GPIO36 to GPIO41
+         */
+        static struct ab8500_gpio_irq_cluster {
+                int start;
+                int end;
+        } clusters[] = {
+                {.start = 6,  .end = 13},
+                {.start = 24, .end = 25},
+                {.start = 36, .end = 41},
+        };
+        struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
+        int base = ab8500_gpio->irq_base;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(clusters); i++) {
+                struct ab8500_gpio_irq_cluster *cluster = &clusters[i];
+
+                if (offset >= cluster->start && offset <= cluster->end)
+                        return base + offset - cluster->start;
+
+                /* Advance by the number of gpios in this cluster */
+                base += cluster->end - cluster->start + 1;
+        }
+
+        return -EINVAL;
+}
+
+static struct gpio_chip ab8500gpio_chip = {
+        .label                  = "ab8500_gpio",
+        .owner                  = THIS_MODULE,
+        .direction_input        = ab8500_gpio_direction_input,
+        .get                    = ab8500_gpio_get,
+        .direction_output       = ab8500_gpio_direction_output,
+        .set                    = ab8500_gpio_set,
+        .to_irq                 = ab8500_gpio_to_irq,
+};
+
+static unsigned int irq_to_rising(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        int offset = irq - ab8500_gpio->irq_base;
+        int new_irq = offset +  AB8500_INT_GPIO6R
+                        + ab8500_gpio->parent->irq_base;
+        return new_irq;
+}
+
+static unsigned int irq_to_falling(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        int offset = irq - ab8500_gpio->irq_base;
+        int new_irq = offset +  AB8500_INT_GPIO6F
+                        +  ab8500_gpio->parent->irq_base;
+        return new_irq;
+
+}
+
+static unsigned int rising_to_irq(unsigned int irq, void *dev)
+{
+        struct ab8500_gpio *ab8500_gpio = dev;
+        int offset = irq - AB8500_INT_GPIO6R
+                        - ab8500_gpio->parent->irq_base ;
+        int new_irq = offset + ab8500_gpio->irq_base;
+        return new_irq;
+}
+
+static unsigned int falling_to_irq(unsigned int irq, void *dev)
+{
+        struct ab8500_gpio *ab8500_gpio = dev;
+        int offset = irq - AB8500_INT_GPIO6F
+                        - ab8500_gpio->parent->irq_base ;
+        int new_irq = offset + ab8500_gpio->irq_base;
+        return new_irq;
+
+}
+
+/*
+ * IRQ handler
+ */
+
+static irqreturn_t handle_rising(int irq, void *dev)
+{
+
+        handle_nested_irq(rising_to_irq(irq , dev));
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t handle_falling(int irq, void *dev)
+{
+
+        handle_nested_irq(falling_to_irq(irq, dev));
+        return IRQ_HANDLED;
+}
+
+static void ab8500_gpio_irq_lock(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        mutex_lock(&ab8500_gpio->lock);
+}
+
+static void ab8500_gpio_irq_sync_unlock(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        int offset = irq - ab8500_gpio->irq_base;
+        bool rising = ab8500_gpio->rising & BIT(offset);
+        bool falling = ab8500_gpio->falling & BIT(offset);
+        int ret;
+
+        switch (ab8500_gpio->irq_action)        {
+        case STARTUP:
+                if (rising)
+                        ret = request_threaded_irq(irq_to_rising(irq),
+                                        NULL, handle_rising,
+                                        IRQF_TRIGGER_RISING,
+                                        "ab8500-gpio-r", ab8500_gpio);
+                if (falling)
+                        ret = request_threaded_irq(irq_to_falling(irq),
+                                       NULL, handle_falling,
+                                       IRQF_TRIGGER_FALLING,
+                                       "ab8500-gpio-f", ab8500_gpio);
+                break;
+        case SHUTDOWN:
+                if (rising)
+                        free_irq(irq_to_rising(irq), ab8500_gpio);
+                if (falling)
+                        free_irq(irq_to_falling(irq), ab8500_gpio);
+                break;
+        case MASK:
+                if (rising)
+                        disable_irq(irq_to_rising(irq));
+                if (falling)
+                        disable_irq(irq_to_falling(irq));
+                break;
+        case UNMASK:
+                if (rising)
+                        enable_irq(irq_to_rising(irq));
+                if (falling)
+                        enable_irq(irq_to_falling(irq));
+                break;
+        case NONE:
+                break;
+        }
+        ab8500_gpio->irq_action = NONE;
+        ab8500_gpio->rising &= ~(BIT(offset));
+        ab8500_gpio->falling &= ~(BIT(offset));
+        mutex_unlock(&ab8500_gpio->lock);
+}
+
+
+static void ab8500_gpio_irq_mask(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        ab8500_gpio->irq_action = MASK;
+}
+
+static void ab8500_gpio_irq_unmask(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        ab8500_gpio->irq_action = UNMASK;
+}
+
+static int ab8500_gpio_irq_set_type(unsigned int irq, unsigned int type)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        int offset = irq - ab8500_gpio->irq_base;
+
+        if (type == IRQ_TYPE_EDGE_BOTH) {
+                ab8500_gpio->rising =  BIT(offset);
+                ab8500_gpio->falling = BIT(offset);
+        } else if (type == IRQ_TYPE_EDGE_RISING) {
+                ab8500_gpio->rising =  BIT(offset);
+        } else  {
+                ab8500_gpio->falling = BIT(offset);
+        }
+        return 0;
+}
+
+unsigned int ab8500_gpio_irq_startup(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        ab8500_gpio->irq_action = STARTUP;
+        return 0;
+}
+
+void ab8500_gpio_irq_shutdown(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        ab8500_gpio->irq_action = SHUTDOWN;
+}
+
+static struct irq_chip ab8500_gpio_irq_chip = {
+        .name                   = "ab8500-gpio",
+        .startup                = ab8500_gpio_irq_startup,
+        .shutdown               = ab8500_gpio_irq_shutdown,
+        .bus_lock               = ab8500_gpio_irq_lock,
+        .bus_sync_unlock        = ab8500_gpio_irq_sync_unlock,
+        .mask                   = ab8500_gpio_irq_mask,
+        .unmask                 = ab8500_gpio_irq_unmask,
+        .set_type               = ab8500_gpio_irq_set_type,
+};
+
+static int ab8500_gpio_irq_init(struct ab8500_gpio *ab8500_gpio)
+{
+        u32 base = ab8500_gpio->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + AB8500_NUM_VIR_GPIO_IRQ ; irq++) {
+                set_irq_chip_data(irq, ab8500_gpio);
+                set_irq_chip_and_handler(irq, &ab8500_gpio_irq_chip,
+                                handle_simple_irq);
+                set_irq_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, IRQF_VALID);
+#else
+                set_irq_noprobe(irq);
+#endif
+        }
+
+        return 0;
+}
+
+static void ab8500_gpio_irq_remove(struct ab8500_gpio *ab8500_gpio)
+{
+        int base = ab8500_gpio->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + AB8500_NUM_VIR_GPIO_IRQ; irq++) {
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, 0);
+#endif
+                set_irq_chip_and_handler(irq, NULL, NULL);
+                set_irq_chip_data(irq, NULL);
+        }
+}
+
+static int __devinit ab8500_gpio_probe(struct platform_device *pdev)
+{
+        struct ab8500_platform_data *ab8500_pdata =
+                                dev_get_platdata(pdev->dev.parent);
+        struct ab8500_gpio_platform_data *pdata;
+        struct ab8500_gpio *ab8500_gpio;
+        int ret;
+        int i;
+
+        pdata = ab8500_pdata->gpio;
+        if (!pdata)     {
+                dev_err(&pdev->dev, "gpio platform data missing\n");
+                return -ENODEV;
+        }
+
+        ab8500_gpio = kzalloc(sizeof(struct ab8500_gpio), GFP_KERNEL);
+        if (ab8500_gpio == NULL) {
+                dev_err(&pdev->dev, "failed to allocate memory\n");
+                return -ENOMEM;
+        }
+        ab8500_gpio->dev = &pdev->dev;
+        ab8500_gpio->parent = dev_get_drvdata(pdev->dev.parent);
+        ab8500_gpio->chip = ab8500gpio_chip;
+        ab8500_gpio->chip.ngpio = AB8500_NUM_GPIO;
+        ab8500_gpio->chip.dev = &pdev->dev;
+        ab8500_gpio->chip.base = pdata->gpio_base;
+        ab8500_gpio->irq_base = pdata->irq_base;
+        /* initialize the lock */
+        mutex_init(&ab8500_gpio->lock);
+        /*
+         * AB8500 core will handle and clear the IRQ
+         * configre GPIO based on config-reg value.
+         * These values are for selecting the PINs as
+         * GPIO or alternate function
+         */
+        for (i = AB8500_GPIO_SEL1_REG; i <= AB8500_GPIO_SEL6_REG; i++)  {
+                ret = abx500_set_register_interruptible(ab8500_gpio->dev,
+                                AB8500_MISC, i,
+                                pdata->config_reg[i]);
+                if (ret < 0)
+                        goto out_free;
+        }
+        ret = abx500_set_register_interruptible(ab8500_gpio->dev, AB8500_MISC,
+                                AB8500_GPIO_ALTFUN_REG,
+                                pdata->config_reg[ALTFUN_REG_INDEX]);
+        if (ret < 0)
+                goto out_free;
+
+        ret = ab8500_gpio_irq_init(ab8500_gpio);
+        if (ret)
+                goto out_free;
+        ret = gpiochip_add(&ab8500_gpio->chip);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to add gpiochip: %d\n",
+                                ret);
+                goto out_rem_irq;
+        }
+        platform_set_drvdata(pdev, ab8500_gpio);
+        return 0;
+
+out_rem_irq:
+        ab8500_gpio_irq_remove(ab8500_gpio);
+out_free:
+        mutex_destroy(&ab8500_gpio->lock);
+        kfree(ab8500_gpio);
+        return ret;
+}
+
+/*
+ * ab8500_gpio_remove() - remove Ab8500-gpio driver
+ * @pdev :      Platform device registered
+ */
+static int __devexit ab8500_gpio_remove(struct platform_device *pdev)
+{
+        struct ab8500_gpio *ab8500_gpio = platform_get_drvdata(pdev);
+        int ret;
+
+        ret = gpiochip_remove(&ab8500_gpio->chip);
+        if (ret < 0) {
+                dev_err(ab8500_gpio->dev, "unable to remove gpiochip:\
+                                %d\n", ret);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, NULL);
+        mutex_destroy(&ab8500_gpio->lock);
+        kfree(ab8500_gpio);
+
+        return 0;
+}
+
+static struct platform_driver ab8500_gpio_driver = {
+        .driver = {
+                .name = "ab8500-gpio",
+                .owner = THIS_MODULE,
+        },
+        .probe = ab8500_gpio_probe,
+        .remove = __devexit_p(ab8500_gpio_remove),
+};
+
+static int __init ab8500_gpio_init(void)
+{
+        return platform_driver_register(&ab8500_gpio_driver);
+}
+arch_initcall(ab8500_gpio_init);
+
+static void __exit ab8500_gpio_exit(void)
+{
+        platform_driver_unregister(&ab8500_gpio_driver);
+}
+module_exit(ab8500_gpio_exit);
+
+MODULE_AUTHOR("BIBEK BASU <bibek.basu@stericsson.com>");
+MODULE_DESCRIPTION("Driver allows to use AB8500 unused pins\
+                        to be used as GPIO");
+MODULE_ALIAS("AB8500 GPIO driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/hwmon/gpio-fan.c b/drivers/hwmon/gpio-fan.c
index f141a1de519c..89aa9fb743af 100644
--- a/drivers/hwmon/gpio-fan.c
+++ b/drivers/hwmon/gpio-fan.c
@@ -116,7 +116,7 @@ static int fan_alarm_init(struct gpio_fan_data *fan_data,
                 return 0;
 
         INIT_WORK(&fan_data->alarm_work, fan_alarm_notify);
-        set_irq_type(alarm_irq, IRQ_TYPE_EDGE_BOTH);
+        irq_set_irq_type(alarm_irq, IRQ_TYPE_EDGE_BOTH);
         err = request_irq(alarm_irq, fan_alarm_irq_handler, IRQF_SHARED,
                           "GPIO fan alarm", fan_data);
         if (err)
diff --git a/drivers/input/keyboard/lm8323.c b/drivers/input/keyboard/lm8323.c
index b732870ecc89..71f744a8e686 100644
--- a/drivers/input/keyboard/lm8323.c
+++ b/drivers/input/keyboard/lm8323.c
@@ -809,7 +809,7 @@ static int lm8323_suspend(struct device *dev)
         struct lm8323_chip *lm = i2c_get_clientdata(client);
         int i;
 
-        set_irq_wake(client->irq, 0);
+        irq_set_irq_wake(client->irq, 0);
         disable_irq(client->irq);
 
         mutex_lock(&lm->lock);
@@ -838,7 +838,7 @@ static int lm8323_resume(struct device *dev)
                         led_classdev_resume(&lm->pwm[i].cdev);
 
         enable_irq(client->irq);
-        set_irq_wake(client->irq, 1);
+        irq_set_irq_wake(client->irq, 1);
 
         return 0;
 }
diff --git a/drivers/input/serio/ams_delta_serio.c b/drivers/input/serio/ams_delta_serio.c
index ebe955325677..4b2a42f9f0bb 100644
--- a/drivers/input/serio/ams_delta_serio.c
+++ b/drivers/input/serio/ams_delta_serio.c
@@ -149,7 +149,7 @@ static int __init ams_delta_serio_init(void)
          * at FIQ level, switch back from edge to simple interrupt handler
          * to avoid bad interaction.
          */
-        set_irq_handler(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
+        irq_set_handler(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
                         handle_simple_irq);
 
         serio_register_port(ams_delta_serio);
diff --git a/drivers/input/touchscreen/mainstone-wm97xx.c b/drivers/input/touchscreen/mainstone-wm97xx.c
index b6b8b1c7ecea..3242e7076258 100644
--- a/drivers/input/touchscreen/mainstone-wm97xx.c
+++ b/drivers/input/touchscreen/mainstone-wm97xx.c
@@ -219,7 +219,7 @@ static int wm97xx_acc_startup(struct wm97xx *wm)
                 }
 
                 wm->pen_irq = gpio_to_irq(irq);
-                set_irq_type(wm->pen_irq, IRQ_TYPE_EDGE_BOTH);
+                irq_set_irq_type(wm->pen_irq, IRQ_TYPE_EDGE_BOTH);
         } else /* pen irq not supported */
                 pen_int = 0;
 
diff --git a/drivers/input/touchscreen/zylonite-wm97xx.c b/drivers/input/touchscreen/zylonite-wm97xx.c
index 048849867643..5b0f15ec874a 100644
--- a/drivers/input/touchscreen/zylonite-wm97xx.c
+++ b/drivers/input/touchscreen/zylonite-wm97xx.c
@@ -193,7 +193,7 @@ static int zylonite_wm97xx_probe(struct platform_device *pdev)
                 gpio_touch_irq = mfp_to_gpio(MFP_PIN_GPIO26);
 
         wm->pen_irq = IRQ_GPIO(gpio_touch_irq);
-        set_irq_type(IRQ_GPIO(gpio_touch_irq), IRQ_TYPE_EDGE_BOTH);
+        irq_set_irq_type(IRQ_GPIO(gpio_touch_irq), IRQ_TYPE_EDGE_BOTH);
 
         wm97xx_config_gpio(wm, WM97XX_GPIO_13, WM97XX_GPIO_IN,
                            WM97XX_GPIO_POL_HIGH,
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 06ecea751a39..8b66e04c2ea6 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1777,12 +1777,6 @@ int md_integrity_register(mddev_t *mddev)
                         continue;
                 if (rdev->raid_disk < 0)
                         continue;
-                /*
-                 * If at least one rdev is not integrity capable, we can not
-                 * enable data integrity for the md device.
-                 */
-                if (!bdev_get_integrity(rdev->bdev))
-                        return -EINVAL;
                 if (!reference) {
                         /* Use the first rdev as the reference */
                         reference = rdev;
@@ -1793,6 +1787,8 @@ int md_integrity_register(mddev_t *mddev)
                                 rdev->bdev->bd_disk) < 0)
                         return -EINVAL;
         }
+        if (!reference || !bdev_get_integrity(reference->bdev))
+                return 0;
         /*
          * All component devices are integrity capable and have matching
          * profiles, register the common profile for the md device.
diff --git a/drivers/memstick/host/r592.c b/drivers/memstick/host/r592.c
index 767406c95291..700d420a59ac 100644
--- a/drivers/memstick/host/r592.c
+++ b/drivers/memstick/host/r592.c
@@ -23,7 +23,7 @@
 #include <linux/swab.h>
 #include "r592.h"
 
-static int enable_dma = 1;
+static int r592_enable_dma = 1;
 static int debug;
 
 static const char *tpc_names[] = {
@@ -267,7 +267,7 @@ static void r592_stop_dma(struct r592_device *dev, int error)
 /* Test if hardware supports DMA */
 static void r592_check_dma(struct r592_device *dev)
 {
-        dev->dma_capable = enable_dma &&
+        dev->dma_capable = r592_enable_dma &&
                 (r592_read_reg(dev, R592_FIFO_DMA_SETTINGS) &
                         R592_FIFO_DMA_SETTINGS_CAP);
 }
@@ -898,7 +898,7 @@ static void __exit r592_module_exit(void)
 module_init(r592_module_init);
 module_exit(r592_module_exit);
 
-module_param(enable_dma, bool, S_IRUGO);
+module_param_named(enable_dma, r592_enable_dma, bool, S_IRUGO);
 MODULE_PARM_DESC(enable_dma, "Enable usage of the DMA (default)");
 module_param(debug, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug level (0-3)");
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index e986f91fff9c..e2fea580585a 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -60,15 +60,6 @@ config MFD_ASIC3
           This driver supports the ASIC3 multifunction chip found on many
           PDAs (mainly iPAQ and HTC based ones)
 
-config MFD_SH_MOBILE_SDHI
-        bool "Support for SuperH Mobile SDHI"
-        depends on SUPERH || ARCH_SHMOBILE
-        select MFD_CORE
-        select TMIO_MMC_DMA
-         ---help---
-          This driver supports the SDHI hardware block found in many
-          SuperH Mobile SoCs.
-
 config MFD_DAVINCI_VOICECODEC
         tristate
         select MFD_CORE
@@ -266,11 +257,6 @@ config MFD_TMIO
         bool
         default n
 
-config TMIO_MMC_DMA
-        bool
-        select DMA_ENGINE
-        select DMADEVICES
-
 config MFD_T7L66XB
         bool "Support Toshiba T7L66XB"
         depends on ARM && HAVE_CLK
@@ -592,7 +578,7 @@ config AB3550_CORE
 config MFD_CS5535
         tristate "Support for CS5535 and CS5536 southbridge core functions"
         select MFD_CORE
-        depends on PCI
+        depends on PCI && X86
         ---help---
           This is the core driver for CS5535/CS5536 MFD functions.  This is
           necessary for using the board's GPIO and MFGPT functionality.
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index ef489f253402..419caa9d7dcf 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -6,7 +6,6 @@
 obj-$(CONFIG_MFD_88PM860X)      += 88pm860x.o
 obj-$(CONFIG_MFD_SM501)         += sm501.o
 obj-$(CONFIG_MFD_ASIC3)         += asic3.o tmio_core.o
-obj-$(CONFIG_MFD_SH_MOBILE_SDHI)                += sh_mobile_sdhi.o
 
 obj-$(CONFIG_HTC_EGPIO)         += htc-egpio.o
 obj-$(CONFIG_HTC_PASIC3)        += htc-pasic3.o
diff --git a/drivers/mfd/ab8500-core.c b/drivers/mfd/ab8500-core.c
index 62e33e2258d4..67d01c938284 100644
--- a/drivers/mfd/ab8500-core.c
+++ b/drivers/mfd/ab8500-core.c
@@ -362,6 +362,15 @@ static void ab8500_irq_remove(struct ab8500 *ab8500)
         }
 }
 
+static struct resource ab8500_gpio_resources[] = {
+        {
+                .name   = "GPIO_INT6",
+                .start  = AB8500_INT_GPIO6R,
+                .end    = AB8500_INT_GPIO41F,
+                .flags  = IORESOURCE_IRQ,
+        }
+};
+
 static struct resource ab8500_gpadc_resources[] = {
         {
                 .name   = "HW_CONV_END",
@@ -596,6 +605,11 @@ static struct mfd_cell ab8500_devs[] = {
                 .name = "ab8500-regulator",
         },
         {
+                .name = "ab8500-gpio",
+                .num_resources = ARRAY_SIZE(ab8500_gpio_resources),
+                .resources = ab8500_gpio_resources,
+        },
+        {
                 .name = "ab8500-gpadc",
                 .num_resources = ARRAY_SIZE(ab8500_gpadc_resources),
                 .resources = ab8500_gpadc_resources,
diff --git a/drivers/mfd/ab8500-i2c.c b/drivers/mfd/ab8500-i2c.c
index 6820327adf4a..821e6b86afd2 100644
--- a/drivers/mfd/ab8500-i2c.c
+++ b/drivers/mfd/ab8500-i2c.c
@@ -97,7 +97,7 @@ static void __exit ab8500_i2c_exit(void)
 {
         platform_driver_unregister(&ab8500_i2c_driver);
 }
-subsys_initcall(ab8500_i2c_init);
+arch_initcall(ab8500_i2c_init);
 module_exit(ab8500_i2c_exit);
 
 MODULE_AUTHOR("Mattias WALLIN <mattias.wallin@stericsson.com");
diff --git a/drivers/misc/sgi-gru/grufile.c b/drivers/misc/sgi-gru/grufile.c
index 28852dfa310d..20e4e9395b61 100644
--- a/drivers/misc/sgi-gru/grufile.c
+++ b/drivers/misc/sgi-gru/grufile.c
@@ -373,7 +373,7 @@ static int gru_chiplet_setup_tlb_irq(int chiplet, char *irq_name,
 
         if (gru_irq_count[chiplet] == 0) {
                 gru_chip[chiplet].name = irq_name;
-                ret = set_irq_chip(irq, &gru_chip[chiplet]);
+                ret = irq_set_chip(irq, &gru_chip[chiplet]);
                 if (ret) {
                         printk(KERN_ERR "%s: set_irq_chip failed, errno=%d\n",
                                GRU_DRIVER_ID_STR, -ret);
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 5ec8eddfcf6e..f5cedeccad42 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -1875,7 +1875,7 @@ static int mmc_test_seq_perf(struct mmc_test_card *test, int write,
                              unsigned int tot_sz, int max_scatter)
 {
         unsigned int dev_addr, i, cnt, sz, ssz;
-        struct timespec ts1, ts2, ts;
+        struct timespec ts1, ts2;
         int ret;
 
         sz = test->area.max_tfr;
@@ -1912,7 +1912,6 @@ static int mmc_test_seq_perf(struct mmc_test_card *test, int write,
         }
         getnstimeofday(&ts2);
 
-        ts = timespec_sub(ts2, ts1);
         mmc_test_print_avg_rate(test, sz, cnt, &ts1, &ts2);
 
         return 0;
diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c
index 797cdb5887fd..76af349c14b4 100644
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -9,6 +9,7 @@
  * your option) any later version.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/scatterlist.h>
 
@@ -252,6 +253,7 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         struct mmc_command cmd;
         struct mmc_data data;
         struct scatterlist sg;
+        void *data_buf;
 
         BUG_ON(!card);
         BUG_ON(!card->host);
@@ -263,6 +265,13 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         if (err)
                 return err;
 
+        /* dma onto stack is unsafe/nonportable, but callers to this
+         * routine normally provide temporary on-stack buffers ...
+         */
+        data_buf = kmalloc(sizeof(card->raw_scr), GFP_KERNEL);
+        if (data_buf == NULL)
+                return -ENOMEM;
+
         memset(&mrq, 0, sizeof(struct mmc_request));
         memset(&cmd, 0, sizeof(struct mmc_command));
         memset(&data, 0, sizeof(struct mmc_data));
@@ -280,12 +289,15 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
         data.sg = &sg;
         data.sg_len = 1;
 
-        sg_init_one(&sg, scr, 8);
+        sg_init_one(&sg, data_buf, 8);
 
         mmc_set_data_timeout(&data, card);
 
         mmc_wait_for_req(card->host, &mrq);
 
+        memcpy(scr, data_buf, sizeof(card->raw_scr));
+        kfree(data_buf);
+
         if (cmd.error)
                 return cmd.error;
         if (data.error)
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 1a21c6427a19..94df40531c38 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -439,13 +439,25 @@ config MMC_SDRICOH_CS
           To compile this driver as a module, choose M here: the
           module will be called sdricoh_cs.
 
+config MMC_TMIO_CORE
+        tristate
+
 config MMC_TMIO
         tristate "Toshiba Mobile IO Controller (TMIO) MMC/SD function support"
-        depends on MFD_TMIO || MFD_ASIC3 || MFD_SH_MOBILE_SDHI
+        depends on MFD_TMIO || MFD_ASIC3
+        select MMC_TMIO_CORE
         help
           This provides support for the SD/MMC cell found in TC6393XB,
           T7L66XB and also HTC ASIC3
 
+config MMC_SDHI
+        tristate "SH-Mobile SDHI SD/SDIO controller support"
+        depends on SUPERH || ARCH_SHMOBILE
+        select MMC_TMIO_CORE
+        help
+          This provides support for the SDHI SD/SDIO controller found in
+          SuperH and ARM SH-Mobile SoCs
+
 config MMC_CB710
         tristate "ENE CB710 MMC/SD Interface support"
         depends on PCI
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index 30aa6867745f..4f1df0aae574 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -29,7 +29,13 @@ endif
 obj-$(CONFIG_MMC_S3C)           += s3cmci.o
 obj-$(CONFIG_MMC_SDRICOH_CS)    += sdricoh_cs.o
 obj-$(CONFIG_MMC_TMIO)          += tmio_mmc.o
-obj-$(CONFIG_MMC_CB710) += cb710-mmc.o
+obj-$(CONFIG_MMC_TMIO_CORE)     += tmio_mmc_core.o
+tmio_mmc_core-y                 := tmio_mmc_pio.o
+ifneq ($(CONFIG_MMC_SDHI),n)
+tmio_mmc_core-y                 += tmio_mmc_dma.o
+endif
+obj-$(CONFIG_MMC_SDHI)          += sh_mobile_sdhi.o
+obj-$(CONFIG_MMC_CB710)         += cb710-mmc.o
 obj-$(CONFIG_MMC_VIA_SDMMC)     += via-sdmmc.o
 obj-$(CONFIG_SDH_BFIN)          += bfin_sdh.o
 obj-$(CONFIG_MMC_DW)            += dw_mmc.o
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 5a614069cb00..87e1f57ec9ba 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -316,7 +316,7 @@ static void dw_mci_idmac_stop_dma(struct dw_mci *host)
 
         /* Stop the IDMAC running */
         temp = mci_readl(host, BMOD);
-        temp &= ~SDMMC_IDMAC_ENABLE;
+        temp &= ~(SDMMC_IDMAC_ENABLE | SDMMC_IDMAC_FB);
         mci_writel(host, BMOD, temp);
 }
 
@@ -385,7 +385,7 @@ static void dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
 
         /* Enable the IDMAC */
         temp = mci_readl(host, BMOD);
-        temp |= SDMMC_IDMAC_ENABLE;
+        temp |= SDMMC_IDMAC_ENABLE | SDMMC_IDMAC_FB;
         mci_writel(host, BMOD, temp);
 
         /* Start it running */
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 5bbb87d10251..b4a7e4fba90f 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -68,6 +68,12 @@ static struct variant_data variant_arm = {
         .datalength_bits        = 16,
 };
 
+static struct variant_data variant_arm_extended_fifo = {
+        .fifosize               = 128 * 4,
+        .fifohalfsize           = 64 * 4,
+        .datalength_bits        = 16,
+};
+
 static struct variant_data variant_u300 = {
         .fifosize               = 16 * 4,
         .fifohalfsize           = 8 * 4,
@@ -1277,10 +1283,15 @@ static int mmci_resume(struct amba_device *dev)
 static struct amba_id mmci_ids[] = {
         {
                 .id     = 0x00041180,
-                .mask   = 0x000fffff,
+                .mask   = 0xff0fffff,
                 .data   = &variant_arm,
         },
         {
+                .id     = 0x01041180,
+                .mask   = 0xff0fffff,
+                .data   = &variant_arm_extended_fifo,
+        },
+        {
                 .id     = 0x00041181,
                 .mask   = 0x000fffff,
                 .data   = &variant_arm,
diff --git a/drivers/mmc/host/of_mmc_spi.c b/drivers/mmc/host/of_mmc_spi.c
index 5530def54e5b..e2aecb7f1d5c 100644
--- a/drivers/mmc/host/of_mmc_spi.c
+++ b/drivers/mmc/host/of_mmc_spi.c
@@ -15,9 +15,11 @@
 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/slab.h>
+#include <linux/irq.h>
 #include <linux/gpio.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
+#include <linux/of_irq.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/mmc_spi.h>
 #include <linux/mmc/core.h>
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index 3b5248567973..a19967d0bfc4 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -16,14 +16,40 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/gpio.h>
+#include <linux/slab.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/sdhci-pltfm.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/sdio.h>
 #include <mach/hardware.h>
 #include <mach/esdhc.h>
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
 
+/* VENDOR SPEC register */
+#define SDHCI_VENDOR_SPEC               0xC0
+#define  SDHCI_VENDOR_SPEC_SDIO_QUIRK   0x00000002
+
+#define ESDHC_FLAG_GPIO_FOR_CD_WP       (1 << 0)
+/*
+ * The CMDTYPE of the CMD register (offset 0xE) should be set to
+ * "11" when the STOP CMD12 is issued on imx53 to abort one
+ * open ended multi-blk IO. Otherwise the TC INT wouldn't
+ * be generated.
+ * In exact block transfer, the controller doesn't complete the
+ * operations automatically as required at the end of the
+ * transfer and remains on hold if the abort command is not sent.
+ * As a result, the TC flag is not asserted and SW  received timeout
+ * exeception. Bit1 of Vendor Spec registor is used to fix it.
+ */
+#define ESDHC_FLAG_MULTIBLK_NO_INT      (1 << 1)
+
+struct pltfm_imx_data {
+        int flags;
+        u32 scratchpad;
+};
+
 static inline void esdhc_clrset_le(struct sdhci_host *host, u32 mask, u32 val, int reg)
 {
         void __iomem *base = host->ioaddr + (reg & ~0x3);
@@ -34,10 +60,14 @@ static inline void esdhc_clrset_le(struct sdhci_host *host, u32 mask, u32 val, i
 
 static u32 esdhc_readl_le(struct sdhci_host *host, int reg)
 {
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct pltfm_imx_data *imx_data = pltfm_host->priv;
+
         /* fake CARD_PRESENT flag on mx25/35 */
         u32 val = readl(host->ioaddr + reg);
 
-        if (unlikely(reg == SDHCI_PRESENT_STATE)) {
+        if (unlikely((reg == SDHCI_PRESENT_STATE)
+                        && (imx_data->flags & ESDHC_FLAG_GPIO_FOR_CD_WP))) {
                 struct esdhc_platform_data *boarddata =
                                 host->mmc->parent->platform_data;
 
@@ -55,13 +85,26 @@ static u32 esdhc_readl_le(struct sdhci_host *host, int reg)
 
 static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
 {
-        if (unlikely(reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE))
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct pltfm_imx_data *imx_data = pltfm_host->priv;
+
+        if (unlikely((reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)
+                        && (imx_data->flags & ESDHC_FLAG_GPIO_FOR_CD_WP)))
                 /*
                  * these interrupts won't work with a custom card_detect gpio
                  * (only applied to mx25/35)
                  */
                 val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
 
+        if (unlikely((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT)
+                                && (reg == SDHCI_INT_STATUS)
+                                && (val & SDHCI_INT_DATA_END))) {
+                        u32 v;
+                        v = readl(host->ioaddr + SDHCI_VENDOR_SPEC);
+                        v &= ~SDHCI_VENDOR_SPEC_SDIO_QUIRK;
+                        writel(v, host->ioaddr + SDHCI_VENDOR_SPEC);
+        }
+
         writel(val, host->ioaddr + reg);
 }
 
@@ -76,6 +119,7 @@ static u16 esdhc_readw_le(struct sdhci_host *host, int reg)
 static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct pltfm_imx_data *imx_data = pltfm_host->priv;
 
         switch (reg) {
         case SDHCI_TRANSFER_MODE:
@@ -83,10 +127,22 @@ static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
                  * Postpone this write, we must do it together with a
                  * command write that is down below.
                  */
-                pltfm_host->scratchpad = val;
+                if ((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT)
+                                && (host->cmd->opcode == SD_IO_RW_EXTENDED)
+                                && (host->cmd->data->blocks > 1)
+                                && (host->cmd->data->flags & MMC_DATA_READ)) {
+                        u32 v;
+                        v = readl(host->ioaddr + SDHCI_VENDOR_SPEC);
+                        v |= SDHCI_VENDOR_SPEC_SDIO_QUIRK;
+                        writel(v, host->ioaddr + SDHCI_VENDOR_SPEC);
+                }
+                imx_data->scratchpad = val;
                 return;
         case SDHCI_COMMAND:
-                writel(val << 16 | pltfm_host->scratchpad,
+                if ((host->cmd->opcode == MMC_STOP_TRANSMISSION)
+                        && (imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT))
+                        val |= SDHCI_CMD_ABORTCMD;
+                writel(val << 16 | imx_data->scratchpad,
                         host->ioaddr + SDHCI_TRANSFER_MODE);
                 return;
         case SDHCI_BLOCK_SIZE:
@@ -146,7 +202,9 @@ static unsigned int esdhc_pltfm_get_ro(struct sdhci_host *host)
 }
 
 static struct sdhci_ops sdhci_esdhc_ops = {
+        .read_l = esdhc_readl_le,
         .read_w = esdhc_readw_le,
+        .write_l = esdhc_writel_le,
         .write_w = esdhc_writew_le,
         .write_b = esdhc_writeb_le,
         .set_clock = esdhc_set_clock,
@@ -168,6 +226,7 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
         struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
         struct clk *clk;
         int err;
+        struct pltfm_imx_data *imx_data;
 
         clk = clk_get(mmc_dev(host->mmc), NULL);
         if (IS_ERR(clk)) {
@@ -177,7 +236,15 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
         clk_enable(clk);
         pltfm_host->clk = clk;
 
-        if (cpu_is_mx35() || cpu_is_mx51())
+        imx_data = kzalloc(sizeof(struct pltfm_imx_data), GFP_KERNEL);
+        if (!imx_data) {
+                clk_disable(pltfm_host->clk);
+                clk_put(pltfm_host->clk);
+                return -ENOMEM;
+        }
+        pltfm_host->priv = imx_data;
+
+        if (!cpu_is_mx25())
                 host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
 
         if (cpu_is_mx25() || cpu_is_mx35()) {
@@ -187,6 +254,9 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
                 sdhci_esdhc_ops.get_ro = esdhc_pltfm_get_ro;
         }
 
+        if (!(cpu_is_mx25() || cpu_is_mx35() || cpu_is_mx51()))
+                imx_data->flags |= ESDHC_FLAG_MULTIBLK_NO_INT;
+
         if (boarddata) {
                 err = gpio_request_one(boarddata->wp_gpio, GPIOF_IN, "ESDHC_WP");
                 if (err) {
@@ -214,8 +284,7 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
                         goto no_card_detect_irq;
                 }
 
-                sdhci_esdhc_ops.write_l = esdhc_writel_le;
-                sdhci_esdhc_ops.read_l = esdhc_readl_le;
+                imx_data->flags |= ESDHC_FLAG_GPIO_FOR_CD_WP;
                 /* Now we have a working card_detect again */
                 host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION;
         }
@@ -227,6 +296,7 @@ static int esdhc_pltfm_init(struct sdhci_host *host, struct sdhci_pltfm_data *pd
  no_card_detect_pin:
         boarddata->cd_gpio = err;
  not_supported:
+        kfree(imx_data);
         return 0;
 }
 
@@ -234,6 +304,7 @@ static void esdhc_pltfm_exit(struct sdhci_host *host)
 {
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct esdhc_platform_data *boarddata = host->mmc->parent->platform_data;
+        struct pltfm_imx_data *imx_data = pltfm_host->priv;
 
         if (boarddata && gpio_is_valid(boarddata->wp_gpio))
                 gpio_free(boarddata->wp_gpio);
@@ -247,6 +318,7 @@ static void esdhc_pltfm_exit(struct sdhci_host *host)
 
         clk_disable(pltfm_host->clk);
         clk_put(pltfm_host->clk);
+        kfree(imx_data);
 }
 
 struct sdhci_pltfm_data sdhci_esdhc_imx_pdata = {
diff --git a/drivers/mmc/host/sdhci-esdhc.h b/drivers/mmc/host/sdhci-esdhc.h
index c55aae828aac..c3b08f111942 100644
--- a/drivers/mmc/host/sdhci-esdhc.h
+++ b/drivers/mmc/host/sdhci-esdhc.h
@@ -23,8 +23,7 @@
                                 SDHCI_QUIRK_NONSTANDARD_CLOCK | \
                                 SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK | \
                                 SDHCI_QUIRK_PIO_NEEDS_DELAY | \
-                                SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET | \
-                                SDHCI_QUIRK_NO_CARD_NO_RESET)
+                                SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET)
 
 #define ESDHC_SYSTEM_CONTROL    0x2c
 #define ESDHC_CLOCK_MASK        0x0000fff0
diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c
index 08161f690ae8..ba40d6d035c7 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -74,7 +74,8 @@ static unsigned int esdhc_of_get_min_clock(struct sdhci_host *host)
 
 struct sdhci_of_data sdhci_esdhc = {
         /* card detection could be handled via GPIO */
-        .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_CARD_DETECTION,
+        .quirks = ESDHC_DEFAULT_QUIRKS | SDHCI_QUIRK_BROKEN_CARD_DETECTION
+                | SDHCI_QUIRK_NO_CARD_NO_RESET,
         .ops = {
                 .read_l = sdhci_be32bs_readl,
                 .read_w = esdhc_readw,
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 2f8d46854acd..a136be706347 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -1016,16 +1016,14 @@ static int __devinit sdhci_pci_probe(struct pci_dev *pdev,
         struct sdhci_pci_chip *chip;
         struct sdhci_pci_slot *slot;
 
-        u8 slots, rev, first_bar;
+        u8 slots, first_bar;
         int ret, i;
 
         BUG_ON(pdev == NULL);
         BUG_ON(ent == NULL);
 
-        pci_read_config_byte(pdev, PCI_CLASS_REVISION, &rev);
-
         dev_info(&pdev->dev, "SDHCI controller found [%04x:%04x] (rev %x)\n",
-                 (int)pdev->vendor, (int)pdev->device, (int)rev);
+                 (int)pdev->vendor, (int)pdev->device, (int)pdev->revision);
 
         ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &slots);
         if (ret)
diff --git a/drivers/mmc/host/sdhci-pltfm.h b/drivers/mmc/host/sdhci-pltfm.h
index ea2e44d9be5e..2b37016ad0ac 100644
--- a/drivers/mmc/host/sdhci-pltfm.h
+++ b/drivers/mmc/host/sdhci-pltfm.h
@@ -17,7 +17,7 @@
 
 struct sdhci_pltfm_host {
         struct clk *clk;
-        u32 scratchpad; /* to handle quirks across io-accessor calls */
+        void *priv; /* to handle quirks across io-accessor calls */
 };
 
 extern struct sdhci_pltfm_data sdhci_cns3xxx_pdata;
diff --git a/drivers/mmc/host/sdhci-spear.c b/drivers/mmc/host/sdhci-spear.c
index d70c54c7b70a..60a4c97d3d18 100644
--- a/drivers/mmc/host/sdhci-spear.c
+++ b/drivers/mmc/host/sdhci-spear.c
@@ -50,7 +50,7 @@ static irqreturn_t sdhci_gpio_irq(int irq, void *dev_id)
         /* val == 1 -> card removed, val == 0 -> card inserted */
         /* if card removed - set irq for low level, else vice versa */
         gpio_irq_type = val ? IRQF_TRIGGER_LOW : IRQF_TRIGGER_HIGH;
-        set_irq_type(irq, gpio_irq_type);
+        irq_set_irq_type(irq, gpio_irq_type);
 
         if (sdhci->data->card_power_gpio >= 0) {
                 if (!sdhci->data->power_always_enb) {
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 6e0969e40650..25e8bde600d1 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -45,6 +45,7 @@
 #define  SDHCI_CMD_CRC          0x08
 #define  SDHCI_CMD_INDEX        0x10
 #define  SDHCI_CMD_DATA         0x20
+#define  SDHCI_CMD_ABORTCMD     0xC0
 
 #define  SDHCI_CMD_RESP_NONE    0x00
 #define  SDHCI_CMD_RESP_LONG    0x01
diff --git a/drivers/mfd/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index 53a63024bf11..cc701236d16f 100644
--- a/drivers/mfd/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -23,51 +23,30 @@
 #include <linux/slab.h>
 #include <linux/platform_device.h>
 #include <linux/mmc/host.h>
-#include <linux/mfd/core.h>
+#include <linux/mmc/sh_mobile_sdhi.h>
 #include <linux/mfd/tmio.h>
-#include <linux/mfd/sh_mobile_sdhi.h>
 #include <linux/sh_dma.h>
 
+#include "tmio_mmc.h"
+
 struct sh_mobile_sdhi {
         struct clk *clk;
         struct tmio_mmc_data mmc_data;
-        struct mfd_cell cell_mmc;
         struct sh_dmae_slave param_tx;
         struct sh_dmae_slave param_rx;
         struct tmio_mmc_dma dma_priv;
 };
 
-static struct resource sh_mobile_sdhi_resources[] = {
-        {
-                .start = 0x000,
-                .end   = 0x1ff,
-                .flags = IORESOURCE_MEM,
-        },
-        {
-                .start = 0,
-                .end   = 0,
-                .flags = IORESOURCE_IRQ,
-        },
-};
-
-static struct mfd_cell sh_mobile_sdhi_cell = {
-        .name          = "tmio-mmc",
-        .num_resources = ARRAY_SIZE(sh_mobile_sdhi_resources),
-        .resources     = sh_mobile_sdhi_resources,
-};
-
-static void sh_mobile_sdhi_set_pwr(struct platform_device *tmio, int state)
+static void sh_mobile_sdhi_set_pwr(struct platform_device *pdev, int state)
 {
-        struct platform_device *pdev = to_platform_device(tmio->dev.parent);
         struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
 
         if (p && p->set_pwr)
                 p->set_pwr(pdev, state);
 }
 
-static int sh_mobile_sdhi_get_cd(struct platform_device *tmio)
+static int sh_mobile_sdhi_get_cd(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(tmio->dev.parent);
         struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
 
         if (p && p->get_cd)
@@ -81,20 +60,9 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
         struct sh_mobile_sdhi *priv;
         struct tmio_mmc_data *mmc_data;
         struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
-        struct resource *mem;
+        struct tmio_mmc_host *host;
         char clk_name[8];
-        int ret, irq;
-
-        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!mem)
-                dev_err(&pdev->dev, "missing MEM resource\n");
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0)
-                dev_err(&pdev->dev, "missing IRQ resource\n");
-
-        if (!mem || (irq < 0))
-                return -EINVAL;
+        int ret;
 
         priv = kzalloc(sizeof(struct sh_mobile_sdhi), GFP_KERNEL);
         if (priv == NULL) {
@@ -109,8 +77,7 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
         if (IS_ERR(priv->clk)) {
                 dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
                 ret = PTR_ERR(priv->clk);
-                kfree(priv);
-                return ret;
+                goto eclkget;
         }
 
         clk_enable(priv->clk);
@@ -123,6 +90,15 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
                 mmc_data->flags = p->tmio_flags;
                 mmc_data->ocr_mask = p->tmio_ocr_mask;
                 mmc_data->capabilities |= p->tmio_caps;
+
+                if (p->dma_slave_tx >= 0 && p->dma_slave_rx >= 0) {
+                        priv->param_tx.slave_id = p->dma_slave_tx;
+                        priv->param_rx.slave_id = p->dma_slave_rx;
+                        priv->dma_priv.chan_priv_tx = &priv->param_tx;
+                        priv->dma_priv.chan_priv_rx = &priv->param_rx;
+                        priv->dma_priv.alignment_shift = 1; /* 2-byte alignment */
+                        mmc_data->dma = &priv->dma_priv;
+                }
         }
 
         /*
@@ -136,36 +112,30 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
          */
         mmc_data->flags |= TMIO_MMC_SDIO_IRQ;
 
-        if (p && p->dma_slave_tx >= 0 && p->dma_slave_rx >= 0) {
-                priv->param_tx.slave_id = p->dma_slave_tx;
-                priv->param_rx.slave_id = p->dma_slave_rx;
-                priv->dma_priv.chan_priv_tx = &priv->param_tx;
-                priv->dma_priv.chan_priv_rx = &priv->param_rx;
-                priv->dma_priv.alignment_shift = 1; /* 2-byte alignment */
-                mmc_data->dma = &priv->dma_priv;
-        }
+        ret = tmio_mmc_host_probe(&host, pdev, mmc_data);
+        if (ret < 0)
+                goto eprobe;
 
-        memcpy(&priv->cell_mmc, &sh_mobile_sdhi_cell, sizeof(priv->cell_mmc));
-        priv->cell_mmc.mfd_data = mmc_data;
+        pr_info("%s at 0x%08lx irq %d\n", mmc_hostname(host->mmc),
+                (unsigned long)host->ctl, host->irq);
 
-        platform_set_drvdata(pdev, priv);
-
-        ret = mfd_add_devices(&pdev->dev, pdev->id,
-                              &priv->cell_mmc, 1, mem, irq);
-        if (ret) {
-                clk_disable(priv->clk);
-                clk_put(priv->clk);
-                kfree(priv);
-        }
+        return ret;
 
+eprobe:
+        clk_disable(priv->clk);
+        clk_put(priv->clk);
+eclkget:
+        kfree(priv);
         return ret;
 }
 
 static int sh_mobile_sdhi_remove(struct platform_device *pdev)
 {
-        struct sh_mobile_sdhi *priv = platform_get_drvdata(pdev);
+        struct mmc_host *mmc = platform_get_drvdata(pdev);
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
 
-        mfd_remove_devices(&pdev->dev);
+        tmio_mmc_host_remove(host);
         clk_disable(priv->clk);
         clk_put(priv->clk);
         kfree(priv);
@@ -198,3 +168,4 @@ module_exit(sh_mobile_sdhi_exit);
 MODULE_DESCRIPTION("SuperH Mobile SDHI driver");
 MODULE_AUTHOR("Magnus Damm");
 MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:sh_mobile_sdhi");
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index ab1adeabdd22..79c568461d59 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -1,8 +1,8 @@
 /*
- *  linux/drivers/mmc/tmio_mmc.c
+ * linux/drivers/mmc/host/tmio_mmc.c
  *
- *  Copyright (C) 2004 Ian Molton
- *  Copyright (C) 2007 Ian Molton
+ * Copyright (C) 2007 Ian Molton
+ * Copyright (C) 2004 Ian Molton
  *
  * 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
@@ -11,1182 +11,17 @@
  * Driver for the MMC / SD / SDIO cell found in:
  *
  * TC6393XB TC6391XB TC6387XB T7L66XB ASIC3
- *
- * This driver draws mainly on scattered spec sheets, Reverse engineering
- * of the toshiba e800  SD driver and some parts of the 2.4 ASIC3 driver (4 bit
- * support). (Further 4 bit support from a later datasheet).
- *
- * TODO:
- *   Investigate using a workqueue for PIO transfers
- *   Eliminate FIXMEs
- *   SDIO support
- *   Better Power management
- *   Handle MMC errors better
- *   double buffer support
- *
  */
 
-#include <linux/delay.h>
 #include <linux/device.h>
-#include <linux/dmaengine.h>
-#include <linux/highmem.h>
-#include <linux/interrupt.h>
-#include <linux/io.h>
-#include <linux/irq.h>
 #include <linux/mfd/core.h>
 #include <linux/mfd/tmio.h>
 #include <linux/mmc/host.h>
 #include <linux/module.h>
 #include <linux/pagemap.h>
 #include <linux/scatterlist.h>
-#include <linux/workqueue.h>
-#include <linux/spinlock.h>
-
-#define CTL_SD_CMD 0x00
-#define CTL_ARG_REG 0x04
-#define CTL_STOP_INTERNAL_ACTION 0x08
-#define CTL_XFER_BLK_COUNT 0xa
-#define CTL_RESPONSE 0x0c
-#define CTL_STATUS 0x1c
-#define CTL_IRQ_MASK 0x20
-#define CTL_SD_CARD_CLK_CTL 0x24
-#define CTL_SD_XFER_LEN 0x26
-#define CTL_SD_MEM_CARD_OPT 0x28
-#define CTL_SD_ERROR_DETAIL_STATUS 0x2c
-#define CTL_SD_DATA_PORT 0x30
-#define CTL_TRANSACTION_CTL 0x34
-#define CTL_SDIO_STATUS 0x36
-#define CTL_SDIO_IRQ_MASK 0x38
-#define CTL_RESET_SD 0xe0
-#define CTL_SDIO_REGS 0x100
-#define CTL_CLK_AND_WAIT_CTL 0x138
-#define CTL_RESET_SDIO 0x1e0
-
-/* Definitions for values the CTRL_STATUS register can take. */
-#define TMIO_STAT_CMDRESPEND    0x00000001
-#define TMIO_STAT_DATAEND       0x00000004
-#define TMIO_STAT_CARD_REMOVE   0x00000008
-#define TMIO_STAT_CARD_INSERT   0x00000010
-#define TMIO_STAT_SIGSTATE      0x00000020
-#define TMIO_STAT_WRPROTECT     0x00000080
-#define TMIO_STAT_CARD_REMOVE_A 0x00000100
-#define TMIO_STAT_CARD_INSERT_A 0x00000200
-#define TMIO_STAT_SIGSTATE_A    0x00000400
-#define TMIO_STAT_CMD_IDX_ERR   0x00010000
-#define TMIO_STAT_CRCFAIL       0x00020000
-#define TMIO_STAT_STOPBIT_ERR   0x00040000
-#define TMIO_STAT_DATATIMEOUT   0x00080000
-#define TMIO_STAT_RXOVERFLOW    0x00100000
-#define TMIO_STAT_TXUNDERRUN    0x00200000
-#define TMIO_STAT_CMDTIMEOUT    0x00400000
-#define TMIO_STAT_RXRDY         0x01000000
-#define TMIO_STAT_TXRQ          0x02000000
-#define TMIO_STAT_ILL_FUNC      0x20000000
-#define TMIO_STAT_CMD_BUSY      0x40000000
-#define TMIO_STAT_ILL_ACCESS    0x80000000
-
-/* Definitions for values the CTRL_SDIO_STATUS register can take. */
-#define TMIO_SDIO_STAT_IOIRQ    0x0001
-#define TMIO_SDIO_STAT_EXPUB52  0x4000
-#define TMIO_SDIO_STAT_EXWT     0x8000
-#define TMIO_SDIO_MASK_ALL      0xc007
-
-/* Define some IRQ masks */
-/* This is the mask used at reset by the chip */
-#define TMIO_MASK_ALL           0x837f031d
-#define TMIO_MASK_READOP  (TMIO_STAT_RXRDY | TMIO_STAT_DATAEND)
-#define TMIO_MASK_WRITEOP (TMIO_STAT_TXRQ | TMIO_STAT_DATAEND)
-#define TMIO_MASK_CMD     (TMIO_STAT_CMDRESPEND | TMIO_STAT_CMDTIMEOUT | \
-                TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT)
-#define TMIO_MASK_IRQ     (TMIO_MASK_READOP | TMIO_MASK_WRITEOP | TMIO_MASK_CMD)
-
-#define enable_mmc_irqs(host, i) \
-        do { \
-                u32 mask;\
-                mask  = sd_ctrl_read32((host), CTL_IRQ_MASK); \
-                mask &= ~((i) & TMIO_MASK_IRQ); \
-                sd_ctrl_write32((host), CTL_IRQ_MASK, mask); \
-        } while (0)
-
-#define disable_mmc_irqs(host, i) \
-        do { \
-                u32 mask;\
-                mask  = sd_ctrl_read32((host), CTL_IRQ_MASK); \
-                mask |= ((i) & TMIO_MASK_IRQ); \
-                sd_ctrl_write32((host), CTL_IRQ_MASK, mask); \
-        } while (0)
-
-#define ack_mmc_irqs(host, i) \
-        do { \
-                sd_ctrl_write32((host), CTL_STATUS, ~(i)); \
-        } while (0)
-
-/* This is arbitrary, just noone needed any higher alignment yet */
-#define MAX_ALIGN 4
-
-struct tmio_mmc_host {
-        void __iomem *ctl;
-        unsigned long bus_shift;
-        struct mmc_command      *cmd;
-        struct mmc_request      *mrq;
-        struct mmc_data         *data;
-        struct mmc_host         *mmc;
-        int                     irq;
-        unsigned int            sdio_irq_enabled;
-
-        /* Callbacks for clock / power control */
-        void (*set_pwr)(struct platform_device *host, int state);
-        void (*set_clk_div)(struct platform_device *host, int state);
-
-        /* pio related stuff */
-        struct scatterlist      *sg_ptr;
-        struct scatterlist      *sg_orig;
-        unsigned int            sg_len;
-        unsigned int            sg_off;
-
-        struct platform_device *pdev;
-
-        /* DMA support */
-        struct dma_chan         *chan_rx;
-        struct dma_chan         *chan_tx;
-        struct tasklet_struct   dma_complete;
-        struct tasklet_struct   dma_issue;
-#ifdef CONFIG_TMIO_MMC_DMA
-        u8                      bounce_buf[PAGE_CACHE_SIZE] __attribute__((aligned(MAX_ALIGN)));
-        struct scatterlist      bounce_sg;
-#endif
-
-        /* Track lost interrupts */
-        struct delayed_work     delayed_reset_work;
-        spinlock_t              lock;
-        unsigned long           last_req_ts;
-};
-
-static void tmio_check_bounce_buffer(struct tmio_mmc_host *host);
-
-static u16 sd_ctrl_read16(struct tmio_mmc_host *host, int addr)
-{
-        return readw(host->ctl + (addr << host->bus_shift));
-}
-
-static void sd_ctrl_read16_rep(struct tmio_mmc_host *host, int addr,
-                u16 *buf, int count)
-{
-        readsw(host->ctl + (addr << host->bus_shift), buf, count);
-}
-
-static u32 sd_ctrl_read32(struct tmio_mmc_host *host, int addr)
-{
-        return readw(host->ctl + (addr << host->bus_shift)) |
-               readw(host->ctl + ((addr + 2) << host->bus_shift)) << 16;
-}
-
-static void sd_ctrl_write16(struct tmio_mmc_host *host, int addr, u16 val)
-{
-        writew(val, host->ctl + (addr << host->bus_shift));
-}
-
-static void sd_ctrl_write16_rep(struct tmio_mmc_host *host, int addr,
-                u16 *buf, int count)
-{
-        writesw(host->ctl + (addr << host->bus_shift), buf, count);
-}
-
-static void sd_ctrl_write32(struct tmio_mmc_host *host, int addr, u32 val)
-{
-        writew(val, host->ctl + (addr << host->bus_shift));
-        writew(val >> 16, host->ctl + ((addr + 2) << host->bus_shift));
-}
-
-static void tmio_mmc_init_sg(struct tmio_mmc_host *host, struct mmc_data *data)
-{
-        host->sg_len = data->sg_len;
-        host->sg_ptr = data->sg;
-        host->sg_orig = data->sg;
-        host->sg_off = 0;
-}
-
-static int tmio_mmc_next_sg(struct tmio_mmc_host *host)
-{
-        host->sg_ptr = sg_next(host->sg_ptr);
-        host->sg_off = 0;
-        return --host->sg_len;
-}
-
-static char *tmio_mmc_kmap_atomic(struct scatterlist *sg, unsigned long *flags)
-{
-        local_irq_save(*flags);
-        return kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
-}
-
-static void tmio_mmc_kunmap_atomic(struct scatterlist *sg, unsigned long *flags, void *virt)
-{
-        kunmap_atomic(virt - sg->offset, KM_BIO_SRC_IRQ);
-        local_irq_restore(*flags);
-}
-
-#ifdef CONFIG_MMC_DEBUG
-
-#define STATUS_TO_TEXT(a, status, i) \
-        do { \
-                if (status & TMIO_STAT_##a) { \
-                        if (i++) \
-                                printk(" | "); \
-                        printk(#a); \
-                } \
-        } while (0)
-
-void pr_debug_status(u32 status)
-{
-        int i = 0;
-        printk(KERN_DEBUG "status: %08x = ", status);
-        STATUS_TO_TEXT(CARD_REMOVE, status, i);
-        STATUS_TO_TEXT(CARD_INSERT, status, i);
-        STATUS_TO_TEXT(SIGSTATE, status, i);
-        STATUS_TO_TEXT(WRPROTECT, status, i);
-        STATUS_TO_TEXT(CARD_REMOVE_A, status, i);
-        STATUS_TO_TEXT(CARD_INSERT_A, status, i);
-        STATUS_TO_TEXT(SIGSTATE_A, status, i);
-        STATUS_TO_TEXT(CMD_IDX_ERR, status, i);
-        STATUS_TO_TEXT(STOPBIT_ERR, status, i);
-        STATUS_TO_TEXT(ILL_FUNC, status, i);
-        STATUS_TO_TEXT(CMD_BUSY, status, i);
-        STATUS_TO_TEXT(CMDRESPEND, status, i);
-        STATUS_TO_TEXT(DATAEND, status, i);
-        STATUS_TO_TEXT(CRCFAIL, status, i);
-        STATUS_TO_TEXT(DATATIMEOUT, status, i);
-        STATUS_TO_TEXT(CMDTIMEOUT, status, i);
-        STATUS_TO_TEXT(RXOVERFLOW, status, i);
-        STATUS_TO_TEXT(TXUNDERRUN, status, i);
-        STATUS_TO_TEXT(RXRDY, status, i);
-        STATUS_TO_TEXT(TXRQ, status, i);
-        STATUS_TO_TEXT(ILL_ACCESS, status, i);
-        printk("\n");
-}
-
-#else
-#define pr_debug_status(s)  do { } while (0)
-#endif
-
-static void tmio_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
-{
-        struct tmio_mmc_host *host = mmc_priv(mmc);
-
-        if (enable) {
-                host->sdio_irq_enabled = 1;
-                sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0001);
-                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK,
-                        (TMIO_SDIO_MASK_ALL & ~TMIO_SDIO_STAT_IOIRQ));
-        } else {
-                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, TMIO_SDIO_MASK_ALL);
-                sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0000);
-                host->sdio_irq_enabled = 0;
-        }
-}
-
-static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
-{
-        u32 clk = 0, clock;
-
-        if (new_clock) {
-                for (clock = host->mmc->f_min, clk = 0x80000080;
-                        new_clock >= (clock<<1); clk >>= 1)
-                        clock <<= 1;
-                clk |= 0x100;
-        }
-
-        if (host->set_clk_div)
-                host->set_clk_div(host->pdev, (clk>>22) & 1);
-
-        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, clk & 0x1ff);
-}
-
-static void tmio_mmc_clk_stop(struct tmio_mmc_host *host)
-{
-        struct tmio_mmc_data *pdata = mfd_get_data(host->pdev);
-
-        /*
-         * Testing on sh-mobile showed that SDIO IRQs are unmasked when
-         * CTL_CLK_AND_WAIT_CTL gets written, so we have to disable the
-         * device IRQ here and restore the SDIO IRQ mask before
-         * re-enabling the device IRQ.
-         */
-        if (pdata->flags & TMIO_MMC_SDIO_IRQ)
-                disable_irq(host->irq);
-        sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0000);
-        msleep(10);
-        if (pdata->flags & TMIO_MMC_SDIO_IRQ) {
-                tmio_mmc_enable_sdio_irq(host->mmc, host->sdio_irq_enabled);
-                enable_irq(host->irq);
-        }
-        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~0x0100 &
-                sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
-        msleep(10);
-}
-
-static void tmio_mmc_clk_start(struct tmio_mmc_host *host)
-{
-        struct tmio_mmc_data *pdata = mfd_get_data(host->pdev);
-
-        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, 0x0100 |
-                sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
-        msleep(10);
-        /* see comment in tmio_mmc_clk_stop above */
-        if (pdata->flags & TMIO_MMC_SDIO_IRQ)
-                disable_irq(host->irq);
-        sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0100);
-        msleep(10);
-        if (pdata->flags & TMIO_MMC_SDIO_IRQ) {
-                tmio_mmc_enable_sdio_irq(host->mmc, host->sdio_irq_enabled);
-                enable_irq(host->irq);
-        }
-}
-
-static void reset(struct tmio_mmc_host *host)
-{
-        /* FIXME - should we set stop clock reg here */
-        sd_ctrl_write16(host, CTL_RESET_SD, 0x0000);
-        sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0000);
-        msleep(10);
-        sd_ctrl_write16(host, CTL_RESET_SD, 0x0001);
-        sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0001);
-        msleep(10);
-}
-
-static void tmio_mmc_reset_work(struct work_struct *work)
-{
-        struct tmio_mmc_host *host = container_of(work, struct tmio_mmc_host,
-                                                  delayed_reset_work.work);
-        struct mmc_request *mrq;
-        unsigned long flags;
-
-        spin_lock_irqsave(&host->lock, flags);
-        mrq = host->mrq;
-
-        /* request already finished */
-        if (!mrq
-            || time_is_after_jiffies(host->last_req_ts +
-                msecs_to_jiffies(2000))) {
-                spin_unlock_irqrestore(&host->lock, flags);
-                return;
-        }
-
-        dev_warn(&host->pdev->dev,
-                "timeout waiting for hardware interrupt (CMD%u)\n",
-                mrq->cmd->opcode);
-
-        if (host->data)
-                host->data->error = -ETIMEDOUT;
-        else if (host->cmd)
-                host->cmd->error = -ETIMEDOUT;
-        else
-                mrq->cmd->error = -ETIMEDOUT;
-
-        host->cmd = NULL;
-        host->data = NULL;
-        host->mrq = NULL;
-
-        spin_unlock_irqrestore(&host->lock, flags);
-
-        reset(host);
-
-        mmc_request_done(host->mmc, mrq);
-}
-
-static void
-tmio_mmc_finish_request(struct tmio_mmc_host *host)
-{
-        struct mmc_request *mrq = host->mrq;
-
-        if (!mrq)
-                return;
-
-        host->mrq = NULL;
-        host->cmd = NULL;
-        host->data = NULL;
-
-        cancel_delayed_work(&host->delayed_reset_work);
-
-        mmc_request_done(host->mmc, mrq);
-}
-
-/* These are the bitmasks the tmio chip requires to implement the MMC response
- * types. Note that R1 and R6 are the same in this scheme. */
-#define APP_CMD        0x0040
-#define RESP_NONE      0x0300
-#define RESP_R1        0x0400
-#define RESP_R1B       0x0500
-#define RESP_R2        0x0600
-#define RESP_R3        0x0700
-#define DATA_PRESENT   0x0800
-#define TRANSFER_READ  0x1000
-#define TRANSFER_MULTI 0x2000
-#define SECURITY_CMD   0x4000
-
-static int
-tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command *cmd)
-{
-        struct mmc_data *data = host->data;
-        int c = cmd->opcode;
-
-        /* Command 12 is handled by hardware */
-        if (cmd->opcode == 12 && !cmd->arg) {
-                sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x001);
-                return 0;
-        }
-
-        switch (mmc_resp_type(cmd)) {
-        case MMC_RSP_NONE: c |= RESP_NONE; break;
-        case MMC_RSP_R1:   c |= RESP_R1;   break;
-        case MMC_RSP_R1B:  c |= RESP_R1B;  break;
-        case MMC_RSP_R2:   c |= RESP_R2;   break;
-        case MMC_RSP_R3:   c |= RESP_R3;   break;
-        default:
-                pr_debug("Unknown response type %d\n", mmc_resp_type(cmd));
-                return -EINVAL;
-        }
-
-        host->cmd = cmd;
-
-/* FIXME - this seems to be ok commented out but the spec suggest this bit
- *         should be set when issuing app commands.
- *      if(cmd->flags & MMC_FLAG_ACMD)
- *              c |= APP_CMD;
- */
-        if (data) {
-                c |= DATA_PRESENT;
-                if (data->blocks > 1) {
-                        sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x100);
-                        c |= TRANSFER_MULTI;
-                }
-                if (data->flags & MMC_DATA_READ)
-                        c |= TRANSFER_READ;
-        }
-
-        enable_mmc_irqs(host, TMIO_MASK_CMD);
-
-        /* Fire off the command */
-        sd_ctrl_write32(host, CTL_ARG_REG, cmd->arg);
-        sd_ctrl_write16(host, CTL_SD_CMD, c);
-
-        return 0;
-}
-
-/*
- * This chip always returns (at least?) as much data as you ask for.
- * I'm unsure what happens if you ask for less than a block. This should be
- * looked into to ensure that a funny length read doesnt hose the controller.
- */
-static void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
-{
-        struct mmc_data *data = host->data;
-        void *sg_virt;
-        unsigned short *buf;
-        unsigned int count;
-        unsigned long flags;
-
-        if (!data) {
-                pr_debug("Spurious PIO IRQ\n");
-                return;
-        }
-
-        sg_virt = tmio_mmc_kmap_atomic(host->sg_ptr, &flags);
-        buf = (unsigned short *)(sg_virt + host->sg_off);
-
-        count = host->sg_ptr->length - host->sg_off;
-        if (count > data->blksz)
-                count = data->blksz;
-
-        pr_debug("count: %08x offset: %08x flags %08x\n",
-                 count, host->sg_off, data->flags);
-
-        /* Transfer the data */
-        if (data->flags & MMC_DATA_READ)
-                sd_ctrl_read16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
-        else
-                sd_ctrl_write16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
-
-        host->sg_off += count;
-
-        tmio_mmc_kunmap_atomic(host->sg_ptr, &flags, sg_virt);
-
-        if (host->sg_off == host->sg_ptr->length)
-                tmio_mmc_next_sg(host);
-
-        return;
-}
-
-/* needs to be called with host->lock held */
-static void tmio_mmc_do_data_irq(struct tmio_mmc_host *host)
-{
-        struct mmc_data *data = host->data;
-        struct mmc_command *stop;
-
-        host->data = NULL;
-
-        if (!data) {
-                dev_warn(&host->pdev->dev, "Spurious data end IRQ\n");
-                return;
-        }
-        stop = data->stop;
-
-        /* FIXME - return correct transfer count on errors */
-        if (!data->error)
-                data->bytes_xfered = data->blocks * data->blksz;
-        else
-                data->bytes_xfered = 0;
-
-        pr_debug("Completed data request\n");
-
-        /*
-         * FIXME: other drivers allow an optional stop command of any given type
-         *        which we dont do, as the chip can auto generate them.
-         *        Perhaps we can be smarter about when to use auto CMD12 and
-         *        only issue the auto request when we know this is the desired
-         *        stop command, allowing fallback to the stop command the
-         *        upper layers expect. For now, we do what works.
-         */
-
-        if (data->flags & MMC_DATA_READ) {
-                if (!host->chan_rx)
-                        disable_mmc_irqs(host, TMIO_MASK_READOP);
-                else
-                        tmio_check_bounce_buffer(host);
-                dev_dbg(&host->pdev->dev, "Complete Rx request %p\n",
-                        host->mrq);
-        } else {
-                if (!host->chan_tx)
-                        disable_mmc_irqs(host, TMIO_MASK_WRITEOP);
-                dev_dbg(&host->pdev->dev, "Complete Tx request %p\n",
-                        host->mrq);
-        }
-
-        if (stop) {
-                if (stop->opcode == 12 && !stop->arg)
-                        sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x000);
-                else
-                        BUG();
-        }
-
-        tmio_mmc_finish_request(host);
-}
-
-static void tmio_mmc_data_irq(struct tmio_mmc_host *host)
-{
-        struct mmc_data *data;
-        spin_lock(&host->lock);
-        data = host->data;
-
-        if (!data)
-                goto out;
-
-        if (host->chan_tx && (data->flags & MMC_DATA_WRITE)) {
-                /*
-                 * Has all data been written out yet? Testing on SuperH showed,
-                 * that in most cases the first interrupt comes already with the
-                 * BUSY status bit clear, but on some operations, like mount or
-                 * in the beginning of a write / sync / umount, there is one
-                 * DATAEND interrupt with the BUSY bit set, in this cases
-                 * waiting for one more interrupt fixes the problem.
-                 */
-                if (!(sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_CMD_BUSY)) {
-                        disable_mmc_irqs(host, TMIO_STAT_DATAEND);
-                        tasklet_schedule(&host->dma_complete);
-                }
-        } else if (host->chan_rx && (data->flags & MMC_DATA_READ)) {
-                disable_mmc_irqs(host, TMIO_STAT_DATAEND);
-                tasklet_schedule(&host->dma_complete);
-        } else {
-                tmio_mmc_do_data_irq(host);
-        }
-out:
-        spin_unlock(&host->lock);
-}
-
-static void tmio_mmc_cmd_irq(struct tmio_mmc_host *host,
-        unsigned int stat)
-{
-        struct mmc_command *cmd = host->cmd;
-        int i, addr;
-
-        spin_lock(&host->lock);
-
-        if (!host->cmd) {
-                pr_debug("Spurious CMD irq\n");
-                goto out;
-        }
-
-        host->cmd = NULL;
-
-        /* This controller is sicker than the PXA one. Not only do we need to
-         * drop the top 8 bits of the first response word, we also need to
-         * modify the order of the response for short response command types.
-         */
-
-        for (i = 3, addr = CTL_RESPONSE ; i >= 0 ; i--, addr += 4)
-                cmd->resp[i] = sd_ctrl_read32(host, addr);
-
-        if (cmd->flags &  MMC_RSP_136) {
-                cmd->resp[0] = (cmd->resp[0] << 8) | (cmd->resp[1] >> 24);
-                cmd->resp[1] = (cmd->resp[1] << 8) | (cmd->resp[2] >> 24);
-                cmd->resp[2] = (cmd->resp[2] << 8) | (cmd->resp[3] >> 24);
-                cmd->resp[3] <<= 8;
-        } else if (cmd->flags & MMC_RSP_R3) {
-                cmd->resp[0] = cmd->resp[3];
-        }
-
-        if (stat & TMIO_STAT_CMDTIMEOUT)
-                cmd->error = -ETIMEDOUT;
-        else if (stat & TMIO_STAT_CRCFAIL && cmd->flags & MMC_RSP_CRC)
-                cmd->error = -EILSEQ;
-
-        /* If there is data to handle we enable data IRQs here, and
-         * we will ultimatley finish the request in the data_end handler.
-         * If theres no data or we encountered an error, finish now.
-         */
-        if (host->data && !cmd->error) {
-                if (host->data->flags & MMC_DATA_READ) {
-                        if (!host->chan_rx)
-                                enable_mmc_irqs(host, TMIO_MASK_READOP);
-                } else {
-                        if (!host->chan_tx)
-                                enable_mmc_irqs(host, TMIO_MASK_WRITEOP);
-                        else
-                                tasklet_schedule(&host->dma_issue);
-                }
-        } else {
-                tmio_mmc_finish_request(host);
-        }
-
-out:
-        spin_unlock(&host->lock);
-
-        return;
-}
-
-static irqreturn_t tmio_mmc_irq(int irq, void *devid)
-{
-        struct tmio_mmc_host *host = devid;
-        struct tmio_mmc_data *pdata = mfd_get_data(host->pdev);
-        unsigned int ireg, irq_mask, status;
-        unsigned int sdio_ireg, sdio_irq_mask, sdio_status;
-
-        pr_debug("MMC IRQ begin\n");
-
-        status = sd_ctrl_read32(host, CTL_STATUS);
-        irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
-        ireg = status & TMIO_MASK_IRQ & ~irq_mask;
-
-        sdio_ireg = 0;
-        if (!ireg && pdata->flags & TMIO_MMC_SDIO_IRQ) {
-                sdio_status = sd_ctrl_read16(host, CTL_SDIO_STATUS);
-                sdio_irq_mask = sd_ctrl_read16(host, CTL_SDIO_IRQ_MASK);
-                sdio_ireg = sdio_status & TMIO_SDIO_MASK_ALL & ~sdio_irq_mask;
-
-                sd_ctrl_write16(host, CTL_SDIO_STATUS, sdio_status & ~TMIO_SDIO_MASK_ALL);
-
-                if (sdio_ireg && !host->sdio_irq_enabled) {
-                        pr_warning("tmio_mmc: Spurious SDIO IRQ, disabling! 0x%04x 0x%04x 0x%04x\n",
-                                   sdio_status, sdio_irq_mask, sdio_ireg);
-                        tmio_mmc_enable_sdio_irq(host->mmc, 0);
-                        goto out;
-                }
 
-                if (host->mmc->caps & MMC_CAP_SDIO_IRQ &&
-                        sdio_ireg & TMIO_SDIO_STAT_IOIRQ)
-                        mmc_signal_sdio_irq(host->mmc);
-
-                if (sdio_ireg)
-                        goto out;
-        }
-
-        pr_debug_status(status);
-        pr_debug_status(ireg);
-
-        if (!ireg) {
-                disable_mmc_irqs(host, status & ~irq_mask);
-
-                pr_warning("tmio_mmc: Spurious irq, disabling! "
-                        "0x%08x 0x%08x 0x%08x\n", status, irq_mask, ireg);
-                pr_debug_status(status);
-
-                goto out;
-        }
-
-        while (ireg) {
-                /* Card insert / remove attempts */
-                if (ireg & (TMIO_STAT_CARD_INSERT | TMIO_STAT_CARD_REMOVE)) {
-                        ack_mmc_irqs(host, TMIO_STAT_CARD_INSERT |
-                                TMIO_STAT_CARD_REMOVE);
-                        mmc_detect_change(host->mmc, msecs_to_jiffies(100));
-                }
-
-                /* CRC and other errors */
-/*              if (ireg & TMIO_STAT_ERR_IRQ)
- *                      handled |= tmio_error_irq(host, irq, stat);
- */
-
-                /* Command completion */
-                if (ireg & (TMIO_STAT_CMDRESPEND | TMIO_STAT_CMDTIMEOUT)) {
-                        ack_mmc_irqs(host,
-                                     TMIO_STAT_CMDRESPEND |
-                                     TMIO_STAT_CMDTIMEOUT);
-                        tmio_mmc_cmd_irq(host, status);
-                }
-
-                /* Data transfer */
-                if (ireg & (TMIO_STAT_RXRDY | TMIO_STAT_TXRQ)) {
-                        ack_mmc_irqs(host, TMIO_STAT_RXRDY | TMIO_STAT_TXRQ);
-                        tmio_mmc_pio_irq(host);
-                }
-
-                /* Data transfer completion */
-                if (ireg & TMIO_STAT_DATAEND) {
-                        ack_mmc_irqs(host, TMIO_STAT_DATAEND);
-                        tmio_mmc_data_irq(host);
-                }
-
-                /* Check status - keep going until we've handled it all */
-                status = sd_ctrl_read32(host, CTL_STATUS);
-                irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
-                ireg = status & TMIO_MASK_IRQ & ~irq_mask;
-
-                pr_debug("Status at end of loop: %08x\n", status);
-                pr_debug_status(status);
-        }
-        pr_debug("MMC IRQ end\n");
-
-out:
-        return IRQ_HANDLED;
-}
-
-#ifdef CONFIG_TMIO_MMC_DMA
-static void tmio_check_bounce_buffer(struct tmio_mmc_host *host)
-{
-        if (host->sg_ptr == &host->bounce_sg) {
-                unsigned long flags;
-                void *sg_vaddr = tmio_mmc_kmap_atomic(host->sg_orig, &flags);
-                memcpy(sg_vaddr, host->bounce_buf, host->bounce_sg.length);
-                tmio_mmc_kunmap_atomic(host->sg_orig, &flags, sg_vaddr);
-        }
-}
-
-static void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)
-{
-#if defined(CONFIG_SUPERH) || defined(CONFIG_ARCH_SHMOBILE)
-        /* Switch DMA mode on or off - SuperH specific? */
-        sd_ctrl_write16(host, 0xd8, enable ? 2 : 0);
-#endif
-}
-
-static void tmio_dma_complete(void *arg)
-{
-        struct tmio_mmc_host *host = arg;
-
-        dev_dbg(&host->pdev->dev, "Command completed\n");
-
-        if (!host->data)
-                dev_warn(&host->pdev->dev, "NULL data in DMA completion!\n");
-        else
-                enable_mmc_irqs(host, TMIO_STAT_DATAEND);
-}
-
-static void tmio_mmc_start_dma_rx(struct tmio_mmc_host *host)
-{
-        struct scatterlist *sg = host->sg_ptr, *sg_tmp;
-        struct dma_async_tx_descriptor *desc = NULL;
-        struct dma_chan *chan = host->chan_rx;
-        struct tmio_mmc_data *pdata = mfd_get_data(host->pdev);
-        dma_cookie_t cookie;
-        int ret, i;
-        bool aligned = true, multiple = true;
-        unsigned int align = (1 << pdata->dma->alignment_shift) - 1;
-
-        for_each_sg(sg, sg_tmp, host->sg_len, i) {
-                if (sg_tmp->offset & align)
-                        aligned = false;
-                if (sg_tmp->length & align) {
-                        multiple = false;
-                        break;
-                }
-        }
-
-        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||
-                          align >= MAX_ALIGN)) || !multiple) {
-                ret = -EINVAL;
-                goto pio;
-        }
-
-        /* The only sg element can be unaligned, use our bounce buffer then */
-        if (!aligned) {
-                sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);
-                host->sg_ptr = &host->bounce_sg;
-                sg = host->sg_ptr;
-        }
-
-        ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_FROM_DEVICE);
-        if (ret > 0)
-                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
-                        DMA_FROM_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-
-        if (desc) {
-                desc->callback = tmio_dma_complete;
-                desc->callback_param = host;
-                cookie = dmaengine_submit(desc);
-                dma_async_issue_pending(chan);
-        }
-        dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",
-                __func__, host->sg_len, ret, cookie, host->mrq);
-
-pio:
-        if (!desc) {
-                /* DMA failed, fall back to PIO */
-                if (ret >= 0)
-                        ret = -EIO;
-                host->chan_rx = NULL;
-                dma_release_channel(chan);
-                /* Free the Tx channel too */
-                chan = host->chan_tx;
-                if (chan) {
-                        host->chan_tx = NULL;
-                        dma_release_channel(chan);
-                }
-                dev_warn(&host->pdev->dev,
-                         "DMA failed: %d, falling back to PIO\n", ret);
-                tmio_mmc_enable_dma(host, false);
-        }
-
-        dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d, sg[%d]\n", __func__,
-                desc, cookie, host->sg_len);
-}
-
-static void tmio_mmc_start_dma_tx(struct tmio_mmc_host *host)
-{
-        struct scatterlist *sg = host->sg_ptr, *sg_tmp;
-        struct dma_async_tx_descriptor *desc = NULL;
-        struct dma_chan *chan = host->chan_tx;
-        struct tmio_mmc_data *pdata = mfd_get_data(host->pdev);
-        dma_cookie_t cookie;
-        int ret, i;
-        bool aligned = true, multiple = true;
-        unsigned int align = (1 << pdata->dma->alignment_shift) - 1;
-
-        for_each_sg(sg, sg_tmp, host->sg_len, i) {
-                if (sg_tmp->offset & align)
-                        aligned = false;
-                if (sg_tmp->length & align) {
-                        multiple = false;
-                        break;
-                }
-        }
-
-        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||
-                          align >= MAX_ALIGN)) || !multiple) {
-                ret = -EINVAL;
-                goto pio;
-        }
-
-        /* The only sg element can be unaligned, use our bounce buffer then */
-        if (!aligned) {
-                unsigned long flags;
-                void *sg_vaddr = tmio_mmc_kmap_atomic(sg, &flags);
-                sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);
-                memcpy(host->bounce_buf, sg_vaddr, host->bounce_sg.length);
-                tmio_mmc_kunmap_atomic(sg, &flags, sg_vaddr);
-                host->sg_ptr = &host->bounce_sg;
-                sg = host->sg_ptr;
-        }
-
-        ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_TO_DEVICE);
-        if (ret > 0)
-                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
-                        DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-
-        if (desc) {
-                desc->callback = tmio_dma_complete;
-                desc->callback_param = host;
-                cookie = dmaengine_submit(desc);
-        }
-        dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",
-                __func__, host->sg_len, ret, cookie, host->mrq);
-
-pio:
-        if (!desc) {
-                /* DMA failed, fall back to PIO */
-                if (ret >= 0)
-                        ret = -EIO;
-                host->chan_tx = NULL;
-                dma_release_channel(chan);
-                /* Free the Rx channel too */
-                chan = host->chan_rx;
-                if (chan) {
-                        host->chan_rx = NULL;
-                        dma_release_channel(chan);
-                }
-                dev_warn(&host->pdev->dev,
-                         "DMA failed: %d, falling back to PIO\n", ret);
-                tmio_mmc_enable_dma(host, false);
-        }
-
-        dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d\n", __func__,
-                desc, cookie);
-}
-
-static void tmio_mmc_start_dma(struct tmio_mmc_host *host,
-                               struct mmc_data *data)
-{
-        if (data->flags & MMC_DATA_READ) {
-                if (host->chan_rx)
-                        tmio_mmc_start_dma_rx(host);
-        } else {
-                if (host->chan_tx)
-                        tmio_mmc_start_dma_tx(host);
-        }
-}
-
-static void tmio_issue_tasklet_fn(unsigned long priv)
-{
-        struct tmio_mmc_host *host = (struct tmio_mmc_host *)priv;
-        struct dma_chan *chan = host->chan_tx;
-
-        dma_async_issue_pending(chan);
-}
-
-static void tmio_tasklet_fn(unsigned long arg)
-{
-        struct tmio_mmc_host *host = (struct tmio_mmc_host *)arg;
-        unsigned long flags;
-
-        spin_lock_irqsave(&host->lock, flags);
-
-        if (!host->data)
-                goto out;
-
-        if (host->data->flags & MMC_DATA_READ)
-                dma_unmap_sg(host->chan_rx->device->dev,
-                             host->sg_ptr, host->sg_len,
-                             DMA_FROM_DEVICE);
-        else
-                dma_unmap_sg(host->chan_tx->device->dev,
-                             host->sg_ptr, host->sg_len,
-                             DMA_TO_DEVICE);
-
-        tmio_mmc_do_data_irq(host);
-out:
-        spin_unlock_irqrestore(&host->lock, flags);
-}
-
-/* It might be necessary to make filter MFD specific */
-static bool tmio_mmc_filter(struct dma_chan *chan, void *arg)
-{
-        dev_dbg(chan->device->dev, "%s: slave data %p\n", __func__, arg);
-        chan->private = arg;
-        return true;
-}
-
-static void tmio_mmc_request_dma(struct tmio_mmc_host *host,
-                                 struct tmio_mmc_data *pdata)
-{
-        /* We can only either use DMA for both Tx and Rx or not use it at all */
-        if (pdata->dma) {
-                dma_cap_mask_t mask;
-
-                dma_cap_zero(mask);
-                dma_cap_set(DMA_SLAVE, mask);
-
-                host->chan_tx = dma_request_channel(mask, tmio_mmc_filter,
-                                                    pdata->dma->chan_priv_tx);
-                dev_dbg(&host->pdev->dev, "%s: TX: got channel %p\n", __func__,
-                        host->chan_tx);
-
-                if (!host->chan_tx)
-                        return;
-
-                host->chan_rx = dma_request_channel(mask, tmio_mmc_filter,
-                                                    pdata->dma->chan_priv_rx);
-                dev_dbg(&host->pdev->dev, "%s: RX: got channel %p\n", __func__,
-                        host->chan_rx);
-
-                if (!host->chan_rx) {
-                        dma_release_channel(host->chan_tx);
-                        host->chan_tx = NULL;
-                        return;
-                }
-
-                tasklet_init(&host->dma_complete, tmio_tasklet_fn, (unsigned long)host);
-                tasklet_init(&host->dma_issue, tmio_issue_tasklet_fn, (unsigned long)host);
-
-                tmio_mmc_enable_dma(host, true);
-        }
-}
-
-static void tmio_mmc_release_dma(struct tmio_mmc_host *host)
-{
-        if (host->chan_tx) {
-                struct dma_chan *chan = host->chan_tx;
-                host->chan_tx = NULL;
-                dma_release_channel(chan);
-        }
-        if (host->chan_rx) {
-                struct dma_chan *chan = host->chan_rx;
-                host->chan_rx = NULL;
-                dma_release_channel(chan);
-        }
-}
-#else
-static void tmio_check_bounce_buffer(struct tmio_mmc_host *host)
-{
-}
-
-static void tmio_mmc_start_dma(struct tmio_mmc_host *host,
-                               struct mmc_data *data)
-{
-}
-
-static void tmio_mmc_request_dma(struct tmio_mmc_host *host,
-                                 struct tmio_mmc_data *pdata)
-{
-        host->chan_tx = NULL;
-        host->chan_rx = NULL;
-}
-
-static void tmio_mmc_release_dma(struct tmio_mmc_host *host)
-{
-}
-#endif
-
-static int tmio_mmc_start_data(struct tmio_mmc_host *host,
-        struct mmc_data *data)
-{
-        struct tmio_mmc_data *pdata = mfd_get_data(host->pdev);
-
-        pr_debug("setup data transfer: blocksize %08x  nr_blocks %d\n",
-                 data->blksz, data->blocks);
-
-        /* Some hardware cannot perform 2 byte requests in 4 bit mode */
-        if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_4) {
-                int blksz_2bytes = pdata->flags & TMIO_MMC_BLKSZ_2BYTES;
-
-                if (data->blksz < 2 || (data->blksz < 4 && !blksz_2bytes)) {
-                        pr_err("%s: %d byte block unsupported in 4 bit mode\n",
-                               mmc_hostname(host->mmc), data->blksz);
-                        return -EINVAL;
-                }
-        }
-
-        tmio_mmc_init_sg(host, data);
-        host->data = data;
-
-        /* Set transfer length / blocksize */
-        sd_ctrl_write16(host, CTL_SD_XFER_LEN, data->blksz);
-        sd_ctrl_write16(host, CTL_XFER_BLK_COUNT, data->blocks);
-
-        tmio_mmc_start_dma(host, data);
-
-        return 0;
-}
-
-/* Process requests from the MMC layer */
-static void tmio_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
-{
-        struct tmio_mmc_host *host = mmc_priv(mmc);
-        int ret;
-
-        if (host->mrq)
-                pr_debug("request not null\n");
-
-        host->last_req_ts = jiffies;
-        wmb();
-        host->mrq = mrq;
-
-        if (mrq->data) {
-                ret = tmio_mmc_start_data(host, mrq->data);
-                if (ret)
-                        goto fail;
-        }
-
-        ret = tmio_mmc_start_command(host, mrq->cmd);
-        if (!ret) {
-                schedule_delayed_work(&host->delayed_reset_work,
-                                      msecs_to_jiffies(2000));
-                return;
-        }
-
-fail:
-        host->mrq = NULL;
-        mrq->cmd->error = ret;
-        mmc_request_done(mmc, mrq);
-}
-
-/* Set MMC clock / power.
- * Note: This controller uses a simple divider scheme therefore it cannot
- * run a MMC card at full speed (20MHz). The max clock is 24MHz on SD, but as
- * MMC wont run that fast, it has to be clocked at 12MHz which is the next
- * slowest setting.
- */
-static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
-{
-        struct tmio_mmc_host *host = mmc_priv(mmc);
-
-        if (ios->clock)
-                tmio_mmc_set_clock(host, ios->clock);
-
-        /* Power sequence - OFF -> ON -> UP */
-        switch (ios->power_mode) {
-        case MMC_POWER_OFF: /* power down SD bus */
-                if (host->set_pwr)
-                        host->set_pwr(host->pdev, 0);
-                tmio_mmc_clk_stop(host);
-                break;
-        case MMC_POWER_ON: /* power up SD bus */
-                if (host->set_pwr)
-                        host->set_pwr(host->pdev, 1);
-                break;
-        case MMC_POWER_UP: /* start bus clock */
-                tmio_mmc_clk_start(host);
-                break;
-        }
-
-        switch (ios->bus_width) {
-        case MMC_BUS_WIDTH_1:
-                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
-        break;
-        case MMC_BUS_WIDTH_4:
-                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
-        break;
-        }
-
-        /* Let things settle. delay taken from winCE driver */
-        udelay(140);
-}
-
-static int tmio_mmc_get_ro(struct mmc_host *mmc)
-{
-        struct tmio_mmc_host *host = mmc_priv(mmc);
-        struct tmio_mmc_data *pdata = mfd_get_data(host->pdev);
-
-        return ((pdata->flags & TMIO_MMC_WRPROTECT_DISABLE) ||
-                (sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_WRPROTECT)) ? 0 : 1;
-}
-
-static int tmio_mmc_get_cd(struct mmc_host *mmc)
-{
-        struct tmio_mmc_host *host = mmc_priv(mmc);
-        struct tmio_mmc_data *pdata = mfd_get_data(host->pdev);
-
-        if (!pdata->get_cd)
-                return -ENOSYS;
-        else
-                return pdata->get_cd(host->pdev);
-}
-
-static const struct mmc_host_ops tmio_mmc_ops = {
-        .request        = tmio_mmc_request,
-        .set_ios        = tmio_mmc_set_ios,
-        .get_ro         = tmio_mmc_get_ro,
-        .get_cd         = tmio_mmc_get_cd,
-        .enable_sdio_irq = tmio_mmc_enable_sdio_irq,
-};
+#include "tmio_mmc.h"
 
 #ifdef CONFIG_PM
 static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
@@ -1227,138 +62,54 @@ out:
 #define tmio_mmc_resume NULL
 #endif
 
-static int __devinit tmio_mmc_probe(struct platform_device *dev)
+static int __devinit tmio_mmc_probe(struct platform_device *pdev)
 {
-        const struct mfd_cell *cell = mfd_get_cell(dev);
+        const struct mfd_cell *cell = mfd_get_cell(pdev);
         struct tmio_mmc_data *pdata;
-        struct resource *res_ctl;
         struct tmio_mmc_host *host;
-        struct mmc_host *mmc;
         int ret = -EINVAL;
-        u32 irq_mask = TMIO_MASK_CMD;
 
-        if (dev->num_resources != 2)
+        if (pdev->num_resources != 2)
                 goto out;
 
-        res_ctl = platform_get_resource(dev, IORESOURCE_MEM, 0);
-        if (!res_ctl)
-                goto out;
-
-        pdata = mfd_get_data(dev);
+        pdata = mfd_get_data(pdev);
         if (!pdata || !pdata->hclk)
                 goto out;
 
-        ret = -ENOMEM;
-
-        mmc = mmc_alloc_host(sizeof(struct tmio_mmc_host), &dev->dev);
-        if (!mmc)
-                goto out;
-
-        host = mmc_priv(mmc);
-        host->mmc = mmc;
-        host->pdev = dev;
-        platform_set_drvdata(dev, mmc);
-
-        host->set_pwr = pdata->set_pwr;
-        host->set_clk_div = pdata->set_clk_div;
-
-        /* SD control register space size is 0x200, 0x400 for bus_shift=1 */
-        host->bus_shift = resource_size(res_ctl) >> 10;
-
-        host->ctl = ioremap(res_ctl->start, resource_size(res_ctl));
-        if (!host->ctl)
-                goto host_free;
-
-        mmc->ops = &tmio_mmc_ops;
-        mmc->caps = MMC_CAP_4_BIT_DATA | pdata->capabilities;
-        mmc->f_max = pdata->hclk;
-        mmc->f_min = mmc->f_max / 512;
-        mmc->max_segs = 32;
-        mmc->max_blk_size = 512;
-        mmc->max_blk_count = (PAGE_CACHE_SIZE / mmc->max_blk_size) *
-                mmc->max_segs;
-        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
-        mmc->max_seg_size = mmc->max_req_size;
-        if (pdata->ocr_mask)
-                mmc->ocr_avail = pdata->ocr_mask;
-        else
-                mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
-
         /* Tell the MFD core we are ready to be enabled */
         if (cell->enable) {
-                ret = cell->enable(dev);
+                ret = cell->enable(pdev);
                 if (ret)
-                        goto unmap_ctl;
+                        goto out;
         }
 
-        tmio_mmc_clk_stop(host);
-        reset(host);
-
-        ret = platform_get_irq(dev, 0);
-        if (ret >= 0)
-                host->irq = ret;
-        else
-                goto cell_disable;
-
-        disable_mmc_irqs(host, TMIO_MASK_ALL);
-        if (pdata->flags & TMIO_MMC_SDIO_IRQ)
-                tmio_mmc_enable_sdio_irq(mmc, 0);
-
-        ret = request_irq(host->irq, tmio_mmc_irq, IRQF_DISABLED |
-                IRQF_TRIGGER_FALLING, dev_name(&dev->dev), host);
+        ret = tmio_mmc_host_probe(&host, pdev, pdata);
         if (ret)
                 goto cell_disable;
 
-        spin_lock_init(&host->lock);
-
-        /* Init delayed work for request timeouts */
-        INIT_DELAYED_WORK(&host->delayed_reset_work, tmio_mmc_reset_work);
-
-        /* See if we also get DMA */
-        tmio_mmc_request_dma(host, pdata);
-
-        mmc_add_host(mmc);
-
         pr_info("%s at 0x%08lx irq %d\n", mmc_hostname(host->mmc),
                 (unsigned long)host->ctl, host->irq);
 
-        /* Unmask the IRQs we want to know about */
-        if (!host->chan_rx)
-                irq_mask |= TMIO_MASK_READOP;
-        if (!host->chan_tx)
-                irq_mask |= TMIO_MASK_WRITEOP;
-        enable_mmc_irqs(host, irq_mask);
-
         return 0;
 
 cell_disable:
         if (cell->disable)
-                cell->disable(dev);
-unmap_ctl:
-        iounmap(host->ctl);
-host_free:
-        mmc_free_host(mmc);
+                cell->disable(pdev);
 out:
         return ret;
 }
 
-static int __devexit tmio_mmc_remove(struct platform_device *dev)
+static int __devexit tmio_mmc_remove(struct platform_device *pdev)
 {
-        const struct mfd_cell *cell = mfd_get_cell(dev);
-        struct mmc_host *mmc = platform_get_drvdata(dev);
+        const struct mfd_cell *cell = mfd_get_cell(pdev);
+        struct mmc_host *mmc = platform_get_drvdata(pdev);
 
-        platform_set_drvdata(dev, NULL);
+        platform_set_drvdata(pdev, NULL);
 
         if (mmc) {
-                struct tmio_mmc_host *host = mmc_priv(mmc);
-                mmc_remove_host(mmc);
-                cancel_delayed_work_sync(&host->delayed_reset_work);
-                tmio_mmc_release_dma(host);
-                free_irq(host->irq, host);
+                tmio_mmc_host_remove(mmc_priv(mmc));
                 if (cell->disable)
-                        cell->disable(dev);
-                iounmap(host->ctl);
-                mmc_free_host(mmc);
+                        cell->disable(pdev);
         }
 
         return 0;
diff --git a/drivers/mmc/host/tmio_mmc.h b/drivers/mmc/host/tmio_mmc.h
new file mode 100644
index 000000000000..099ed49a259b
--- /dev/null
+++ b/drivers/mmc/host/tmio_mmc.h
@@ -0,0 +1,123 @@
+/*
+ * linux/drivers/mmc/host/tmio_mmc.h
+ *
+ * Copyright (C) 2007 Ian Molton
+ * Copyright (C) 2004 Ian Molton
+ *
+ * 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.
+ *
+ * Driver for the MMC / SD / SDIO cell found in:
+ *
+ * TC6393XB TC6391XB TC6387XB T7L66XB ASIC3
+ */
+
+#ifndef TMIO_MMC_H
+#define TMIO_MMC_H
+
+#include <linux/highmem.h>
+#include <linux/mmc/tmio.h>
+#include <linux/pagemap.h>
+
+/* Definitions for values the CTRL_SDIO_STATUS register can take. */
+#define TMIO_SDIO_STAT_IOIRQ    0x0001
+#define TMIO_SDIO_STAT_EXPUB52  0x4000
+#define TMIO_SDIO_STAT_EXWT     0x8000
+#define TMIO_SDIO_MASK_ALL      0xc007
+
+/* Define some IRQ masks */
+/* This is the mask used at reset by the chip */
+#define TMIO_MASK_ALL           0x837f031d
+#define TMIO_MASK_READOP  (TMIO_STAT_RXRDY | TMIO_STAT_DATAEND)
+#define TMIO_MASK_WRITEOP (TMIO_STAT_TXRQ | TMIO_STAT_DATAEND)
+#define TMIO_MASK_CMD     (TMIO_STAT_CMDRESPEND | TMIO_STAT_CMDTIMEOUT | \
+                TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT)
+#define TMIO_MASK_IRQ     (TMIO_MASK_READOP | TMIO_MASK_WRITEOP | TMIO_MASK_CMD)
+
+struct tmio_mmc_data;
+
+struct tmio_mmc_host {
+        void __iomem *ctl;
+        unsigned long bus_shift;
+        struct mmc_command      *cmd;
+        struct mmc_request      *mrq;
+        struct mmc_data         *data;
+        struct mmc_host         *mmc;
+        int                     irq;
+        unsigned int            sdio_irq_enabled;
+
+        /* Callbacks for clock / power control */
+        void (*set_pwr)(struct platform_device *host, int state);
+        void (*set_clk_div)(struct platform_device *host, int state);
+
+        /* pio related stuff */
+        struct scatterlist      *sg_ptr;
+        struct scatterlist      *sg_orig;
+        unsigned int            sg_len;
+        unsigned int            sg_off;
+
+        struct platform_device *pdev;
+        struct tmio_mmc_data *pdata;
+
+        /* DMA support */
+        bool                    force_pio;
+        struct dma_chan         *chan_rx;
+        struct dma_chan         *chan_tx;
+        struct tasklet_struct   dma_complete;
+        struct tasklet_struct   dma_issue;
+        struct scatterlist      bounce_sg;
+        u8                      *bounce_buf;
+
+        /* Track lost interrupts */
+        struct delayed_work     delayed_reset_work;
+        spinlock_t              lock;
+        unsigned long           last_req_ts;
+};
+
+int tmio_mmc_host_probe(struct tmio_mmc_host **host,
+                        struct platform_device *pdev,
+                        struct tmio_mmc_data *pdata);
+void tmio_mmc_host_remove(struct tmio_mmc_host *host);
+void tmio_mmc_do_data_irq(struct tmio_mmc_host *host);
+
+void tmio_mmc_enable_mmc_irqs(struct tmio_mmc_host *host, u32 i);
+void tmio_mmc_disable_mmc_irqs(struct tmio_mmc_host *host, u32 i);
+
+static inline char *tmio_mmc_kmap_atomic(struct scatterlist *sg,
+                                         unsigned long *flags)
+{
+        local_irq_save(*flags);
+        return kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
+}
+
+static inline void tmio_mmc_kunmap_atomic(struct scatterlist *sg,
+                                          unsigned long *flags, void *virt)
+{
+        kunmap_atomic(virt - sg->offset, KM_BIO_SRC_IRQ);
+        local_irq_restore(*flags);
+}
+
+#if defined(CONFIG_MMC_SDHI) || defined(CONFIG_MMC_SDHI_MODULE)
+void tmio_mmc_start_dma(struct tmio_mmc_host *host, struct mmc_data *data);
+void tmio_mmc_request_dma(struct tmio_mmc_host *host, struct tmio_mmc_data *pdata);
+void tmio_mmc_release_dma(struct tmio_mmc_host *host);
+#else
+static inline void tmio_mmc_start_dma(struct tmio_mmc_host *host,
+                               struct mmc_data *data)
+{
+}
+
+static inline void tmio_mmc_request_dma(struct tmio_mmc_host *host,
+                                 struct tmio_mmc_data *pdata)
+{
+        host->chan_tx = NULL;
+        host->chan_rx = NULL;
+}
+
+static inline void tmio_mmc_release_dma(struct tmio_mmc_host *host)
+{
+}
+#endif
+
+#endif
diff --git a/drivers/mmc/host/tmio_mmc_dma.c b/drivers/mmc/host/tmio_mmc_dma.c
new file mode 100644
index 000000000000..d3de74ab633e
--- /dev/null
+++ b/drivers/mmc/host/tmio_mmc_dma.c
@@ -0,0 +1,317 @@
+/*
+ * linux/drivers/mmc/tmio_mmc_dma.c
+ *
+ * Copyright (C) 2010-2011 Guennadi Liakhovetski
+ *
+ * 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.
+ *
+ * DMA function for TMIO MMC implementations
+ */
+
+#include <linux/device.h>
+#include <linux/dmaengine.h>
+#include <linux/mfd/tmio.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/tmio.h>
+#include <linux/pagemap.h>
+#include <linux/scatterlist.h>
+
+#include "tmio_mmc.h"
+
+#define TMIO_MMC_MIN_DMA_LEN 8
+
+static void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)
+{
+#if defined(CONFIG_SUPERH) || defined(CONFIG_ARCH_SHMOBILE)
+        /* Switch DMA mode on or off - SuperH specific? */
+        writew(enable ? 2 : 0, host->ctl + (0xd8 << host->bus_shift));
+#endif
+}
+
+static void tmio_mmc_start_dma_rx(struct tmio_mmc_host *host)
+{
+        struct scatterlist *sg = host->sg_ptr, *sg_tmp;
+        struct dma_async_tx_descriptor *desc = NULL;
+        struct dma_chan *chan = host->chan_rx;
+        struct tmio_mmc_data *pdata = host->pdata;
+        dma_cookie_t cookie;
+        int ret, i;
+        bool aligned = true, multiple = true;
+        unsigned int align = (1 << pdata->dma->alignment_shift) - 1;
+
+        for_each_sg(sg, sg_tmp, host->sg_len, i) {
+                if (sg_tmp->offset & align)
+                        aligned = false;
+                if (sg_tmp->length & align) {
+                        multiple = false;
+                        break;
+                }
+        }
+
+        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||
+                          (align & PAGE_MASK))) || !multiple) {
+                ret = -EINVAL;
+                goto pio;
+        }
+
+        if (sg->length < TMIO_MMC_MIN_DMA_LEN) {
+                host->force_pio = true;
+                return;
+        }
+
+        tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_RXRDY);
+
+        /* The only sg element can be unaligned, use our bounce buffer then */
+        if (!aligned) {
+                sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);
+                host->sg_ptr = &host->bounce_sg;
+                sg = host->sg_ptr;
+        }
+
+        ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_FROM_DEVICE);
+        if (ret > 0)
+                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                        DMA_FROM_DEVICE, DMA_CTRL_ACK);
+
+        if (desc) {
+                cookie = dmaengine_submit(desc);
+                if (cookie < 0) {
+                        desc = NULL;
+                        ret = cookie;
+                }
+        }
+        dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",
+                __func__, host->sg_len, ret, cookie, host->mrq);
+
+pio:
+        if (!desc) {
+                /* DMA failed, fall back to PIO */
+                if (ret >= 0)
+                        ret = -EIO;
+                host->chan_rx = NULL;
+                dma_release_channel(chan);
+                /* Free the Tx channel too */
+                chan = host->chan_tx;
+                if (chan) {
+                        host->chan_tx = NULL;
+                        dma_release_channel(chan);
+                }
+                dev_warn(&host->pdev->dev,
+                         "DMA failed: %d, falling back to PIO\n", ret);
+                tmio_mmc_enable_dma(host, false);
+        }
+
+        dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d, sg[%d]\n", __func__,
+                desc, cookie, host->sg_len);
+}
+
+static void tmio_mmc_start_dma_tx(struct tmio_mmc_host *host)
+{
+        struct scatterlist *sg = host->sg_ptr, *sg_tmp;
+        struct dma_async_tx_descriptor *desc = NULL;
+        struct dma_chan *chan = host->chan_tx;
+        struct tmio_mmc_data *pdata = host->pdata;
+        dma_cookie_t cookie;
+        int ret, i;
+        bool aligned = true, multiple = true;
+        unsigned int align = (1 << pdata->dma->alignment_shift) - 1;
+
+        for_each_sg(sg, sg_tmp, host->sg_len, i) {
+                if (sg_tmp->offset & align)
+                        aligned = false;
+                if (sg_tmp->length & align) {
+                        multiple = false;
+                        break;
+                }
+        }
+
+        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||
+                          (align & PAGE_MASK))) || !multiple) {
+                ret = -EINVAL;
+                goto pio;
+        }
+
+        if (sg->length < TMIO_MMC_MIN_DMA_LEN) {
+                host->force_pio = true;
+                return;
+        }
+
+        tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_TXRQ);
+
+        /* The only sg element can be unaligned, use our bounce buffer then */
+        if (!aligned) {
+                unsigned long flags;
+                void *sg_vaddr = tmio_mmc_kmap_atomic(sg, &flags);
+                sg_init_one(&host->bounce_sg, host->bounce_buf, sg->length);
+                memcpy(host->bounce_buf, sg_vaddr, host->bounce_sg.length);
+                tmio_mmc_kunmap_atomic(sg, &flags, sg_vaddr);
+                host->sg_ptr = &host->bounce_sg;
+                sg = host->sg_ptr;
+        }
+
+        ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_TO_DEVICE);
+        if (ret > 0)
+                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
+                        DMA_TO_DEVICE, DMA_CTRL_ACK);
+
+        if (desc) {
+                cookie = dmaengine_submit(desc);
+                if (cookie < 0) {
+                        desc = NULL;
+                        ret = cookie;
+                }
+        }
+        dev_dbg(&host->pdev->dev, "%s(): mapped %d -> %d, cookie %d, rq %p\n",
+                __func__, host->sg_len, ret, cookie, host->mrq);
+
+pio:
+        if (!desc) {
+                /* DMA failed, fall back to PIO */
+                if (ret >= 0)
+                        ret = -EIO;
+                host->chan_tx = NULL;
+                dma_release_channel(chan);
+                /* Free the Rx channel too */
+                chan = host->chan_rx;
+                if (chan) {
+                        host->chan_rx = NULL;
+                        dma_release_channel(chan);
+                }
+                dev_warn(&host->pdev->dev,
+                         "DMA failed: %d, falling back to PIO\n", ret);
+                tmio_mmc_enable_dma(host, false);
+        }
+
+        dev_dbg(&host->pdev->dev, "%s(): desc %p, cookie %d\n", __func__,
+                desc, cookie);
+}
+
+void tmio_mmc_start_dma(struct tmio_mmc_host *host,
+                               struct mmc_data *data)
+{
+        if (data->flags & MMC_DATA_READ) {
+                if (host->chan_rx)
+                        tmio_mmc_start_dma_rx(host);
+        } else {
+                if (host->chan_tx)
+                        tmio_mmc_start_dma_tx(host);
+        }
+}
+
+static void tmio_mmc_issue_tasklet_fn(unsigned long priv)
+{
+        struct tmio_mmc_host *host = (struct tmio_mmc_host *)priv;
+        struct dma_chan *chan = NULL;
+
+        spin_lock_irq(&host->lock);
+
+        if (host && host->data) {
+                if (host->data->flags & MMC_DATA_READ)
+                        chan = host->chan_rx;
+                else
+                        chan = host->chan_tx;
+        }
+
+        spin_unlock_irq(&host->lock);
+
+        tmio_mmc_enable_mmc_irqs(host, TMIO_STAT_DATAEND);
+
+        if (chan)
+                dma_async_issue_pending(chan);
+}
+
+static void tmio_mmc_tasklet_fn(unsigned long arg)
+{
+        struct tmio_mmc_host *host = (struct tmio_mmc_host *)arg;
+
+        spin_lock_irq(&host->lock);
+
+        if (!host->data)
+                goto out;
+
+        if (host->data->flags & MMC_DATA_READ)
+                dma_unmap_sg(host->chan_rx->device->dev,
+                             host->sg_ptr, host->sg_len,
+                             DMA_FROM_DEVICE);
+        else
+                dma_unmap_sg(host->chan_tx->device->dev,
+                             host->sg_ptr, host->sg_len,
+                             DMA_TO_DEVICE);
+
+        tmio_mmc_do_data_irq(host);
+out:
+        spin_unlock_irq(&host->lock);
+}
+
+/* It might be necessary to make filter MFD specific */
+static bool tmio_mmc_filter(struct dma_chan *chan, void *arg)
+{
+        dev_dbg(chan->device->dev, "%s: slave data %p\n", __func__, arg);
+        chan->private = arg;
+        return true;
+}
+
+void tmio_mmc_request_dma(struct tmio_mmc_host *host, struct tmio_mmc_data *pdata)
+{
+        /* We can only either use DMA for both Tx and Rx or not use it at all */
+        if (pdata->dma) {
+                dma_cap_mask_t mask;
+
+                dma_cap_zero(mask);
+                dma_cap_set(DMA_SLAVE, mask);
+
+                host->chan_tx = dma_request_channel(mask, tmio_mmc_filter,
+                                                    pdata->dma->chan_priv_tx);
+                dev_dbg(&host->pdev->dev, "%s: TX: got channel %p\n", __func__,
+                        host->chan_tx);
+
+                if (!host->chan_tx)
+                        return;
+
+                host->chan_rx = dma_request_channel(mask, tmio_mmc_filter,
+                                                    pdata->dma->chan_priv_rx);
+                dev_dbg(&host->pdev->dev, "%s: RX: got channel %p\n", __func__,
+                        host->chan_rx);
+
+                if (!host->chan_rx)
+                        goto ereqrx;
+
+                host->bounce_buf = (u8 *)__get_free_page(GFP_KERNEL | GFP_DMA);
+                if (!host->bounce_buf)
+                        goto ebouncebuf;
+
+                tasklet_init(&host->dma_complete, tmio_mmc_tasklet_fn, (unsigned long)host);
+                tasklet_init(&host->dma_issue, tmio_mmc_issue_tasklet_fn, (unsigned long)host);
+
+                tmio_mmc_enable_dma(host, true);
+
+                return;
+ebouncebuf:
+                dma_release_channel(host->chan_rx);
+                host->chan_rx = NULL;
+ereqrx:
+                dma_release_channel(host->chan_tx);
+                host->chan_tx = NULL;
+                return;
+        }
+}
+
+void tmio_mmc_release_dma(struct tmio_mmc_host *host)
+{
+        if (host->chan_tx) {
+                struct dma_chan *chan = host->chan_tx;
+                host->chan_tx = NULL;
+                dma_release_channel(chan);
+        }
+        if (host->chan_rx) {
+                struct dma_chan *chan = host->chan_rx;
+                host->chan_rx = NULL;
+                dma_release_channel(chan);
+        }
+        if (host->bounce_buf) {
+                free_pages((unsigned long)host->bounce_buf, 0);
+                host->bounce_buf = NULL;
+        }
+}
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
new file mode 100644
index 000000000000..6ae8d2f00ec7
--- /dev/null
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -0,0 +1,897 @@
+/*
+ * linux/drivers/mmc/host/tmio_mmc_pio.c
+ *
+ * Copyright (C) 2011 Guennadi Liakhovetski
+ * Copyright (C) 2007 Ian Molton
+ * Copyright (C) 2004 Ian Molton
+ *
+ * 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.
+ *
+ * Driver for the MMC / SD / SDIO IP found in:
+ *
+ * TC6393XB, TC6391XB, TC6387XB, T7L66XB, ASIC3, SH-Mobile SoCs
+ *
+ * This driver draws mainly on scattered spec sheets, Reverse engineering
+ * of the toshiba e800  SD driver and some parts of the 2.4 ASIC3 driver (4 bit
+ * support). (Further 4 bit support from a later datasheet).
+ *
+ * TODO:
+ *   Investigate using a workqueue for PIO transfers
+ *   Eliminate FIXMEs
+ *   SDIO support
+ *   Better Power management
+ *   Handle MMC errors better
+ *   double buffer support
+ *
+ */
+
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/highmem.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/mfd/tmio.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/tmio.h>
+#include <linux/module.h>
+#include <linux/pagemap.h>
+#include <linux/platform_device.h>
+#include <linux/scatterlist.h>
+#include <linux/workqueue.h>
+#include <linux/spinlock.h>
+
+#include "tmio_mmc.h"
+
+static u16 sd_ctrl_read16(struct tmio_mmc_host *host, int addr)
+{
+        return readw(host->ctl + (addr << host->bus_shift));
+}
+
+static void sd_ctrl_read16_rep(struct tmio_mmc_host *host, int addr,
+                u16 *buf, int count)
+{
+        readsw(host->ctl + (addr << host->bus_shift), buf, count);
+}
+
+static u32 sd_ctrl_read32(struct tmio_mmc_host *host, int addr)
+{
+        return readw(host->ctl + (addr << host->bus_shift)) |
+               readw(host->ctl + ((addr + 2) << host->bus_shift)) << 16;
+}
+
+static void sd_ctrl_write16(struct tmio_mmc_host *host, int addr, u16 val)
+{
+        writew(val, host->ctl + (addr << host->bus_shift));
+}
+
+static void sd_ctrl_write16_rep(struct tmio_mmc_host *host, int addr,
+                u16 *buf, int count)
+{
+        writesw(host->ctl + (addr << host->bus_shift), buf, count);
+}
+
+static void sd_ctrl_write32(struct tmio_mmc_host *host, int addr, u32 val)
+{
+        writew(val, host->ctl + (addr << host->bus_shift));
+        writew(val >> 16, host->ctl + ((addr + 2) << host->bus_shift));
+}
+
+void tmio_mmc_enable_mmc_irqs(struct tmio_mmc_host *host, u32 i)
+{
+        u32 mask = sd_ctrl_read32(host, CTL_IRQ_MASK) & ~(i & TMIO_MASK_IRQ);
+        sd_ctrl_write32(host, CTL_IRQ_MASK, mask);
+}
+
+void tmio_mmc_disable_mmc_irqs(struct tmio_mmc_host *host, u32 i)
+{
+        u32 mask = sd_ctrl_read32(host, CTL_IRQ_MASK) | (i & TMIO_MASK_IRQ);
+        sd_ctrl_write32(host, CTL_IRQ_MASK, mask);
+}
+
+static void tmio_mmc_ack_mmc_irqs(struct tmio_mmc_host *host, u32 i)
+{
+        sd_ctrl_write32(host, CTL_STATUS, ~i);
+}
+
+static void tmio_mmc_init_sg(struct tmio_mmc_host *host, struct mmc_data *data)
+{
+        host->sg_len = data->sg_len;
+        host->sg_ptr = data->sg;
+        host->sg_orig = data->sg;
+        host->sg_off = 0;
+}
+
+static int tmio_mmc_next_sg(struct tmio_mmc_host *host)
+{
+        host->sg_ptr = sg_next(host->sg_ptr);
+        host->sg_off = 0;
+        return --host->sg_len;
+}
+
+#ifdef CONFIG_MMC_DEBUG
+
+#define STATUS_TO_TEXT(a, status, i) \
+        do { \
+                if (status & TMIO_STAT_##a) { \
+                        if (i++) \
+                                printk(" | "); \
+                        printk(#a); \
+                } \
+        } while (0)
+
+static void pr_debug_status(u32 status)
+{
+        int i = 0;
+        printk(KERN_DEBUG "status: %08x = ", status);
+        STATUS_TO_TEXT(CARD_REMOVE, status, i);
+        STATUS_TO_TEXT(CARD_INSERT, status, i);
+        STATUS_TO_TEXT(SIGSTATE, status, i);
+        STATUS_TO_TEXT(WRPROTECT, status, i);
+        STATUS_TO_TEXT(CARD_REMOVE_A, status, i);
+        STATUS_TO_TEXT(CARD_INSERT_A, status, i);
+        STATUS_TO_TEXT(SIGSTATE_A, status, i);
+        STATUS_TO_TEXT(CMD_IDX_ERR, status, i);
+        STATUS_TO_TEXT(STOPBIT_ERR, status, i);
+        STATUS_TO_TEXT(ILL_FUNC, status, i);
+        STATUS_TO_TEXT(CMD_BUSY, status, i);
+        STATUS_TO_TEXT(CMDRESPEND, status, i);
+        STATUS_TO_TEXT(DATAEND, status, i);
+        STATUS_TO_TEXT(CRCFAIL, status, i);
+        STATUS_TO_TEXT(DATATIMEOUT, status, i);
+        STATUS_TO_TEXT(CMDTIMEOUT, status, i);
+        STATUS_TO_TEXT(RXOVERFLOW, status, i);
+        STATUS_TO_TEXT(TXUNDERRUN, status, i);
+        STATUS_TO_TEXT(RXRDY, status, i);
+        STATUS_TO_TEXT(TXRQ, status, i);
+        STATUS_TO_TEXT(ILL_ACCESS, status, i);
+        printk("\n");
+}
+
+#else
+#define pr_debug_status(s)  do { } while (0)
+#endif
+
+static void tmio_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+
+        if (enable) {
+                host->sdio_irq_enabled = 1;
+                sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0001);
+                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK,
+                        (TMIO_SDIO_MASK_ALL & ~TMIO_SDIO_STAT_IOIRQ));
+        } else {
+                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, TMIO_SDIO_MASK_ALL);
+                sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0000);
+                host->sdio_irq_enabled = 0;
+        }
+}
+
+static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
+{
+        u32 clk = 0, clock;
+
+        if (new_clock) {
+                for (clock = host->mmc->f_min, clk = 0x80000080;
+                        new_clock >= (clock<<1); clk >>= 1)
+                        clock <<= 1;
+                clk |= 0x100;
+        }
+
+        if (host->set_clk_div)
+                host->set_clk_div(host->pdev, (clk>>22) & 1);
+
+        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, clk & 0x1ff);
+}
+
+static void tmio_mmc_clk_stop(struct tmio_mmc_host *host)
+{
+        struct resource *res = platform_get_resource(host->pdev, IORESOURCE_MEM, 0);
+
+        /* implicit BUG_ON(!res) */
+        if (resource_size(res) > 0x100) {
+                sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0000);
+                msleep(10);
+        }
+
+        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~0x0100 &
+                sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
+        msleep(10);
+}
+
+static void tmio_mmc_clk_start(struct tmio_mmc_host *host)
+{
+        struct resource *res = platform_get_resource(host->pdev, IORESOURCE_MEM, 0);
+
+        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, 0x0100 |
+                sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
+        msleep(10);
+
+        /* implicit BUG_ON(!res) */
+        if (resource_size(res) > 0x100) {
+                sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0100);
+                msleep(10);
+        }
+}
+
+static void tmio_mmc_reset(struct tmio_mmc_host *host)
+{
+        struct resource *res = platform_get_resource(host->pdev, IORESOURCE_MEM, 0);
+
+        /* FIXME - should we set stop clock reg here */
+        sd_ctrl_write16(host, CTL_RESET_SD, 0x0000);
+        /* implicit BUG_ON(!res) */
+        if (resource_size(res) > 0x100)
+                sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0000);
+        msleep(10);
+        sd_ctrl_write16(host, CTL_RESET_SD, 0x0001);
+        if (resource_size(res) > 0x100)
+                sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0001);
+        msleep(10);
+}
+
+static void tmio_mmc_reset_work(struct work_struct *work)
+{
+        struct tmio_mmc_host *host = container_of(work, struct tmio_mmc_host,
+                                                  delayed_reset_work.work);
+        struct mmc_request *mrq;
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
+        mrq = host->mrq;
+
+        /* request already finished */
+        if (!mrq
+            || time_is_after_jiffies(host->last_req_ts +
+                msecs_to_jiffies(2000))) {
+                spin_unlock_irqrestore(&host->lock, flags);
+                return;
+        }
+
+        dev_warn(&host->pdev->dev,
+                "timeout waiting for hardware interrupt (CMD%u)\n",
+                mrq->cmd->opcode);
+
+        if (host->data)
+                host->data->error = -ETIMEDOUT;
+        else if (host->cmd)
+                host->cmd->error = -ETIMEDOUT;
+        else
+                mrq->cmd->error = -ETIMEDOUT;
+
+        host->cmd = NULL;
+        host->data = NULL;
+        host->mrq = NULL;
+        host->force_pio = false;
+
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        tmio_mmc_reset(host);
+
+        mmc_request_done(host->mmc, mrq);
+}
+
+static void tmio_mmc_finish_request(struct tmio_mmc_host *host)
+{
+        struct mmc_request *mrq = host->mrq;
+
+        if (!mrq)
+                return;
+
+        host->mrq = NULL;
+        host->cmd = NULL;
+        host->data = NULL;
+        host->force_pio = false;
+
+        cancel_delayed_work(&host->delayed_reset_work);
+
+        mmc_request_done(host->mmc, mrq);
+}
+
+/* These are the bitmasks the tmio chip requires to implement the MMC response
+ * types. Note that R1 and R6 are the same in this scheme. */
+#define APP_CMD        0x0040
+#define RESP_NONE      0x0300
+#define RESP_R1        0x0400
+#define RESP_R1B       0x0500
+#define RESP_R2        0x0600
+#define RESP_R3        0x0700
+#define DATA_PRESENT   0x0800
+#define TRANSFER_READ  0x1000
+#define TRANSFER_MULTI 0x2000
+#define SECURITY_CMD   0x4000
+
+static int tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command *cmd)
+{
+        struct mmc_data *data = host->data;
+        int c = cmd->opcode;
+
+        /* Command 12 is handled by hardware */
+        if (cmd->opcode == 12 && !cmd->arg) {
+                sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x001);
+                return 0;
+        }
+
+        switch (mmc_resp_type(cmd)) {
+        case MMC_RSP_NONE: c |= RESP_NONE; break;
+        case MMC_RSP_R1:   c |= RESP_R1;   break;
+        case MMC_RSP_R1B:  c |= RESP_R1B;  break;
+        case MMC_RSP_R2:   c |= RESP_R2;   break;
+        case MMC_RSP_R3:   c |= RESP_R3;   break;
+        default:
+                pr_debug("Unknown response type %d\n", mmc_resp_type(cmd));
+                return -EINVAL;
+        }
+
+        host->cmd = cmd;
+
+/* FIXME - this seems to be ok commented out but the spec suggest this bit
+ *         should be set when issuing app commands.
+ *      if(cmd->flags & MMC_FLAG_ACMD)
+ *              c |= APP_CMD;
+ */
+        if (data) {
+                c |= DATA_PRESENT;
+                if (data->blocks > 1) {
+                        sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x100);
+                        c |= TRANSFER_MULTI;
+                }
+                if (data->flags & MMC_DATA_READ)
+                        c |= TRANSFER_READ;
+        }
+
+        tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_CMD);
+
+        /* Fire off the command */
+        sd_ctrl_write32(host, CTL_ARG_REG, cmd->arg);
+        sd_ctrl_write16(host, CTL_SD_CMD, c);
+
+        return 0;
+}
+
+/*
+ * This chip always returns (at least?) as much data as you ask for.
+ * I'm unsure what happens if you ask for less than a block. This should be
+ * looked into to ensure that a funny length read doesnt hose the controller.
+ */
+static void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
+{
+        struct mmc_data *data = host->data;
+        void *sg_virt;
+        unsigned short *buf;
+        unsigned int count;
+        unsigned long flags;
+
+        if ((host->chan_tx || host->chan_rx) && !host->force_pio) {
+                pr_err("PIO IRQ in DMA mode!\n");
+                return;
+        } else if (!data) {
+                pr_debug("Spurious PIO IRQ\n");
+                return;
+        }
+
+        sg_virt = tmio_mmc_kmap_atomic(host->sg_ptr, &flags);
+        buf = (unsigned short *)(sg_virt + host->sg_off);
+
+        count = host->sg_ptr->length - host->sg_off;
+        if (count > data->blksz)
+                count = data->blksz;
+
+        pr_debug("count: %08x offset: %08x flags %08x\n",
+                 count, host->sg_off, data->flags);
+
+        /* Transfer the data */
+        if (data->flags & MMC_DATA_READ)
+                sd_ctrl_read16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
+        else
+                sd_ctrl_write16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
+
+        host->sg_off += count;
+
+        tmio_mmc_kunmap_atomic(host->sg_ptr, &flags, sg_virt);
+
+        if (host->sg_off == host->sg_ptr->length)
+                tmio_mmc_next_sg(host);
+
+        return;
+}
+
+static void tmio_mmc_check_bounce_buffer(struct tmio_mmc_host *host)
+{
+        if (host->sg_ptr == &host->bounce_sg) {
+                unsigned long flags;
+                void *sg_vaddr = tmio_mmc_kmap_atomic(host->sg_orig, &flags);
+                memcpy(sg_vaddr, host->bounce_buf, host->bounce_sg.length);
+                tmio_mmc_kunmap_atomic(host->sg_orig, &flags, sg_vaddr);
+        }
+}
+
+/* needs to be called with host->lock held */
+void tmio_mmc_do_data_irq(struct tmio_mmc_host *host)
+{
+        struct mmc_data *data = host->data;
+        struct mmc_command *stop;
+
+        host->data = NULL;
+
+        if (!data) {
+                dev_warn(&host->pdev->dev, "Spurious data end IRQ\n");
+                return;
+        }
+        stop = data->stop;
+
+        /* FIXME - return correct transfer count on errors */
+        if (!data->error)
+                data->bytes_xfered = data->blocks * data->blksz;
+        else
+                data->bytes_xfered = 0;
+
+        pr_debug("Completed data request\n");
+
+        /*
+         * FIXME: other drivers allow an optional stop command of any given type
+         *        which we dont do, as the chip can auto generate them.
+         *        Perhaps we can be smarter about when to use auto CMD12 and
+         *        only issue the auto request when we know this is the desired
+         *        stop command, allowing fallback to the stop command the
+         *        upper layers expect. For now, we do what works.
+         */
+
+        if (data->flags & MMC_DATA_READ) {
+                if (host->chan_rx && !host->force_pio)
+                        tmio_mmc_check_bounce_buffer(host);
+                dev_dbg(&host->pdev->dev, "Complete Rx request %p\n",
+                        host->mrq);
+        } else {
+                dev_dbg(&host->pdev->dev, "Complete Tx request %p\n",
+                        host->mrq);
+        }
+
+        if (stop) {
+                if (stop->opcode == 12 && !stop->arg)
+                        sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x000);
+                else
+                        BUG();
+        }
+
+        tmio_mmc_finish_request(host);
+}
+
+static void tmio_mmc_data_irq(struct tmio_mmc_host *host)
+{
+        struct mmc_data *data;
+        spin_lock(&host->lock);
+        data = host->data;
+
+        if (!data)
+                goto out;
+
+        if (host->chan_tx && (data->flags & MMC_DATA_WRITE) && !host->force_pio) {
+                /*
+                 * Has all data been written out yet? Testing on SuperH showed,
+                 * that in most cases the first interrupt comes already with the
+                 * BUSY status bit clear, but on some operations, like mount or
+                 * in the beginning of a write / sync / umount, there is one
+                 * DATAEND interrupt with the BUSY bit set, in this cases
+                 * waiting for one more interrupt fixes the problem.
+                 */
+                if (!(sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_CMD_BUSY)) {
+                        tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_DATAEND);
+                        tasklet_schedule(&host->dma_complete);
+                }
+        } else if (host->chan_rx && (data->flags & MMC_DATA_READ) && !host->force_pio) {
+                tmio_mmc_disable_mmc_irqs(host, TMIO_STAT_DATAEND);
+                tasklet_schedule(&host->dma_complete);
+        } else {
+                tmio_mmc_do_data_irq(host);
+                tmio_mmc_disable_mmc_irqs(host, TMIO_MASK_READOP | TMIO_MASK_WRITEOP);
+        }
+out:
+        spin_unlock(&host->lock);
+}
+
+static void tmio_mmc_cmd_irq(struct tmio_mmc_host *host,
+        unsigned int stat)
+{
+        struct mmc_command *cmd = host->cmd;
+        int i, addr;
+
+        spin_lock(&host->lock);
+
+        if (!host->cmd) {
+                pr_debug("Spurious CMD irq\n");
+                goto out;
+        }
+
+        host->cmd = NULL;
+
+        /* This controller is sicker than the PXA one. Not only do we need to
+         * drop the top 8 bits of the first response word, we also need to
+         * modify the order of the response for short response command types.
+         */
+
+        for (i = 3, addr = CTL_RESPONSE ; i >= 0 ; i--, addr += 4)
+                cmd->resp[i] = sd_ctrl_read32(host, addr);
+
+        if (cmd->flags &  MMC_RSP_136) {
+                cmd->resp[0] = (cmd->resp[0] << 8) | (cmd->resp[1] >> 24);
+                cmd->resp[1] = (cmd->resp[1] << 8) | (cmd->resp[2] >> 24);
+                cmd->resp[2] = (cmd->resp[2] << 8) | (cmd->resp[3] >> 24);
+                cmd->resp[3] <<= 8;
+        } else if (cmd->flags & MMC_RSP_R3) {
+                cmd->resp[0] = cmd->resp[3];
+        }
+
+        if (stat & TMIO_STAT_CMDTIMEOUT)
+                cmd->error = -ETIMEDOUT;
+        else if (stat & TMIO_STAT_CRCFAIL && cmd->flags & MMC_RSP_CRC)
+                cmd->error = -EILSEQ;
+
+        /* If there is data to handle we enable data IRQs here, and
+         * we will ultimatley finish the request in the data_end handler.
+         * If theres no data or we encountered an error, finish now.
+         */
+        if (host->data && !cmd->error) {
+                if (host->data->flags & MMC_DATA_READ) {
+                        if (host->force_pio || !host->chan_rx)
+                                tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_READOP);
+                        else
+                                tasklet_schedule(&host->dma_issue);
+                } else {
+                        if (host->force_pio || !host->chan_tx)
+                                tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_WRITEOP);
+                        else
+                                tasklet_schedule(&host->dma_issue);
+                }
+        } else {
+                tmio_mmc_finish_request(host);
+        }
+
+out:
+        spin_unlock(&host->lock);
+}
+
+static irqreturn_t tmio_mmc_irq(int irq, void *devid)
+{
+        struct tmio_mmc_host *host = devid;
+        struct tmio_mmc_data *pdata = host->pdata;
+        unsigned int ireg, irq_mask, status;
+        unsigned int sdio_ireg, sdio_irq_mask, sdio_status;
+
+        pr_debug("MMC IRQ begin\n");
+
+        status = sd_ctrl_read32(host, CTL_STATUS);
+        irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
+        ireg = status & TMIO_MASK_IRQ & ~irq_mask;
+
+        sdio_ireg = 0;
+        if (!ireg && pdata->flags & TMIO_MMC_SDIO_IRQ) {
+                sdio_status = sd_ctrl_read16(host, CTL_SDIO_STATUS);
+                sdio_irq_mask = sd_ctrl_read16(host, CTL_SDIO_IRQ_MASK);
+                sdio_ireg = sdio_status & TMIO_SDIO_MASK_ALL & ~sdio_irq_mask;
+
+                sd_ctrl_write16(host, CTL_SDIO_STATUS, sdio_status & ~TMIO_SDIO_MASK_ALL);
+
+                if (sdio_ireg && !host->sdio_irq_enabled) {
+                        pr_warning("tmio_mmc: Spurious SDIO IRQ, disabling! 0x%04x 0x%04x 0x%04x\n",
+                                   sdio_status, sdio_irq_mask, sdio_ireg);
+                        tmio_mmc_enable_sdio_irq(host->mmc, 0);
+                        goto out;
+                }
+
+                if (host->mmc->caps & MMC_CAP_SDIO_IRQ &&
+                        sdio_ireg & TMIO_SDIO_STAT_IOIRQ)
+                        mmc_signal_sdio_irq(host->mmc);
+
+                if (sdio_ireg)
+                        goto out;
+        }
+
+        pr_debug_status(status);
+        pr_debug_status(ireg);
+
+        if (!ireg) {
+                tmio_mmc_disable_mmc_irqs(host, status & ~irq_mask);
+
+                pr_warning("tmio_mmc: Spurious irq, disabling! "
+                        "0x%08x 0x%08x 0x%08x\n", status, irq_mask, ireg);
+                pr_debug_status(status);
+
+                goto out;
+        }
+
+        while (ireg) {
+                /* Card insert / remove attempts */
+                if (ireg & (TMIO_STAT_CARD_INSERT | TMIO_STAT_CARD_REMOVE)) {
+                        tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_CARD_INSERT |
+                                TMIO_STAT_CARD_REMOVE);
+                        mmc_detect_change(host->mmc, msecs_to_jiffies(100));
+                }
+
+                /* CRC and other errors */
+/*              if (ireg & TMIO_STAT_ERR_IRQ)
+ *                      handled |= tmio_error_irq(host, irq, stat);
+ */
+
+                /* Command completion */
+                if (ireg & (TMIO_STAT_CMDRESPEND | TMIO_STAT_CMDTIMEOUT)) {
+                        tmio_mmc_ack_mmc_irqs(host,
+                                     TMIO_STAT_CMDRESPEND |
+                                     TMIO_STAT_CMDTIMEOUT);
+                        tmio_mmc_cmd_irq(host, status);
+                }
+
+                /* Data transfer */
+                if (ireg & (TMIO_STAT_RXRDY | TMIO_STAT_TXRQ)) {
+                        tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_RXRDY | TMIO_STAT_TXRQ);
+                        tmio_mmc_pio_irq(host);
+                }
+
+                /* Data transfer completion */
+                if (ireg & TMIO_STAT_DATAEND) {
+                        tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_DATAEND);
+                        tmio_mmc_data_irq(host);
+                }
+
+                /* Check status - keep going until we've handled it all */
+                status = sd_ctrl_read32(host, CTL_STATUS);
+                irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
+                ireg = status & TMIO_MASK_IRQ & ~irq_mask;
+
+                pr_debug("Status at end of loop: %08x\n", status);
+                pr_debug_status(status);
+        }
+        pr_debug("MMC IRQ end\n");
+
+out:
+        return IRQ_HANDLED;
+}
+
+static int tmio_mmc_start_data(struct tmio_mmc_host *host,
+        struct mmc_data *data)
+{
+        struct tmio_mmc_data *pdata = host->pdata;
+
+        pr_debug("setup data transfer: blocksize %08x  nr_blocks %d\n",
+                 data->blksz, data->blocks);
+
+        /* Some hardware cannot perform 2 byte requests in 4 bit mode */
+        if (host->mmc->ios.bus_width == MMC_BUS_WIDTH_4) {
+                int blksz_2bytes = pdata->flags & TMIO_MMC_BLKSZ_2BYTES;
+
+                if (data->blksz < 2 || (data->blksz < 4 && !blksz_2bytes)) {
+                        pr_err("%s: %d byte block unsupported in 4 bit mode\n",
+                               mmc_hostname(host->mmc), data->blksz);
+                        return -EINVAL;
+                }
+        }
+
+        tmio_mmc_init_sg(host, data);
+        host->data = data;
+
+        /* Set transfer length / blocksize */
+        sd_ctrl_write16(host, CTL_SD_XFER_LEN, data->blksz);
+        sd_ctrl_write16(host, CTL_XFER_BLK_COUNT, data->blocks);
+
+        tmio_mmc_start_dma(host, data);
+
+        return 0;
+}
+
+/* Process requests from the MMC layer */
+static void tmio_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        int ret;
+
+        if (host->mrq)
+                pr_debug("request not null\n");
+
+        host->last_req_ts = jiffies;
+        wmb();
+        host->mrq = mrq;
+
+        if (mrq->data) {
+                ret = tmio_mmc_start_data(host, mrq->data);
+                if (ret)
+                        goto fail;
+        }
+
+        ret = tmio_mmc_start_command(host, mrq->cmd);
+        if (!ret) {
+                schedule_delayed_work(&host->delayed_reset_work,
+                                      msecs_to_jiffies(2000));
+                return;
+        }
+
+fail:
+        host->mrq = NULL;
+        host->force_pio = false;
+        mrq->cmd->error = ret;
+        mmc_request_done(mmc, mrq);
+}
+
+/* Set MMC clock / power.
+ * Note: This controller uses a simple divider scheme therefore it cannot
+ * run a MMC card at full speed (20MHz). The max clock is 24MHz on SD, but as
+ * MMC wont run that fast, it has to be clocked at 12MHz which is the next
+ * slowest setting.
+ */
+static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+
+        if (ios->clock)
+                tmio_mmc_set_clock(host, ios->clock);
+
+        /* Power sequence - OFF -> UP -> ON */
+        if (ios->power_mode == MMC_POWER_OFF || !ios->clock) {
+                /* power down SD bus */
+                if (ios->power_mode == MMC_POWER_OFF && host->set_pwr)
+                        host->set_pwr(host->pdev, 0);
+                tmio_mmc_clk_stop(host);
+        } else if (ios->power_mode == MMC_POWER_UP) {
+                /* power up SD bus */
+                if (host->set_pwr)
+                        host->set_pwr(host->pdev, 1);
+        } else {
+                /* start bus clock */
+                tmio_mmc_clk_start(host);
+        }
+
+        switch (ios->bus_width) {
+        case MMC_BUS_WIDTH_1:
+                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
+        break;
+        case MMC_BUS_WIDTH_4:
+                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
+        break;
+        }
+
+        /* Let things settle. delay taken from winCE driver */
+        udelay(140);
+}
+
+static int tmio_mmc_get_ro(struct mmc_host *mmc)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct tmio_mmc_data *pdata = host->pdata;
+
+        return ((pdata->flags & TMIO_MMC_WRPROTECT_DISABLE) ||
+                !(sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_WRPROTECT));
+}
+
+static int tmio_mmc_get_cd(struct mmc_host *mmc)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct tmio_mmc_data *pdata = host->pdata;
+
+        if (!pdata->get_cd)
+                return -ENOSYS;
+        else
+                return pdata->get_cd(host->pdev);
+}
+
+static const struct mmc_host_ops tmio_mmc_ops = {
+        .request        = tmio_mmc_request,
+        .set_ios        = tmio_mmc_set_ios,
+        .get_ro         = tmio_mmc_get_ro,
+        .get_cd         = tmio_mmc_get_cd,
+        .enable_sdio_irq = tmio_mmc_enable_sdio_irq,
+};
+
+int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
+                                  struct platform_device *pdev,
+                                  struct tmio_mmc_data *pdata)
+{
+        struct tmio_mmc_host *_host;
+        struct mmc_host *mmc;
+        struct resource *res_ctl;
+        int ret;
+        u32 irq_mask = TMIO_MASK_CMD;
+
+        res_ctl = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res_ctl)
+                return -EINVAL;
+
+        mmc = mmc_alloc_host(sizeof(struct tmio_mmc_host), &pdev->dev);
+        if (!mmc)
+                return -ENOMEM;
+
+        _host = mmc_priv(mmc);
+        _host->pdata = pdata;
+        _host->mmc = mmc;
+        _host->pdev = pdev;
+        platform_set_drvdata(pdev, mmc);
+
+        _host->set_pwr = pdata->set_pwr;
+        _host->set_clk_div = pdata->set_clk_div;
+
+        /* SD control register space size is 0x200, 0x400 for bus_shift=1 */
+        _host->bus_shift = resource_size(res_ctl) >> 10;
+
+        _host->ctl = ioremap(res_ctl->start, resource_size(res_ctl));
+        if (!_host->ctl) {
+                ret = -ENOMEM;
+                goto host_free;
+        }
+
+        mmc->ops = &tmio_mmc_ops;
+        mmc->caps = MMC_CAP_4_BIT_DATA | pdata->capabilities;
+        mmc->f_max = pdata->hclk;
+        mmc->f_min = mmc->f_max / 512;
+        mmc->max_segs = 32;
+        mmc->max_blk_size = 512;
+        mmc->max_blk_count = (PAGE_CACHE_SIZE / mmc->max_blk_size) *
+                mmc->max_segs;
+        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
+        mmc->max_seg_size = mmc->max_req_size;
+        if (pdata->ocr_mask)
+                mmc->ocr_avail = pdata->ocr_mask;
+        else
+                mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+
+        tmio_mmc_clk_stop(_host);
+        tmio_mmc_reset(_host);
+
+        ret = platform_get_irq(pdev, 0);
+        if (ret < 0)
+                goto unmap_ctl;
+
+        _host->irq = ret;
+
+        tmio_mmc_disable_mmc_irqs(_host, TMIO_MASK_ALL);
+        if (pdata->flags & TMIO_MMC_SDIO_IRQ)
+                tmio_mmc_enable_sdio_irq(mmc, 0);
+
+        ret = request_irq(_host->irq, tmio_mmc_irq, IRQF_DISABLED |
+                IRQF_TRIGGER_FALLING, dev_name(&pdev->dev), _host);
+        if (ret)
+                goto unmap_ctl;
+
+        spin_lock_init(&_host->lock);
+
+        /* Init delayed work for request timeouts */
+        INIT_DELAYED_WORK(&_host->delayed_reset_work, tmio_mmc_reset_work);
+
+        /* See if we also get DMA */
+        tmio_mmc_request_dma(_host, pdata);
+
+        mmc_add_host(mmc);
+
+        /* Unmask the IRQs we want to know about */
+        if (!_host->chan_rx)
+                irq_mask |= TMIO_MASK_READOP;
+        if (!_host->chan_tx)
+                irq_mask |= TMIO_MASK_WRITEOP;
+
+        tmio_mmc_enable_mmc_irqs(_host, irq_mask);
+
+        *host = _host;
+
+        return 0;
+
+unmap_ctl:
+        iounmap(_host->ctl);
+host_free:
+        mmc_free_host(mmc);
+
+        return ret;
+}
+EXPORT_SYMBOL(tmio_mmc_host_probe);
+
+void tmio_mmc_host_remove(struct tmio_mmc_host *host)
+{
+        mmc_remove_host(host->mmc);
+        cancel_delayed_work_sync(&host->delayed_reset_work);
+        tmio_mmc_release_dma(host);
+        free_irq(host->irq, host);
+        iounmap(host->ctl);
+        mmc_free_host(host->mmc);
+}
+EXPORT_SYMBOL(tmio_mmc_host_remove);
+
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/via-sdmmc.c b/drivers/mmc/host/via-sdmmc.c
index 8c5b4881ccd6..4dfe2c02ea91 100644
--- a/drivers/mmc/host/via-sdmmc.c
+++ b/drivers/mmc/host/via-sdmmc.c
@@ -1087,14 +1087,13 @@ static int __devinit via_sd_probe(struct pci_dev *pcidev,
         struct mmc_host *mmc;
         struct via_crdr_mmc_host *sdhost;
         u32 base, len;
-        u8 rev, gatt;
+        u8  gatt;
         int ret;
 
-        pci_read_config_byte(pcidev, PCI_CLASS_REVISION, &rev);
         pr_info(DRV_NAME
                 ": VIA SDMMC controller found at %s [%04x:%04x] (rev %x)\n",
                 pci_name(pcidev), (int)pcidev->vendor, (int)pcidev->device,
-                (int)rev);
+                (int)pcidev->revision);
 
         ret = pci_enable_device(pcidev);
         if (ret)
diff --git a/drivers/net/bfin_mac.c b/drivers/net/bfin_mac.c
index 22abfb39d813..68d45ba2d9b9 100644
--- a/drivers/net/bfin_mac.c
+++ b/drivers/net/bfin_mac.c
@@ -1237,8 +1237,17 @@ static int bfin_mac_enable(struct phy_device *phydev)
 
         if (phydev->interface == PHY_INTERFACE_MODE_RMII) {
                 opmode |= RMII; /* For Now only 100MBit are supported */
-#if (defined(CONFIG_BF537) || defined(CONFIG_BF536)) && CONFIG_BF_REV_0_2
-                opmode |= TE;
+#if defined(CONFIG_BF537) || defined(CONFIG_BF536)
+                if (__SILICON_REVISION__ < 3) {
+                        /*
+                         * This isn't publicly documented (fun times!), but in
+                         * silicon <=0.2, the RX and TX pins are clocked together.
+                         * So in order to recv, we must enable the transmit side
+                         * as well.  This will cause a spurious TX interrupt too,
+                         * but we can easily consume that.
+                         */
+                        opmode |= TE;
+                }
 #endif
         }
 
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index d1865cc97313..8e6d618b5305 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -8317,7 +8317,7 @@ static const struct net_device_ops bnx2_netdev_ops = {
 #endif
 };
 
-static void inline vlan_features_add(struct net_device *dev, u32 flags)
+static inline void vlan_features_add(struct net_device *dev, u32 flags)
 {
         dev->vlan_features |= flags;
 }
diff --git a/drivers/net/can/c_can/c_can.c b/drivers/net/can/c_can/c_can.c
index 110eda01843c..31552959aed7 100644
--- a/drivers/net/can/c_can/c_can.c
+++ b/drivers/net/can/c_can/c_can.c
@@ -588,14 +588,9 @@ static void c_can_chip_config(struct net_device *dev)
 {
         struct c_can_priv *priv = netdev_priv(dev);
 
-        if (priv->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
-                /* disable automatic retransmission */
-                priv->write_reg(priv, &priv->regs->control,
-                                CONTROL_DISABLE_AR);
-        else
-                /* enable automatic retransmission */
-                priv->write_reg(priv, &priv->regs->control,
-                                CONTROL_ENABLE_AR);
+        /* enable automatic retransmission */
+        priv->write_reg(priv, &priv->regs->control,
+                        CONTROL_ENABLE_AR);
 
         if (priv->can.ctrlmode & (CAN_CTRLMODE_LISTENONLY &
                                         CAN_CTRLMODE_LOOPBACK)) {
@@ -704,7 +699,6 @@ static void c_can_do_tx(struct net_device *dev)
 
         for (/* nix */; (priv->tx_next - priv->tx_echo) > 0; priv->tx_echo++) {
                 msg_obj_no = get_tx_echo_msg_obj(priv);
-                c_can_inval_msg_object(dev, 0, msg_obj_no);
                 val = c_can_read_reg32(priv, &priv->regs->txrqst1);
                 if (!(val & (1 << msg_obj_no))) {
                         can_get_echo_skb(dev,
@@ -713,6 +707,7 @@ static void c_can_do_tx(struct net_device *dev)
                                         &priv->regs->ifregs[0].msg_cntrl)
                                         & IF_MCONT_DLC_MASK;
                         stats->tx_packets++;
+                        c_can_inval_msg_object(dev, 0, msg_obj_no);
                 }
         }
 
@@ -1112,8 +1107,7 @@ struct net_device *alloc_c_can_dev(void)
         priv->can.bittiming_const = &c_can_bittiming_const;
         priv->can.do_set_mode = c_can_set_mode;
         priv->can.do_get_berr_counter = c_can_get_berr_counter;
-        priv->can.ctrlmode_supported = CAN_CTRLMODE_ONE_SHOT |
-                                        CAN_CTRLMODE_LOOPBACK |
+        priv->can.ctrlmode_supported = CAN_CTRLMODE_LOOPBACK |
                                         CAN_CTRLMODE_LISTENONLY |
                                         CAN_CTRLMODE_BERR_REPORTING;
 
diff --git a/drivers/net/can/c_can/c_can_platform.c b/drivers/net/can/c_can/c_can_platform.c
index e629b961ae2d..cc90824f2c9c 100644
--- a/drivers/net/can/c_can/c_can_platform.c
+++ b/drivers/net/can/c_can/c_can_platform.c
@@ -73,7 +73,8 @@ static int __devinit c_can_plat_probe(struct platform_device *pdev)
         void __iomem *addr;
         struct net_device *dev;
         struct c_can_priv *priv;
-        struct resource *mem, *irq;
+        struct resource *mem;
+        int irq;
 #ifdef CONFIG_HAVE_CLK
         struct clk *clk;
 
@@ -88,8 +89,8 @@ static int __devinit c_can_plat_probe(struct platform_device *pdev)
 
         /* get the platform data */
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
-        if (!mem || (irq <= 0)) {
+        irq = platform_get_irq(pdev, 0);
+        if (!mem || irq <= 0) {
                 ret = -ENODEV;
                 goto exit_free_clk;
         }
@@ -117,7 +118,7 @@ static int __devinit c_can_plat_probe(struct platform_device *pdev)
 
         priv = netdev_priv(dev);
 
-        dev->irq = irq->start;
+        dev->irq = irq;
         priv->regs = addr;
 #ifdef CONFIG_HAVE_CLK
         priv->can.clock.freq = clk_get_rate(clk);
diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c
index 4d538a4e9d55..910893143295 100644
--- a/drivers/net/cxgb3/cxgb3_main.c
+++ b/drivers/net/cxgb3/cxgb3_main.c
@@ -1983,14 +1983,20 @@ static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
 {
         struct port_info *pi = netdev_priv(dev);
         struct adapter *adapter = pi->adapter;
-        struct qset_params *qsp = &adapter->params.sge.qset[0];
-        struct sge_qset *qs = &adapter->sge.qs[0];
+        struct qset_params *qsp;
+        struct sge_qset *qs;
+        int i;
 
         if (c->rx_coalesce_usecs * 10 > M_NEWTIMER)
                 return -EINVAL;
 
-        qsp->coalesce_usecs = c->rx_coalesce_usecs;
-        t3_update_qset_coalesce(qs, qsp);
+        for (i = 0; i < pi->nqsets; i++) {
+                qsp = &adapter->params.sge.qset[i];
+                qs = &adapter->sge.qs[i];
+                qsp->coalesce_usecs = c->rx_coalesce_usecs;
+                t3_update_qset_coalesce(qs, qsp);
+        }
+
         return 0;
 }
 
diff --git a/drivers/net/dm9000.c b/drivers/net/dm9000.c
index 317708113601..b7af5bab9937 100644
--- a/drivers/net/dm9000.c
+++ b/drivers/net/dm9000.c
@@ -621,9 +621,9 @@ static int dm9000_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
                 /* change in wol state, update IRQ state */
 
                 if (!dm->wake_state)
-                        set_irq_wake(dm->irq_wake, 1);
+                        irq_set_irq_wake(dm->irq_wake, 1);
                 else if (dm->wake_state & !opts)
-                        set_irq_wake(dm->irq_wake, 0);
+                        irq_set_irq_wake(dm->irq_wake, 0);
         }
 
         dm->wake_state = opts;
@@ -1424,13 +1424,13 @@ dm9000_probe(struct platform_device *pdev)
                 } else {
 
                         /* test to see if irq is really wakeup capable */
-                        ret = set_irq_wake(db->irq_wake, 1);
+                        ret = irq_set_irq_wake(db->irq_wake, 1);
                         if (ret) {
                                 dev_err(db->dev, "irq %d cannot set wakeup (%d)\n",
                                         db->irq_wake, ret);
                                 ret = 0;
                         } else {
-                                set_irq_wake(db->irq_wake, 0);
+                                irq_set_irq_wake(db->irq_wake, 0);
                                 db->wake_supported = 1;
                         }
                 }
diff --git a/drivers/net/jme.c b/drivers/net/jme.c
index f690474f4409..994c80939c7a 100644
--- a/drivers/net/jme.c
+++ b/drivers/net/jme.c
@@ -273,7 +273,7 @@ jme_clear_pm(struct jme_adapter *jme)
 {
         jwrite32(jme, JME_PMCS, 0xFFFF0000 | jme->reg_pmcs);
         pci_set_power_state(jme->pdev, PCI_D0);
-        pci_enable_wake(jme->pdev, PCI_D0, false);
+        device_set_wakeup_enable(&jme->pdev->dev, false);
 }
 
 static int
@@ -2538,6 +2538,8 @@ jme_set_wol(struct net_device *netdev,
 
         jwrite32(jme, JME_PMCS, jme->reg_pmcs);
 
+        device_set_wakeup_enable(&jme->pdev->dev, jme->reg_pmcs);
+
         return 0;
 }
 
@@ -3172,9 +3174,9 @@ jme_shutdown(struct pci_dev *pdev)
 }
 
 #ifdef CONFIG_PM
-static int
-jme_suspend(struct pci_dev *pdev, pm_message_t state)
+static int jme_suspend(struct device *dev)
 {
+        struct pci_dev *pdev = to_pci_dev(dev);
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct jme_adapter *jme = netdev_priv(netdev);
 
@@ -3206,22 +3208,18 @@ jme_suspend(struct pci_dev *pdev, pm_message_t state)
         tasklet_hi_enable(&jme->rxclean_task);
         tasklet_hi_enable(&jme->rxempty_task);
 
-        pci_save_state(pdev);
         jme_powersave_phy(jme);
-        pci_enable_wake(jme->pdev, PCI_D3hot, true);
-        pci_set_power_state(pdev, PCI_D3hot);
 
         return 0;
 }
 
-static int
-jme_resume(struct pci_dev *pdev)
+static int jme_resume(struct device *dev)
 {
+        struct pci_dev *pdev = to_pci_dev(dev);
         struct net_device *netdev = pci_get_drvdata(pdev);
         struct jme_adapter *jme = netdev_priv(netdev);
 
-        jme_clear_pm(jme);
-        pci_restore_state(pdev);
+        jwrite32(jme, JME_PMCS, 0xFFFF0000 | jme->reg_pmcs);
 
         jme_phy_on(jme);
         if (test_bit(JME_FLAG_SSET, &jme->flags))
@@ -3238,6 +3236,13 @@ jme_resume(struct pci_dev *pdev)
 
         return 0;
 }
+
+static SIMPLE_DEV_PM_OPS(jme_pm_ops, jme_suspend, jme_resume);
+#define JME_PM_OPS (&jme_pm_ops)
+
+#else
+
+#define JME_PM_OPS NULL
 #endif
 
 static DEFINE_PCI_DEVICE_TABLE(jme_pci_tbl) = {
@@ -3251,11 +3256,8 @@ static struct pci_driver jme_driver = {
         .id_table       = jme_pci_tbl,
         .probe          = jme_init_one,
         .remove         = __devexit_p(jme_remove_one),
-#ifdef CONFIG_PM
-        .suspend        = jme_suspend,
-        .resume         = jme_resume,
-#endif /* CONFIG_PM */
         .shutdown       = jme_shutdown,
+        .driver.pm      = JME_PM_OPS,
 };
 
 static int __init
diff --git a/drivers/net/ksz884x.c b/drivers/net/ksz884x.c
index 540a8dcbcc46..7f7d5708a658 100644
--- a/drivers/net/ksz884x.c
+++ b/drivers/net/ksz884x.c
@@ -4898,7 +4898,7 @@ static netdev_tx_t netdev_tx(struct sk_buff *skb, struct net_device *dev)
                                 goto unlock;
                         }
                         skb_copy_and_csum_dev(org_skb, skb->data);
-                        org_skb->ip_summed = 0;
+                        org_skb->ip_summed = CHECKSUM_NONE;
                         skb->len = org_skb->len;
                         copy_old_skb(org_skb, skb);
                 }
diff --git a/drivers/net/mlx4/en_netdev.c b/drivers/net/mlx4/en_netdev.c
index 5762ebde4455..4f158baa0246 100644
--- a/drivers/net/mlx4/en_netdev.c
+++ b/drivers/net/mlx4/en_netdev.c
@@ -742,6 +742,9 @@ int mlx4_en_start_port(struct net_device *dev)
                                   0, MLX4_PROT_ETH))
                 mlx4_warn(mdev, "Failed Attaching Broadcast\n");
 
+        /* Must redo promiscuous mode setup. */
+        priv->flags &= ~(MLX4_EN_FLAG_PROMISC | MLX4_EN_FLAG_MC_PROMISC);
+
         /* Schedule multicast task to populate multicast list */
         queue_work(mdev->workqueue, &priv->mcast_task);
 
diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index 1f4e8680a96a..673dc600c891 100644
--- a/drivers/net/myri10ge/myri10ge.c
+++ b/drivers/net/myri10ge/myri10ge.c
@@ -1312,17 +1312,26 @@ myri10ge_unmap_rx_page(struct pci_dev *pdev,
                                  * page into an skb */
 
 static inline int
-myri10ge_rx_done(struct myri10ge_slice_state *ss, struct myri10ge_rx_buf *rx,
-                 int bytes, int len, __wsum csum)
+myri10ge_rx_done(struct myri10ge_slice_state *ss, int len, __wsum csum,
+                 int lro_enabled)
 {
         struct myri10ge_priv *mgp = ss->mgp;
         struct sk_buff *skb;
         struct skb_frag_struct rx_frags[MYRI10GE_MAX_FRAGS_PER_FRAME];
-        int i, idx, hlen, remainder;
+        struct myri10ge_rx_buf *rx;
+        int i, idx, hlen, remainder, bytes;
         struct pci_dev *pdev = mgp->pdev;
         struct net_device *dev = mgp->dev;
         u8 *va;
 
+        if (len <= mgp->small_bytes) {
+                rx = &ss->rx_small;
+                bytes = mgp->small_bytes;
+        } else {
+                rx = &ss->rx_big;
+                bytes = mgp->big_bytes;
+        }
+
         len += MXGEFW_PAD;
         idx = rx->cnt & rx->mask;
         va = page_address(rx->info[idx].page) + rx->info[idx].page_offset;
@@ -1341,7 +1350,7 @@ myri10ge_rx_done(struct myri10ge_slice_state *ss, struct myri10ge_rx_buf *rx,
                 remainder -= MYRI10GE_ALLOC_SIZE;
         }
 
-        if (dev->features & NETIF_F_LRO) {
+        if (lro_enabled) {
                 rx_frags[0].page_offset += MXGEFW_PAD;
                 rx_frags[0].size -= MXGEFW_PAD;
                 len -= MXGEFW_PAD;
@@ -1463,7 +1472,7 @@ myri10ge_clean_rx_done(struct myri10ge_slice_state *ss, int budget)
 {
         struct myri10ge_rx_done *rx_done = &ss->rx_done;
         struct myri10ge_priv *mgp = ss->mgp;
-        struct net_device *netdev = mgp->dev;
+
         unsigned long rx_bytes = 0;
         unsigned long rx_packets = 0;
         unsigned long rx_ok;
@@ -1474,18 +1483,18 @@ myri10ge_clean_rx_done(struct myri10ge_slice_state *ss, int budget)
         u16 length;
         __wsum checksum;
 
+        /*
+         * Prevent compiler from generating more than one ->features memory
+         * access to avoid theoretical race condition with functions that
+         * change NETIF_F_LRO flag at runtime.
+         */
+        bool lro_enabled = ACCESS_ONCE(mgp->dev->features) & NETIF_F_LRO;
+
         while (rx_done->entry[idx].length != 0 && work_done < budget) {
                 length = ntohs(rx_done->entry[idx].length);
                 rx_done->entry[idx].length = 0;
                 checksum = csum_unfold(rx_done->entry[idx].checksum);
-                if (length <= mgp->small_bytes)
-                        rx_ok = myri10ge_rx_done(ss, &ss->rx_small,
-                                                 mgp->small_bytes,
-                                                 length, checksum);
-                else
-                        rx_ok = myri10ge_rx_done(ss, &ss->rx_big,
-                                                 mgp->big_bytes,
-                                                 length, checksum);
+                rx_ok = myri10ge_rx_done(ss, length, checksum, lro_enabled);
                 rx_packets += rx_ok;
                 rx_bytes += rx_ok * (unsigned long)length;
                 cnt++;
@@ -1497,7 +1506,7 @@ myri10ge_clean_rx_done(struct myri10ge_slice_state *ss, int budget)
         ss->stats.rx_packets += rx_packets;
         ss->stats.rx_bytes += rx_bytes;
 
-        if (netdev->features & NETIF_F_LRO)
+        if (lro_enabled)
                 lro_flush_all(&rx_done->lro_mgr);
 
         /* restock receive rings if needed */
diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
index 653d308e0f5d..3bdcc803ec68 100644
--- a/drivers/net/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/netxen/netxen_nic_ethtool.c
@@ -871,7 +871,7 @@ static int netxen_nic_set_flags(struct net_device *netdev, u32 data)
         struct netxen_adapter *adapter = netdev_priv(netdev);
         int hw_lro;
 
-        if (data & ~ETH_FLAG_LRO)
+        if (ethtool_invalid_flags(netdev, data, ETH_FLAG_LRO))
                 return -EINVAL;
 
         if (!(adapter->capabilities & NX_FW_CAPABILITY_HW_LRO))
diff --git a/drivers/net/qlcnic/qlcnic_ethtool.c b/drivers/net/qlcnic/qlcnic_ethtool.c
index 4c14510e2a87..45b2755d6cba 100644
--- a/drivers/net/qlcnic/qlcnic_ethtool.c
+++ b/drivers/net/qlcnic/qlcnic_ethtool.c
@@ -1003,7 +1003,7 @@ static int qlcnic_set_flags(struct net_device *netdev, u32 data)
         struct qlcnic_adapter *adapter = netdev_priv(netdev);
         int hw_lro;
 
-        if (data & ~ETH_FLAG_LRO)
+        if (ethtool_invalid_flags(netdev, data, ETH_FLAG_LRO))
                 return -EINVAL;
 
         if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO))
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index 2ad6364103ea..356e74d20b80 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -6726,7 +6726,7 @@ static int s2io_ethtool_set_flags(struct net_device *dev, u32 data)
         int rc = 0;
         int changed = 0;
 
-        if (data & ~ETH_FLAG_LRO)
+        if (ethtool_invalid_flags(dev, data, ETH_FLAG_LRO))
                 return -EINVAL;
 
         if (data & ETH_FLAG_LRO) {
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index ebec88882c3b..73c942d85f07 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -48,9 +48,9 @@
 #include <net/ip.h>
 
 #include <asm/system.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/byteorder.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 #ifdef CONFIG_SPARC
 #include <asm/idprom.h>
@@ -13118,7 +13118,7 @@ done:
 
 static struct pci_dev * __devinit tg3_find_peer(struct tg3 *);
 
-static void inline vlan_features_add(struct net_device *dev, unsigned long flags)
+static inline void vlan_features_add(struct net_device *dev, unsigned long flags)
 {
         dev->vlan_features |= flags;
 }
diff --git a/drivers/net/vmxnet3/vmxnet3_ethtool.c b/drivers/net/vmxnet3/vmxnet3_ethtool.c
index 81254be85b92..51f2ef142a5b 100644
--- a/drivers/net/vmxnet3/vmxnet3_ethtool.c
+++ b/drivers/net/vmxnet3/vmxnet3_ethtool.c
@@ -304,8 +304,8 @@ vmxnet3_set_flags(struct net_device *netdev, u32 data)
         u8 lro_present = (netdev->features & NETIF_F_LRO) == 0 ? 0 : 1;
         unsigned long flags;
 
-        if (data & ~ETH_FLAG_LRO)
-                return -EOPNOTSUPP;
+        if (ethtool_invalid_flags(netdev, data, ETH_FLAG_LRO))
+                return -EINVAL;
 
         if (lro_requested ^ lro_present) {
                 /* toggle the LRO feature*/
diff --git a/drivers/net/vxge/vxge-ethtool.c b/drivers/net/vxge/vxge-ethtool.c
index 1dd3a21b3a43..c5eb034107fd 100644
--- a/drivers/net/vxge/vxge-ethtool.c
+++ b/drivers/net/vxge/vxge-ethtool.c
@@ -1117,8 +1117,8 @@ static int vxge_set_flags(struct net_device *dev, u32 data)
         struct vxgedev *vdev = netdev_priv(dev);
         enum vxge_hw_status status;
 
-        if (data & ~ETH_FLAG_RXHASH)
-                return -EOPNOTSUPP;
+        if (ethtool_invalid_flags(dev, data, ETH_FLAG_RXHASH))
+                return -EINVAL;
 
         if (!!(data & ETH_FLAG_RXHASH) == vdev->devh->config.rth_en)
                 return 0;
diff --git a/drivers/net/wireless/p54/p54spi.c b/drivers/net/wireless/p54/p54spi.c
index 18d24b7b1e34..7ecc0bda57b3 100644
--- a/drivers/net/wireless/p54/p54spi.c
+++ b/drivers/net/wireless/p54/p54spi.c
@@ -649,8 +649,7 @@ static int __devinit p54spi_probe(struct spi_device *spi)
                 goto err_free_common;
         }
 
-        set_irq_type(gpio_to_irq(p54spi_gpio_irq),
-                     IRQ_TYPE_EDGE_RISING);
+        irq_set_irq_type(gpio_to_irq(p54spi_gpio_irq), IRQ_TYPE_EDGE_RISING);
 
         disable_irq(gpio_to_irq(p54spi_gpio_irq));
 
diff --git a/drivers/net/wireless/wl1251/sdio.c b/drivers/net/wireless/wl1251/sdio.c
index d550b5e68d3c..f51a0241a440 100644
--- a/drivers/net/wireless/wl1251/sdio.c
+++ b/drivers/net/wireless/wl1251/sdio.c
@@ -265,7 +265,7 @@ static int wl1251_sdio_probe(struct sdio_func *func,
                         goto disable;
                 }
 
-                set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
+                irq_set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
                 disable_irq(wl->irq);
 
                 wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq;
diff --git a/drivers/net/wireless/wl1251/spi.c b/drivers/net/wireless/wl1251/spi.c
index ac872b38960f..af6448c4d3e2 100644
--- a/drivers/net/wireless/wl1251/spi.c
+++ b/drivers/net/wireless/wl1251/spi.c
@@ -286,7 +286,7 @@ static int __devinit wl1251_spi_probe(struct spi_device *spi)
                 goto out_free;
         }
 
-        set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
+        irq_set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
 
         disable_irq(wl->irq);
 
diff --git a/drivers/parisc/eisa.c b/drivers/parisc/eisa.c
index deeec32a5803..103095bbe8c0 100644
--- a/drivers/parisc/eisa.c
+++ b/drivers/parisc/eisa.c
@@ -340,7 +340,7 @@ static int __init eisa_probe(struct parisc_device *dev)
         /* Reserve IRQ2 */
         setup_irq(2, &irq2_action);
         for (i = 0; i < 16; i++) {
-                set_irq_chip_and_handler(i, &eisa_interrupt_type,
+                irq_set_chip_and_handler(i, &eisa_interrupt_type,
                                          handle_simple_irq);
         }
         
diff --git a/drivers/parisc/gsc.c b/drivers/parisc/gsc.c
index ef31080cf591..1bab5a2cd359 100644
--- a/drivers/parisc/gsc.c
+++ b/drivers/parisc/gsc.c
@@ -152,8 +152,8 @@ int gsc_assign_irq(struct irq_chip *type, void *data)
         if (irq > GSC_IRQ_MAX)
                 return NO_IRQ;
 
-        set_irq_chip_and_handler(irq, type, handle_simple_irq);
-        set_irq_chip_data(irq, data);
+        irq_set_chip_and_handler(irq, type, handle_simple_irq);
+        irq_set_chip_data(irq, data);
 
         return irq++;
 }
diff --git a/drivers/parisc/superio.c b/drivers/parisc/superio.c
index a4d8ff66a639..e3b76d409dee 100644
--- a/drivers/parisc/superio.c
+++ b/drivers/parisc/superio.c
@@ -355,7 +355,8 @@ int superio_fixup_irq(struct pci_dev *pcidev)
 #endif
 
         for (i = 0; i < 16; i++) {
-                set_irq_chip_and_handler(i, &superio_interrupt_type, handle_simple_irq);
+                irq_set_chip_and_handler(i, &superio_interrupt_type,
+                                         handle_simple_irq);
         }
 
         /*
diff --git a/drivers/pci/dmar.c b/drivers/pci/dmar.c
index 09933eb9126b..12e02bf92c4a 100644
--- a/drivers/pci/dmar.c
+++ b/drivers/pci/dmar.c
@@ -1226,7 +1226,7 @@ const char *dmar_get_fault_reason(u8 fault_reason, int *fault_type)
 
 void dmar_msi_unmask(struct irq_data *data)
 {
-        struct intel_iommu *iommu = irq_data_get_irq_data(data);
+        struct intel_iommu *iommu = irq_data_get_irq_handler_data(data);
         unsigned long flag;
 
         /* unmask it */
@@ -1240,7 +1240,7 @@ void dmar_msi_unmask(struct irq_data *data)
 void dmar_msi_mask(struct irq_data *data)
 {
         unsigned long flag;
-        struct intel_iommu *iommu = irq_data_get_irq_data(data);
+        struct intel_iommu *iommu = irq_data_get_irq_handler_data(data);
 
         /* mask it */
         spin_lock_irqsave(&iommu->register_lock, flag);
@@ -1252,7 +1252,7 @@ void dmar_msi_mask(struct irq_data *data)
 
 void dmar_msi_write(int irq, struct msi_msg *msg)
 {
-        struct intel_iommu *iommu = get_irq_data(irq);
+        struct intel_iommu *iommu = irq_get_handler_data(irq);
         unsigned long flag;
 
         spin_lock_irqsave(&iommu->register_lock, flag);
@@ -1264,7 +1264,7 @@ void dmar_msi_write(int irq, struct msi_msg *msg)
 
 void dmar_msi_read(int irq, struct msi_msg *msg)
 {
-        struct intel_iommu *iommu = get_irq_data(irq);
+        struct intel_iommu *iommu = irq_get_handler_data(irq);
         unsigned long flag;
 
         spin_lock_irqsave(&iommu->register_lock, flag);
@@ -1382,12 +1382,12 @@ int dmar_set_interrupt(struct intel_iommu *iommu)
                 return -EINVAL;
         }
 
-        set_irq_data(irq, iommu);
+        irq_set_handler_data(irq, iommu);
         iommu->irq = irq;
 
         ret = arch_setup_dmar_msi(irq);
         if (ret) {
-                set_irq_data(irq, NULL);
+                irq_set_handler_data(irq, NULL);
                 iommu->irq = 0;
                 destroy_irq(irq);
                 return ret;
diff --git a/drivers/pci/htirq.c b/drivers/pci/htirq.c
index 834842aa5bbf..db057b6fe0c8 100644
--- a/drivers/pci/htirq.c
+++ b/drivers/pci/htirq.c
@@ -34,7 +34,7 @@ struct ht_irq_cfg {
 
 void write_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg)
 {
-        struct ht_irq_cfg *cfg = get_irq_data(irq);
+        struct ht_irq_cfg *cfg = irq_get_handler_data(irq);
         unsigned long flags;
         spin_lock_irqsave(&ht_irq_lock, flags);
         if (cfg->msg.address_lo != msg->address_lo) {
@@ -53,13 +53,13 @@ void write_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg)
 
 void fetch_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg)
 {
-        struct ht_irq_cfg *cfg = get_irq_data(irq);
+        struct ht_irq_cfg *cfg = irq_get_handler_data(irq);
         *msg = cfg->msg;
 }
 
 void mask_ht_irq(struct irq_data *data)
 {
-        struct ht_irq_cfg *cfg = irq_data_get_irq_data(data);
+        struct ht_irq_cfg *cfg = irq_data_get_irq_handler_data(data);
         struct ht_irq_msg msg = cfg->msg;
 
         msg.address_lo |= 1;
@@ -68,7 +68,7 @@ void mask_ht_irq(struct irq_data *data)
 
 void unmask_ht_irq(struct irq_data *data)
 {
-        struct ht_irq_cfg *cfg = irq_data_get_irq_data(data);
+        struct ht_irq_cfg *cfg = irq_data_get_irq_handler_data(data);
         struct ht_irq_msg msg = cfg->msg;
 
         msg.address_lo &= ~1;
@@ -126,7 +126,7 @@ int __ht_create_irq(struct pci_dev *dev, int idx, ht_irq_update_t *update)
                 kfree(cfg);
                 return -EBUSY;
         }
-        set_irq_data(irq, cfg);
+        irq_set_handler_data(irq, cfg);
 
         if (arch_setup_ht_irq(irq, dev) < 0) {
                 ht_destroy_irq(irq);
@@ -162,9 +162,9 @@ void ht_destroy_irq(unsigned int irq)
 {
         struct ht_irq_cfg *cfg;
 
-        cfg = get_irq_data(irq);
-        set_irq_chip(irq, NULL);
-        set_irq_data(irq, NULL);
+        cfg = irq_get_handler_data(irq);
+        irq_set_chip(irq, NULL);
+        irq_set_handler_data(irq, NULL);
         destroy_irq(irq);
 
         kfree(cfg);
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index a4115f1afe1f..7da3bef60d87 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -1206,7 +1206,7 @@ void free_dmar_iommu(struct intel_iommu *iommu)
                 iommu_disable_translation(iommu);
 
         if (iommu->irq) {
-                set_irq_data(iommu->irq, NULL);
+                irq_set_handler_data(iommu->irq, NULL);
                 /* This will mask the irq */
                 free_irq(iommu->irq, iommu);
                 destroy_irq(iommu->irq);
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index ec87cd66f3eb..a22557b20283 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -50,7 +50,7 @@ static DEFINE_SPINLOCK(irq_2_ir_lock);
 
 static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
 {
-        struct irq_cfg *cfg = get_irq_chip_data(irq);
+        struct irq_cfg *cfg = irq_get_chip_data(irq);
         return cfg ? &cfg->irq_2_iommu : NULL;
 }
 
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 44b0aeee83e5..2f10328bf661 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -236,7 +236,7 @@ void __read_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 
 void read_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
-        struct msi_desc *entry = get_irq_msi(irq);
+        struct msi_desc *entry = irq_get_msi_desc(irq);
 
         __read_msi_msg(entry, msg);
 }
@@ -253,7 +253,7 @@ void __get_cached_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 
 void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
-        struct msi_desc *entry = get_irq_msi(irq);
+        struct msi_desc *entry = irq_get_msi_desc(irq);
 
         __get_cached_msi_msg(entry, msg);
 }
@@ -297,7 +297,7 @@ void __write_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 
 void write_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
-        struct msi_desc *entry = get_irq_msi(irq);
+        struct msi_desc *entry = irq_get_msi_desc(irq);
 
         __write_msi_msg(entry, msg);
 }
@@ -354,7 +354,7 @@ static void __pci_restore_msi_state(struct pci_dev *dev)
         if (!dev->msi_enabled)
                 return;
 
-        entry = get_irq_msi(dev->irq);
+        entry = irq_get_msi_desc(dev->irq);
         pos = entry->msi_attrib.pos;
 
         pci_intx_for_msi(dev, 0);
@@ -519,7 +519,7 @@ static void msix_program_entries(struct pci_dev *dev,
                                                 PCI_MSIX_ENTRY_VECTOR_CTRL;
 
                 entries[i].vector = entry->irq;
-                set_irq_msi(entry->irq, entry);
+                irq_set_msi_desc(entry->irq, entry);
                 entry->masked = readl(entry->mask_base + offset);
                 msix_mask_irq(entry, 1);
                 i++;
diff --git a/drivers/pcmcia/bfin_cf_pcmcia.c b/drivers/pcmcia/bfin_cf_pcmcia.c
index eae9cbe37a3e..49221395101e 100644
--- a/drivers/pcmcia/bfin_cf_pcmcia.c
+++ b/drivers/pcmcia/bfin_cf_pcmcia.c
@@ -235,7 +235,7 @@ static int __devinit bfin_cf_probe(struct platform_device *pdev)
         cf->irq = irq;
         cf->socket.pci_irq = irq;
 
-        set_irq_type(irq, IRQF_TRIGGER_LOW);
+        irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
 
         io_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         attr_mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
diff --git a/drivers/pcmcia/db1xxx_ss.c b/drivers/pcmcia/db1xxx_ss.c
index 27575e6378a1..01757f18a208 100644
--- a/drivers/pcmcia/db1xxx_ss.c
+++ b/drivers/pcmcia/db1xxx_ss.c
@@ -181,7 +181,7 @@ static int db1x_pcmcia_setup_irqs(struct db1x_pcmcia_sock *sock)
                 /* all other (older) Db1x00 boards use a GPIO to show
                  * card detection status:  use both-edge triggers.
                  */
-                set_irq_type(sock->insert_irq, IRQ_TYPE_EDGE_BOTH);
+                irq_set_irq_type(sock->insert_irq, IRQ_TYPE_EDGE_BOTH);
                 ret = request_irq(sock->insert_irq, db1000_pcmcia_cdirq,
                                   0, "pcmcia_carddetect", sock);
 
diff --git a/drivers/pcmcia/sa1100_nanoengine.c b/drivers/pcmcia/sa1100_nanoengine.c
index 3d2652e2f5ae..93b9c9ba57c3 100644
--- a/drivers/pcmcia/sa1100_nanoengine.c
+++ b/drivers/pcmcia/sa1100_nanoengine.c
@@ -86,7 +86,7 @@ static int nanoengine_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
         GPDR &= ~nano_skts[i].input_pins;
         GPDR |= nano_skts[i].output_pins;
         GPCR = nano_skts[i].clear_outputs;
-        set_irq_type(nano_skts[i].transition_pins, IRQ_TYPE_EDGE_BOTH);
+        irq_set_irq_type(nano_skts[i].transition_pins, IRQ_TYPE_EDGE_BOTH);
         skt->socket.pci_irq = nano_skts[i].pci_irq;
 
         return soc_pcmcia_request_irqs(skt,
diff --git a/drivers/pcmcia/soc_common.c b/drivers/pcmcia/soc_common.c
index 5a9a392eacdf..768f9572a8c8 100644
--- a/drivers/pcmcia/soc_common.c
+++ b/drivers/pcmcia/soc_common.c
@@ -155,11 +155,11 @@ static int soc_common_pcmcia_config_skt(
                  */
                 if (skt->irq_state != 1 && state->io_irq) {
                         skt->irq_state = 1;
-                        set_irq_type(skt->socket.pci_irq,
-                                IRQ_TYPE_EDGE_FALLING);
+                        irq_set_irq_type(skt->socket.pci_irq,
+                                         IRQ_TYPE_EDGE_FALLING);
                 } else if (skt->irq_state == 1 && state->io_irq == 0) {
                         skt->irq_state = 0;
-                        set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE);
+                        irq_set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE);
                 }
 
                 skt->cs_state = *state;
@@ -537,7 +537,7 @@ int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
                                   IRQF_DISABLED, irqs[i].str, skt);
                 if (res)
                         break;
-                set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
+                irq_set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
         }
 
         if (res) {
@@ -570,7 +570,7 @@ void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
 
         for (i = 0; i < nr; i++)
                 if (irqs[i].sock == skt->nr)
-                        set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
+                        irq_set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
 }
 EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
 
@@ -581,8 +581,8 @@ void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
 
         for (i = 0; i < nr; i++)
                 if (irqs[i].sock == skt->nr) {
-                        set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_RISING);
-                        set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_BOTH);
+                        irq_set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_RISING);
+                        irq_set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_BOTH);
                 }
 }
 EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
diff --git a/drivers/pcmcia/xxs1500_ss.c b/drivers/pcmcia/xxs1500_ss.c
index 3b67a1b6a197..379f4218857d 100644
--- a/drivers/pcmcia/xxs1500_ss.c
+++ b/drivers/pcmcia/xxs1500_ss.c
@@ -274,7 +274,7 @@ static int __devinit xxs1500_pcmcia_probe(struct platform_device *pdev)
          * edge detector.
          */
         irq = gpio_to_irq(GPIO_CDA);
-        set_irq_type(irq, IRQ_TYPE_EDGE_BOTH);
+        irq_set_irq_type(irq, IRQ_TYPE_EDGE_BOTH);
         ret = request_irq(irq, cdirq, 0, "pcmcia_carddetect", sock);
         if (ret) {
                 dev_err(&pdev->dev, "cannot setup cd irq\n");
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 222dfb737b11..2ee442c2a5db 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -101,6 +101,19 @@ config DELL_WMI
           To compile this driver as a module, choose M here: the module will
           be called dell-wmi.
 
+config DELL_WMI_AIO
+        tristate "WMI Hotkeys for Dell All-In-One series"
+        depends on ACPI_WMI
+        depends on INPUT
+        select INPUT_SPARSEKMAP
+        ---help---
+          Say Y here if you want to support WMI-based hotkeys on Dell
+          All-In-One machines.
+
+          To compile this driver as a module, choose M here: the module will
+          be called dell-wmi.
+
+
 config FUJITSU_LAPTOP
         tristate "Fujitsu Laptop Extras"
         depends on ACPI
@@ -438,23 +451,53 @@ config EEEPC_LAPTOP
           Bluetooth, backlight and allows powering on/off some other
           devices.
 
-          If you have an Eee PC laptop, say Y or M here.
+          If you have an Eee PC laptop, say Y or M here. If this driver
+          doesn't work on your Eee PC, try eeepc-wmi instead.
 
-config EEEPC_WMI
-        tristate "Eee PC WMI Hotkey Driver (EXPERIMENTAL)"
+config ASUS_WMI
+        tristate "ASUS WMI Driver (EXPERIMENTAL)"
         depends on ACPI_WMI
         depends on INPUT
+        depends on HWMON
         depends on EXPERIMENTAL
         depends on BACKLIGHT_CLASS_DEVICE
         depends on RFKILL || RFKILL = n
+        depends on HOTPLUG_PCI
         select INPUT_SPARSEKMAP
         select LEDS_CLASS
         select NEW_LEDS
         ---help---
-          Say Y here if you want to support WMI-based hotkeys on Eee PC laptops.
+          Say Y here if you have a WMI aware Asus laptop (like Eee PCs or new
+          Asus Notebooks).
 
           To compile this driver as a module, choose M here: the module will
-          be called eeepc-wmi.
+          be called asus-wmi.
+
+config ASUS_NB_WMI
+        tristate "Asus Notebook WMI Driver (EXPERIMENTAL)"
+        depends on ASUS_WMI
+        ---help---
+          This is a driver for newer Asus notebooks. It adds extra features
+          like wireless radio and bluetooth control, leds, hotkeys, backlight...
+
+          For more informations, see
+          <file:Documentation/ABI/testing/sysfs-platform-asus-wmi>
+
+          If you have an ACPI-WMI compatible Asus Notebook, say Y or M
+          here.
+
+config EEEPC_WMI
+        tristate "Eee PC WMI Driver (EXPERIMENTAL)"
+        depends on ASUS_WMI
+        ---help---
+          This is a driver for newer Eee PC laptops. It adds extra features
+          like wireless radio and bluetooth control, leds, hotkeys, backlight...
+
+          For more informations, see
+          <file:Documentation/ABI/testing/sysfs-platform-asus-wmi>
+
+          If you have an ACPI-WMI compatible Eee PC laptop (>= 1000), say Y or M
+          here.
 
 config ACPI_WMI
         tristate "WMI"
@@ -616,6 +659,21 @@ config GPIO_INTEL_PMIC
           Say Y here to support GPIO via the SCU IPC interface
           on Intel MID platforms.
 
+config INTEL_MID_POWER_BUTTON
+        tristate "power button driver for Intel MID platforms"
+        depends on INTEL_SCU_IPC && INPUT
+        help
+          This driver handles the power button on the Intel MID platforms.
+
+          If unsure, say N.
+
+config INTEL_MFLD_THERMAL
+       tristate "Thermal driver for Intel Medfield platform"
+       depends on INTEL_SCU_IPC && THERMAL
+       help
+         Say Y here to enable thermal driver support for the  Intel Medfield
+         platform.
+
 config RAR_REGISTER
         bool "Restricted Access Region Register Driver"
         depends on PCI && X86_MRST
@@ -672,4 +730,26 @@ config XO1_RFKILL
           Support for enabling/disabling the WLAN interface on the OLPC XO-1
           laptop.
 
+config XO15_EBOOK
+        tristate "OLPC XO-1.5 ebook switch"
+        depends on ACPI && INPUT
+        ---help---
+          Support for the ebook switch on the OLPC XO-1.5 laptop.
+
+          This switch is triggered as the screen is rotated and folded down to
+          convert the device into ebook form.
+
+config SAMSUNG_LAPTOP
+        tristate "Samsung Laptop driver"
+        depends on RFKILL && BACKLIGHT_CLASS_DEVICE && X86
+        ---help---
+          This module implements a driver for a wide range of different
+          Samsung laptops.  It offers control over the different
+          function keys, wireless LED, LCD backlight level, and
+          sometimes provides a "performance_control" sysfs file to allow
+          the performance level of the laptop to be changed.
+
+          To compile this driver as a module, choose M here: the module
+          will be called samsung-laptop.
+
 endif # X86_PLATFORM_DEVICES
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index 299aefb3e74c..029e8861d086 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -3,6 +3,8 @@
 # x86 Platform-Specific Drivers
 #
 obj-$(CONFIG_ASUS_LAPTOP)       += asus-laptop.o
+obj-$(CONFIG_ASUS_WMI)          += asus-wmi.o
+obj-$(CONFIG_ASUS_NB_WMI)       += asus-nb-wmi.o
 obj-$(CONFIG_EEEPC_LAPTOP)      += eeepc-laptop.o
 obj-$(CONFIG_EEEPC_WMI)         += eeepc-wmi.o
 obj-$(CONFIG_MSI_LAPTOP)        += msi-laptop.o
@@ -10,6 +12,7 @@ obj-$(CONFIG_ACPI_CMPC)		+= classmate-laptop.o
 obj-$(CONFIG_COMPAL_LAPTOP)     += compal-laptop.o
 obj-$(CONFIG_DELL_LAPTOP)       += dell-laptop.o
 obj-$(CONFIG_DELL_WMI)          += dell-wmi.o
+obj-$(CONFIG_DELL_WMI_AIO)      += dell-wmi-aio.o
 obj-$(CONFIG_ACER_WMI)          += acer-wmi.o
 obj-$(CONFIG_ACERHDF)           += acerhdf.o
 obj-$(CONFIG_HP_ACCEL)          += hp_accel.o
@@ -29,9 +32,13 @@ obj-$(CONFIG_TOPSTAR_LAPTOP)	+= topstar-laptop.o
 obj-$(CONFIG_ACPI_TOSHIBA)      += toshiba_acpi.o
 obj-$(CONFIG_TOSHIBA_BT_RFKILL) += toshiba_bluetooth.o
 obj-$(CONFIG_INTEL_SCU_IPC)     += intel_scu_ipc.o
-obj-$(CONFIG_INTEL_SCU_IPC_UTIL)+= intel_scu_ipcutil.o
+obj-$(CONFIG_INTEL_SCU_IPC_UTIL) += intel_scu_ipcutil.o
+obj-$(CONFIG_INTEL_MFLD_THERMAL) += intel_mid_thermal.o
 obj-$(CONFIG_RAR_REGISTER)      += intel_rar_register.o
 obj-$(CONFIG_INTEL_IPS)         += intel_ips.o
 obj-$(CONFIG_GPIO_INTEL_PMIC)   += intel_pmic_gpio.o
 obj-$(CONFIG_XO1_RFKILL)        += xo1-rfkill.o
+obj-$(CONFIG_XO15_EBOOK)        += xo15-ebook.o
 obj-$(CONFIG_IBM_RTL)           += ibm_rtl.o
+obj-$(CONFIG_SAMSUNG_LAPTOP)    += samsung-laptop.o
+obj-$(CONFIG_INTEL_MFLD_THERMAL)        += intel_mid_thermal.o
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index c9784705f6ac..5ea6c3477d17 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -22,6 +22,8 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -46,12 +48,6 @@ MODULE_AUTHOR("Carlos Corbacho");
 MODULE_DESCRIPTION("Acer Laptop WMI Extras Driver");
 MODULE_LICENSE("GPL");
 
-#define ACER_LOGPREFIX "acer-wmi: "
-#define ACER_ERR KERN_ERR ACER_LOGPREFIX
-#define ACER_NOTICE KERN_NOTICE ACER_LOGPREFIX
-#define ACER_INFO KERN_INFO ACER_LOGPREFIX
-#define ACER_WARNING KERN_WARNING ACER_LOGPREFIX
-
 /*
  * Magic Number
  * Meaning is unknown - this number is required for writing to ACPI for AMW0
@@ -84,7 +80,7 @@ MODULE_LICENSE("GPL");
 #define AMW0_GUID1              "67C3371D-95A3-4C37-BB61-DD47B491DAAB"
 #define AMW0_GUID2              "431F16ED-0C2B-444C-B267-27DEB140CF9C"
 #define WMID_GUID1              "6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3"
-#define WMID_GUID2              "95764E09-FB56-4e83-B31A-37761F60994A"
+#define WMID_GUID2              "95764E09-FB56-4E83-B31A-37761F60994A"
 #define WMID_GUID3              "61EF69EA-865C-4BC3-A502-A0DEBA0CB531"
 
 /*
@@ -93,7 +89,7 @@ MODULE_LICENSE("GPL");
 #define ACERWMID_EVENT_GUID "676AA15E-6A47-4D9F-A2CC-1E6D18D14026"
 
 MODULE_ALIAS("wmi:67C3371D-95A3-4C37-BB61-DD47B491DAAB");
-MODULE_ALIAS("wmi:6AF4F258-B401-42fd-BE91-3D4AC2D7C0D3");
+MODULE_ALIAS("wmi:6AF4F258-B401-42Fd-BE91-3D4AC2D7C0D3");
 MODULE_ALIAS("wmi:676AA15E-6A47-4D9F-A2CC-1E6D18D14026");
 
 enum acer_wmi_event_ids {
@@ -108,7 +104,7 @@ static const struct key_entry acer_wmi_keymap[] = {
         {KE_KEY, 0x23, {KEY_PROG3} },    /* P_Key */
         {KE_KEY, 0x24, {KEY_PROG4} },    /* Social networking_Key */
         {KE_KEY, 0x64, {KEY_SWITCHVIDEOMODE} }, /* Display Switch */
-        {KE_KEY, 0x82, {KEY_F22} },      /* Touch Pad On/Off */
+        {KE_KEY, 0x82, {KEY_TOUCHPAD_TOGGLE} }, /* Touch Pad On/Off */
         {KE_END, 0}
 };
 
@@ -221,6 +217,7 @@ struct acer_debug {
 static struct rfkill *wireless_rfkill;
 static struct rfkill *bluetooth_rfkill;
 static struct rfkill *threeg_rfkill;
+static bool rfkill_inited;
 
 /* Each low-level interface must define at least some of the following */
 struct wmi_interface {
@@ -845,7 +842,7 @@ static void type_aa_dmi_decode(const struct dmi_header *header, void *dummy)
         has_type_aa = true;
         type_aa = (struct hotkey_function_type_aa *) header;
 
-        printk(ACER_INFO "Function bitmap for Communication Button: 0x%x\n",
+        pr_info("Function bitmap for Communication Button: 0x%x\n",
                 type_aa->commun_func_bitmap);
 
         if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_WIRELESS)
@@ -991,6 +988,7 @@ static int __devinit acer_led_init(struct device *dev)
 
 static void acer_led_exit(void)
 {
+        set_u32(LED_OFF, ACER_CAP_MAILLED);
         led_classdev_unregister(&mail_led);
 }
 
@@ -1036,7 +1034,7 @@ static int __devinit acer_backlight_init(struct device *dev)
         bd = backlight_device_register("acer-wmi", dev, NULL, &acer_bl_ops,
                                        &props);
         if (IS_ERR(bd)) {
-                printk(ACER_ERR "Could not register Acer backlight device\n");
+                pr_err("Could not register Acer backlight device\n");
                 acer_backlight_device = NULL;
                 return PTR_ERR(bd);
         }
@@ -1083,8 +1081,7 @@ static acpi_status wmid3_get_device_status(u32 *value, u16 device)
                 return AE_ERROR;
         }
         if (obj->buffer.length != 8) {
-                printk(ACER_WARNING "Unknown buffer length %d\n",
-                        obj->buffer.length);
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return AE_ERROR;
         }
@@ -1093,7 +1090,7 @@ static acpi_status wmid3_get_device_status(u32 *value, u16 device)
         kfree(obj);
 
         if (return_value.error_code || return_value.ec_return_value)
-                printk(ACER_WARNING "Get Device Status failed: "
+                pr_warning("Get Device Status failed: "
                         "0x%x - 0x%x\n", return_value.error_code,
                         return_value.ec_return_value);
         else
@@ -1161,9 +1158,13 @@ static int acer_rfkill_set(void *data, bool blocked)
 {
         acpi_status status;
         u32 cap = (unsigned long)data;
-        status = set_u32(!blocked, cap);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
+
+        if (rfkill_inited) {
+                status = set_u32(!blocked, cap);
+                if (ACPI_FAILURE(status))
+                        return -ENODEV;
+        }
+
         return 0;
 }
 
@@ -1187,14 +1188,16 @@ static struct rfkill *acer_rfkill_register(struct device *dev,
                 return ERR_PTR(-ENOMEM);
 
         status = get_device_status(&state, cap);
-        if (ACPI_SUCCESS(status))
-                rfkill_init_sw_state(rfkill_dev, !state);
 
         err = rfkill_register(rfkill_dev);
         if (err) {
                 rfkill_destroy(rfkill_dev);
                 return ERR_PTR(err);
         }
+
+        if (ACPI_SUCCESS(status))
+                rfkill_set_sw_state(rfkill_dev, !state);
+
         return rfkill_dev;
 }
 
@@ -1229,14 +1232,19 @@ static int acer_rfkill_init(struct device *dev)
                 }
         }
 
-        schedule_delayed_work(&acer_rfkill_work, round_jiffies_relative(HZ));
+        rfkill_inited = true;
+
+        if (ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID))
+                schedule_delayed_work(&acer_rfkill_work,
+                        round_jiffies_relative(HZ));
 
         return 0;
 }
 
 static void acer_rfkill_exit(void)
 {
-        cancel_delayed_work_sync(&acer_rfkill_work);
+        if (ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID))
+                cancel_delayed_work_sync(&acer_rfkill_work);
 
         rfkill_unregister(wireless_rfkill);
         rfkill_destroy(wireless_rfkill);
@@ -1309,7 +1317,7 @@ static void acer_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(ACER_WARNING "bad event status 0x%x\n", status);
+                pr_warning("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -1318,14 +1326,12 @@ static void acer_wmi_notify(u32 value, void *context)
         if (!obj)
                 return;
         if (obj->type != ACPI_TYPE_BUFFER) {
-                printk(ACER_WARNING "Unknown response received %d\n",
-                        obj->type);
+                pr_warning("Unknown response received %d\n", obj->type);
                 kfree(obj);
                 return;
         }
         if (obj->buffer.length != 8) {
-                printk(ACER_WARNING "Unknown buffer length %d\n",
-                        obj->buffer.length);
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return;
         }
@@ -1335,13 +1341,26 @@ static void acer_wmi_notify(u32 value, void *context)
 
         switch (return_value.function) {
         case WMID_HOTKEY_EVENT:
+                if (return_value.device_state) {
+                        u16 device_state = return_value.device_state;
+                        pr_debug("deivces states: 0x%x\n", device_state);
+                        if (has_cap(ACER_CAP_WIRELESS))
+                                rfkill_set_sw_state(wireless_rfkill,
+                                !(device_state & ACER_WMID3_GDS_WIRELESS));
+                        if (has_cap(ACER_CAP_BLUETOOTH))
+                                rfkill_set_sw_state(bluetooth_rfkill,
+                                !(device_state & ACER_WMID3_GDS_BLUETOOTH));
+                        if (has_cap(ACER_CAP_THREEG))
+                                rfkill_set_sw_state(threeg_rfkill,
+                                !(device_state & ACER_WMID3_GDS_THREEG));
+                }
                 if (!sparse_keymap_report_event(acer_wmi_input_dev,
                                 return_value.key_num, 1, true))
-                        printk(ACER_WARNING "Unknown key number - 0x%x\n",
+                        pr_warning("Unknown key number - 0x%x\n",
                                 return_value.key_num);
                 break;
         default:
-                printk(ACER_WARNING "Unknown function number - %d - %d\n",
+                pr_warning("Unknown function number - %d - %d\n",
                         return_value.function, return_value.key_num);
                 break;
         }
@@ -1370,8 +1389,7 @@ wmid3_set_lm_mode(struct lm_input_params *params,
                 return AE_ERROR;
         }
         if (obj->buffer.length != 4) {
-                printk(ACER_WARNING "Unknown buffer length %d\n",
-                       obj->buffer.length);
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return AE_ERROR;
         }
@@ -1396,11 +1414,11 @@ static int acer_wmi_enable_ec_raw(void)
         status = wmid3_set_lm_mode(&params, &return_value);
 
         if (return_value.error_code || return_value.ec_return_value)
-                printk(ACER_WARNING "Enabling EC raw mode failed: "
+                pr_warning("Enabling EC raw mode failed: "
                        "0x%x - 0x%x\n", return_value.error_code,
                        return_value.ec_return_value);
         else
-                printk(ACER_INFO "Enabled EC raw mode");
+                pr_info("Enabled EC raw mode");
 
         return status;
 }
@@ -1419,7 +1437,7 @@ static int acer_wmi_enable_lm(void)
         status = wmid3_set_lm_mode(&params, &return_value);
 
         if (return_value.error_code || return_value.ec_return_value)
-                printk(ACER_WARNING "Enabling Launch Manager failed: "
+                pr_warning("Enabling Launch Manager failed: "
                        "0x%x - 0x%x\n", return_value.error_code,
                        return_value.ec_return_value);
 
@@ -1553,6 +1571,7 @@ pm_message_t state)
 
         if (has_cap(ACER_CAP_MAILLED)) {
                 get_u32(&value, ACER_CAP_MAILLED);
+                set_u32(LED_OFF, ACER_CAP_MAILLED);
                 data->mailled = value;
         }
 
@@ -1580,6 +1599,17 @@ static int acer_platform_resume(struct platform_device *device)
         return 0;
 }
 
+static void acer_platform_shutdown(struct platform_device *device)
+{
+        struct acer_data *data = &interface->data;
+
+        if (!data)
+                return;
+
+        if (has_cap(ACER_CAP_MAILLED))
+                set_u32(LED_OFF, ACER_CAP_MAILLED);
+}
+
 static struct platform_driver acer_platform_driver = {
         .driver = {
                 .name = "acer-wmi",
@@ -1589,6 +1619,7 @@ static struct platform_driver acer_platform_driver = {
         .remove = acer_platform_remove,
         .suspend = acer_platform_suspend,
         .resume = acer_platform_resume,
+        .shutdown = acer_platform_shutdown,
 };
 
 static struct platform_device *acer_platform_device;
@@ -1636,7 +1667,7 @@ static int create_debugfs(void)
 {
         interface->debug.root = debugfs_create_dir("acer-wmi", NULL);
         if (!interface->debug.root) {
-                printk(ACER_ERR "Failed to create debugfs directory");
+                pr_err("Failed to create debugfs directory");
                 return -ENOMEM;
         }
 
@@ -1657,11 +1688,10 @@ static int __init acer_wmi_init(void)
 {
         int err;
 
-        printk(ACER_INFO "Acer Laptop ACPI-WMI Extras\n");
+        pr_info("Acer Laptop ACPI-WMI Extras\n");
 
         if (dmi_check_system(acer_blacklist)) {
-                printk(ACER_INFO "Blacklisted hardware detected - "
-                                "not loading\n");
+                pr_info("Blacklisted hardware detected - not loading\n");
                 return -ENODEV;
         }
 
@@ -1678,12 +1708,11 @@ static int __init acer_wmi_init(void)
 
         if (wmi_has_guid(WMID_GUID2) && interface) {
                 if (ACPI_FAILURE(WMID_set_capabilities())) {
-                        printk(ACER_ERR "Unable to detect available WMID "
-                                        "devices\n");
+                        pr_err("Unable to detect available WMID devices\n");
                         return -ENODEV;
                 }
         } else if (!wmi_has_guid(WMID_GUID2) && interface) {
-                printk(ACER_ERR "No WMID device detection method found\n");
+                pr_err("No WMID device detection method found\n");
                 return -ENODEV;
         }
 
@@ -1691,8 +1720,7 @@ static int __init acer_wmi_init(void)
                 interface = &AMW0_interface;
 
                 if (ACPI_FAILURE(AMW0_set_capabilities())) {
-                        printk(ACER_ERR "Unable to detect available AMW0 "
-                                        "devices\n");
+                        pr_err("Unable to detect available AMW0 devices\n");
                         return -ENODEV;
                 }
         }
@@ -1701,8 +1729,7 @@ static int __init acer_wmi_init(void)
                 AMW0_find_mailled();
 
         if (!interface) {
-                printk(ACER_INFO "No or unsupported WMI interface, unable to "
-                                "load\n");
+                pr_err("No or unsupported WMI interface, unable to load\n");
                 return -ENODEV;
         }
 
@@ -1710,22 +1737,22 @@ static int __init acer_wmi_init(void)
 
         if (acpi_video_backlight_support() && has_cap(ACER_CAP_BRIGHTNESS)) {
                 interface->capability &= ~ACER_CAP_BRIGHTNESS;
-                printk(ACER_INFO "Brightness must be controlled by "
+                pr_info("Brightness must be controlled by "
                        "generic video driver\n");
         }
 
         if (wmi_has_guid(WMID_GUID3)) {
                 if (ec_raw_mode) {
                         if (ACPI_FAILURE(acer_wmi_enable_ec_raw())) {
-                                printk(ACER_ERR "Cannot enable EC raw mode\n");
+                                pr_err("Cannot enable EC raw mode\n");
                                 return -ENODEV;
                         }
                 } else if (ACPI_FAILURE(acer_wmi_enable_lm())) {
-                        printk(ACER_ERR "Cannot enable Launch Manager mode\n");
+                        pr_err("Cannot enable Launch Manager mode\n");
                         return -ENODEV;
                 }
         } else if (ec_raw_mode) {
-                printk(ACER_INFO "No WMID EC raw mode enable method\n");
+                pr_info("No WMID EC raw mode enable method\n");
         }
 
         if (wmi_has_guid(ACERWMID_EVENT_GUID)) {
@@ -1736,7 +1763,7 @@ static int __init acer_wmi_init(void)
 
         err = platform_driver_register(&acer_platform_driver);
         if (err) {
-                printk(ACER_ERR "Unable to register platform driver.\n");
+                pr_err("Unable to register platform driver.\n");
                 goto error_platform_register;
         }
 
@@ -1791,7 +1818,7 @@ static void __exit acer_wmi_exit(void)
         platform_device_unregister(acer_platform_device);
         platform_driver_unregister(&acer_platform_driver);
 
-        printk(ACER_INFO "Acer Laptop WMI Extras unloaded\n");
+        pr_info("Acer Laptop WMI Extras unloaded\n");
         return;
 }
 
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index 5a6f7d7575d6..c53b3ff7978a 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -29,7 +29,7 @@
  *  John Belmonte  - ACPI code for Toshiba laptop was a good starting point.
  *  Eric Burghard  - LED display support for W1N
  *  Josh Green     - Light Sens support
- *  Thomas Tuttle  - His first patch for led support was very helpfull
+ *  Thomas Tuttle  - His first patch for led support was very helpful
  *  Sam Lin        - GPS support
  */
 
@@ -50,6 +50,7 @@
 #include <linux/input/sparse-keymap.h>
 #include <linux/rfkill.h>
 #include <linux/slab.h>
+#include <linux/dmi.h>
 #include <acpi/acpi_drivers.h>
 #include <acpi/acpi_bus.h>
 
@@ -157,46 +158,9 @@ MODULE_PARM_DESC(wwan_status, "Set the wireless status on boot "
 #define METHOD_BRIGHTNESS_SET   "SPLV"
 #define METHOD_BRIGHTNESS_GET   "GPLV"
 
-/* Backlight */
-static acpi_handle lcd_switch_handle;
-static char *lcd_switch_paths[] = {
-  "\\_SB.PCI0.SBRG.EC0._Q10",   /* All new models */
-  "\\_SB.PCI0.ISA.EC0._Q10",    /* A1x */
-  "\\_SB.PCI0.PX40.ECD0._Q10",  /* L3C */
-  "\\_SB.PCI0.PX40.EC0.Q10",    /* M1A */
-  "\\_SB.PCI0.LPCB.EC0._Q10",   /* P30 */
-  "\\_SB.PCI0.LPCB.EC0._Q0E", /* P30/P35 */
-  "\\_SB.PCI0.PX40.Q10",        /* S1x */
-  "\\Q10"};             /* A2x, L2D, L3D, M2E */
-
 /* Display */
 #define METHOD_SWITCH_DISPLAY   "SDSP"
 
-static acpi_handle display_get_handle;
-static char *display_get_paths[] = {
-  /* A6B, A6K A6R A7D F3JM L4R M6R A3G M6A M6V VX-1 V6J V6V W3Z */
-  "\\_SB.PCI0.P0P1.VGA.GETD",
-  /* A3E A4K, A4D A4L A6J A7J A8J Z71V M9V S5A M5A z33A W1Jc W2V G1 */
-  "\\_SB.PCI0.P0P2.VGA.GETD",
-  /* A6V A6Q */
-  "\\_SB.PCI0.P0P3.VGA.GETD",
-  /* A6T, A6M */
-  "\\_SB.PCI0.P0PA.VGA.GETD",
-  /* L3C */
-  "\\_SB.PCI0.PCI1.VGAC.NMAP",
-  /* Z96F */
-  "\\_SB.PCI0.VGA.GETD",
-  /* A2D */
-  "\\ACTD",
-  /* A4G Z71A W1N W5A W5F M2N M3N M5N M6N S1N S5N */
-  "\\ADVG",
-  /* P30 */
-  "\\DNXT",
-  /* A2H D1 L2D L3D L3H L2E L5D L5C M1A M2E L4L W3V */
-  "\\INFB",
-  /* A3F A6F A3N A3L M6N W3N W6A */
-  "\\SSTE"};
-
 #define METHOD_ALS_CONTROL      "ALSC" /* Z71A Z71V */
 #define METHOD_ALS_LEVEL        "ALSL" /* Z71A Z71V */
 
@@ -246,7 +210,6 @@ struct asus_laptop {
 
         int wireless_status;
         bool have_rsts;
-        int lcd_state;
 
         struct rfkill *gps_rfkill;
 
@@ -559,48 +522,6 @@ error:
 /*
  * Backlight device
  */
-static int asus_lcd_status(struct asus_laptop *asus)
-{
-        return asus->lcd_state;
-}
-
-static int asus_lcd_set(struct asus_laptop *asus, int value)
-{
-        int lcd = 0;
-        acpi_status status = 0;
-
-        lcd = !!value;
-
-        if (lcd == asus_lcd_status(asus))
-                return 0;
-
-        if (!lcd_switch_handle)
-                return -ENODEV;
-
-        status = acpi_evaluate_object(lcd_switch_handle,
-                                      NULL, NULL, NULL);
-
-        if (ACPI_FAILURE(status)) {
-                pr_warning("Error switching LCD\n");
-                return -ENODEV;
-        }
-
-        asus->lcd_state = lcd;
-        return 0;
-}
-
-static void lcd_blank(struct asus_laptop *asus, int blank)
-{
-        struct backlight_device *bd = asus->backlight_device;
-
-        asus->lcd_state = (blank == FB_BLANK_UNBLANK);
-
-        if (bd) {
-                bd->props.power = blank;
-                backlight_update_status(bd);
-        }
-}
-
 static int asus_read_brightness(struct backlight_device *bd)
 {
         struct asus_laptop *asus = bl_get_data(bd);
@@ -628,16 +549,9 @@ static int asus_set_brightness(struct backlight_device *bd, int value)
 
 static int update_bl_status(struct backlight_device *bd)
 {
-        struct asus_laptop *asus = bl_get_data(bd);
-        int rv;
         int value = bd->props.brightness;
 
-        rv = asus_set_brightness(bd, value);
-        if (rv)
-                return rv;
-
-        value = (bd->props.power == FB_BLANK_UNBLANK) ? 1 : 0;
-        return asus_lcd_set(asus, value);
+        return asus_set_brightness(bd, value);
 }
 
 static const struct backlight_ops asusbl_ops = {
@@ -661,8 +575,7 @@ static int asus_backlight_init(struct asus_laptop *asus)
         struct backlight_properties props;
 
         if (acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_GET, NULL) ||
-            acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_SET, NULL) ||
-            !lcd_switch_handle)
+            acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_SET, NULL))
                 return 0;
 
         memset(&props, 0, sizeof(struct backlight_properties));
@@ -971,41 +884,6 @@ static void asus_set_display(struct asus_laptop *asus, int value)
         return;
 }
 
-static int read_display(struct asus_laptop *asus)
-{
-        unsigned long long value = 0;
-        acpi_status rv = AE_OK;
-
-        /*
-         * In most of the case, we know how to set the display, but sometime
-         * we can't read it
-         */
-        if (display_get_handle) {
-                rv = acpi_evaluate_integer(display_get_handle, NULL,
-                                           NULL, &value);
-                if (ACPI_FAILURE(rv))
-                        pr_warning("Error reading display status\n");
-        }
-
-        value &= 0x0F; /* needed for some models, shouldn't hurt others */
-
-        return value;
-}
-
-/*
- * Now, *this* one could be more user-friendly, but so far, no-one has
- * complained. The significance of bits is the same as in store_disp()
- */
-static ssize_t show_disp(struct device *dev,
-                         struct device_attribute *attr, char *buf)
-{
-        struct asus_laptop *asus = dev_get_drvdata(dev);
-
-        if (!display_get_handle)
-                return -ENODEV;
-        return sprintf(buf, "%d\n", read_display(asus));
-}
-
 /*
  * Experimental support for display switching. As of now: 1 should activate
  * the LCD output, 2 should do for CRT, 4 for TV-Out and 8 for DVI.
@@ -1247,15 +1125,6 @@ static void asus_acpi_notify(struct acpi_device *device, u32 event)
         struct asus_laptop *asus = acpi_driver_data(device);
         u16 count;
 
-        /*
-         * We need to tell the backlight device when the backlight power is
-         * switched
-         */
-        if (event == ATKD_LCD_ON)
-                lcd_blank(asus, FB_BLANK_UNBLANK);
-        else if (event == ATKD_LCD_OFF)
-                lcd_blank(asus, FB_BLANK_POWERDOWN);
-
         /* TODO Find a better way to handle events count. */
         count = asus->event_count[event % 128]++;
         acpi_bus_generate_proc_event(asus->device, event, count);
@@ -1282,7 +1151,7 @@ static DEVICE_ATTR(bluetooth, S_IRUGO | S_IWUSR,
                    show_bluetooth, store_bluetooth);
 static DEVICE_ATTR(wimax, S_IRUGO | S_IWUSR, show_wimax, store_wimax);
 static DEVICE_ATTR(wwan, S_IRUGO | S_IWUSR, show_wwan, store_wwan);
-static DEVICE_ATTR(display, S_IRUGO | S_IWUSR, show_disp, store_disp);
+static DEVICE_ATTR(display, S_IWUSR, NULL, store_disp);
 static DEVICE_ATTR(ledd, S_IRUGO | S_IWUSR, show_ledd, store_ledd);
 static DEVICE_ATTR(ls_level, S_IRUGO | S_IWUSR, show_lslvl, store_lslvl);
 static DEVICE_ATTR(ls_switch, S_IRUGO | S_IWUSR, show_lssw, store_lssw);
@@ -1393,26 +1262,6 @@ static struct platform_driver platform_driver = {
         }
 };
 
-static int asus_handle_init(char *name, acpi_handle * handle,
-                            char **paths, int num_paths)
-{
-        int i;
-        acpi_status status;
-
-        for (i = 0; i < num_paths; i++) {
-                status = acpi_get_handle(NULL, paths[i], handle);
-                if (ACPI_SUCCESS(status))
-                        return 0;
-        }
-
-        *handle = NULL;
-        return -ENODEV;
-}
-
-#define ASUS_HANDLE_INIT(object)                                        \
-        asus_handle_init(#object, &object##_handle, object##_paths,     \
-                         ARRAY_SIZE(object##_paths))
-
 /*
  * This function is used to initialize the context with right values. In this
  * method, we can make all the detection we want, and modify the asus_laptop
@@ -1498,10 +1347,6 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
         if (!acpi_check_handle(asus->handle, METHOD_WL_STATUS, NULL))
                 asus->have_rsts = true;
 
-        /* Scheduled for removal */
-        ASUS_HANDLE_INIT(lcd_switch);
-        ASUS_HANDLE_INIT(display_get);
-
         kfree(model);
 
         return AE_OK;
@@ -1553,10 +1398,23 @@ static int __devinit asus_acpi_init(struct asus_laptop *asus)
                 asus_als_level(asus, asus->light_level);
         }
 
-        asus->lcd_state = 1; /* LCD should be on when the module load */
         return result;
 }
 
+static void __devinit asus_dmi_check(void)
+{
+        const char *model;
+
+        model = dmi_get_system_info(DMI_PRODUCT_NAME);
+        if (!model)
+                return;
+
+        /* On L1400B WLED control the sound card, don't mess with it ... */
+        if (strncmp(model, "L1400B", 6) == 0) {
+                wlan_status = -1;
+        }
+}
+
 static bool asus_device_present;
 
 static int __devinit asus_acpi_add(struct acpi_device *device)
@@ -1575,6 +1433,8 @@ static int __devinit asus_acpi_add(struct acpi_device *device)
         device->driver_data = asus;
         asus->device = device;
 
+        asus_dmi_check();
+
         result = asus_acpi_init(asus);
         if (result)
                 goto fail_platform;
diff --git a/drivers/platform/x86/asus-nb-wmi.c b/drivers/platform/x86/asus-nb-wmi.c
new file mode 100644
index 000000000000..0580d99b0798
--- /dev/null
+++ b/drivers/platform/x86/asus-nb-wmi.c
@@ -0,0 +1,98 @@
+/*
+ * Asus Notebooks WMI hotkey driver
+ *
+ * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ *
+ *  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 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; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+
+#include "asus-wmi.h"
+
+#define ASUS_NB_WMI_FILE        "asus-nb-wmi"
+
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>");
+MODULE_DESCRIPTION("Asus Notebooks WMI Hotkey Driver");
+MODULE_LICENSE("GPL");
+
+#define ASUS_NB_WMI_EVENT_GUID  "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
+
+MODULE_ALIAS("wmi:"ASUS_NB_WMI_EVENT_GUID);
+
+static const struct key_entry asus_nb_wmi_keymap[] = {
+        { KE_KEY, 0x30, { KEY_VOLUMEUP } },
+        { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
+        { KE_KEY, 0x32, { KEY_MUTE } },
+        { KE_KEY, 0x33, { KEY_DISPLAYTOGGLE } }, /* LCD on */
+        { KE_KEY, 0x34, { KEY_DISPLAY_OFF } }, /* LCD off */
+        { KE_KEY, 0x40, { KEY_PREVIOUSSONG } },
+        { KE_KEY, 0x41, { KEY_NEXTSONG } },
+        { KE_KEY, 0x43, { KEY_STOPCD } },
+        { KE_KEY, 0x45, { KEY_PLAYPAUSE } },
+        { KE_KEY, 0x4c, { KEY_MEDIA } },
+        { KE_KEY, 0x50, { KEY_EMAIL } },
+        { KE_KEY, 0x51, { KEY_WWW } },
+        { KE_KEY, 0x55, { KEY_CALC } },
+        { KE_KEY, 0x5C, { KEY_F15 } },  /* Power Gear key */
+        { KE_KEY, 0x5D, { KEY_WLAN } },
+        { KE_KEY, 0x5E, { KEY_WLAN } },
+        { KE_KEY, 0x5F, { KEY_WLAN } },
+        { KE_KEY, 0x60, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x61, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x62, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x63, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x6B, { KEY_TOUCHPAD_TOGGLE } },
+        { KE_KEY, 0x7E, { KEY_BLUETOOTH } },
+        { KE_KEY, 0x7D, { KEY_BLUETOOTH } },
+        { KE_KEY, 0x82, { KEY_CAMERA } },
+        { KE_KEY, 0x88, { KEY_RFKILL  } },
+        { KE_KEY, 0x8A, { KEY_PROG1 } },
+        { KE_KEY, 0x95, { KEY_MEDIA } },
+        { KE_KEY, 0x99, { KEY_PHONE } },
+        { KE_KEY, 0xb5, { KEY_CALC } },
+        { KE_KEY, 0xc4, { KEY_KBDILLUMUP } },
+        { KE_KEY, 0xc5, { KEY_KBDILLUMDOWN } },
+        { KE_END, 0},
+};
+
+static struct asus_wmi_driver asus_nb_wmi_driver = {
+        .name = ASUS_NB_WMI_FILE,
+        .owner = THIS_MODULE,
+        .event_guid = ASUS_NB_WMI_EVENT_GUID,
+        .keymap = asus_nb_wmi_keymap,
+        .input_name = "Asus WMI hotkeys",
+        .input_phys = ASUS_NB_WMI_FILE "/input0",
+};
+
+
+static int __init asus_nb_wmi_init(void)
+{
+        return asus_wmi_register_driver(&asus_nb_wmi_driver);
+}
+
+static void __exit asus_nb_wmi_exit(void)
+{
+        asus_wmi_unregister_driver(&asus_nb_wmi_driver);
+}
+
+module_init(asus_nb_wmi_init);
+module_exit(asus_nb_wmi_exit);
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
new file mode 100644
index 000000000000..efc776cb0c66
--- /dev/null
+++ b/drivers/platform/x86/asus-wmi.c
@@ -0,0 +1,1656 @@
+/*
+ * Asus PC WMI hotkey driver
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * Portions based on wistron_btns.c:
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ *  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 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; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <linux/leds.h>
+#include <linux/rfkill.h>
+#include <linux/pci.h>
+#include <linux/pci_hotplug.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/platform_device.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#include "asus-wmi.h"
+
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>, "
+              "Yong Wang <yong.y.wang@intel.com>");
+MODULE_DESCRIPTION("Asus Generic WMI Driver");
+MODULE_LICENSE("GPL");
+
+#define to_platform_driver(drv)                                 \
+        (container_of((drv), struct platform_driver, driver))
+
+#define to_asus_wmi_driver(pdrv)                                        \
+        (container_of((pdrv), struct asus_wmi_driver, platform_driver))
+
+#define ASUS_WMI_MGMT_GUID      "97845ED0-4E6D-11DE-8A39-0800200C9A66"
+
+#define NOTIFY_BRNUP_MIN                0x11
+#define NOTIFY_BRNUP_MAX                0x1f
+#define NOTIFY_BRNDOWN_MIN              0x20
+#define NOTIFY_BRNDOWN_MAX              0x2e
+
+/* WMI Methods */
+#define ASUS_WMI_METHODID_SPEC          0x43455053 /* BIOS SPECification */
+#define ASUS_WMI_METHODID_SFBD          0x44424653 /* Set First Boot Device */
+#define ASUS_WMI_METHODID_GLCD          0x44434C47 /* Get LCD status */
+#define ASUS_WMI_METHODID_GPID          0x44495047 /* Get Panel ID?? (Resol) */
+#define ASUS_WMI_METHODID_QMOD          0x444F4D51 /* Quiet MODe */
+#define ASUS_WMI_METHODID_SPLV          0x4C425053 /* Set Panel Light Value */
+#define ASUS_WMI_METHODID_SFUN          0x4E554653 /* FUNCtionalities */
+#define ASUS_WMI_METHODID_SDSP          0x50534453 /* Set DiSPlay output */
+#define ASUS_WMI_METHODID_GDSP          0x50534447 /* Get DiSPlay output */
+#define ASUS_WMI_METHODID_DEVP          0x50564544 /* DEVice Policy */
+#define ASUS_WMI_METHODID_OSVR          0x5256534F /* OS VeRsion */
+#define ASUS_WMI_METHODID_DSTS          0x53544344 /* Device STatuS */
+#define ASUS_WMI_METHODID_DSTS2         0x53545344 /* Device STatuS #2*/
+#define ASUS_WMI_METHODID_BSTS          0x53545342 /* Bios STatuS ? */
+#define ASUS_WMI_METHODID_DEVS          0x53564544 /* DEVice Set */
+#define ASUS_WMI_METHODID_CFVS          0x53564643 /* CPU Frequency Volt Set */
+#define ASUS_WMI_METHODID_KBFT          0x5446424B /* KeyBoard FilTer */
+#define ASUS_WMI_METHODID_INIT          0x54494E49 /* INITialize */
+#define ASUS_WMI_METHODID_HKEY          0x59454B48 /* Hot KEY ?? */
+
+#define ASUS_WMI_UNSUPPORTED_METHOD     0xFFFFFFFE
+
+/* Wireless */
+#define ASUS_WMI_DEVID_HW_SWITCH        0x00010001
+#define ASUS_WMI_DEVID_WIRELESS_LED     0x00010002
+#define ASUS_WMI_DEVID_WLAN             0x00010011
+#define ASUS_WMI_DEVID_BLUETOOTH        0x00010013
+#define ASUS_WMI_DEVID_GPS              0x00010015
+#define ASUS_WMI_DEVID_WIMAX            0x00010017
+#define ASUS_WMI_DEVID_WWAN3G           0x00010019
+#define ASUS_WMI_DEVID_UWB              0x00010021
+
+/* Leds */
+/* 0x000200XX and 0x000400XX */
+
+/* Backlight and Brightness */
+#define ASUS_WMI_DEVID_BACKLIGHT        0x00050011
+#define ASUS_WMI_DEVID_BRIGHTNESS       0x00050012
+#define ASUS_WMI_DEVID_KBD_BACKLIGHT    0x00050021
+#define ASUS_WMI_DEVID_LIGHT_SENSOR     0x00050022 /* ?? */
+
+/* Misc */
+#define ASUS_WMI_DEVID_CAMERA           0x00060013
+
+/* Storage */
+#define ASUS_WMI_DEVID_CARDREADER       0x00080013
+
+/* Input */
+#define ASUS_WMI_DEVID_TOUCHPAD         0x00100011
+#define ASUS_WMI_DEVID_TOUCHPAD_LED     0x00100012
+
+/* Fan, Thermal */
+#define ASUS_WMI_DEVID_THERMAL_CTRL     0x00110011
+#define ASUS_WMI_DEVID_FAN_CTRL         0x00110012
+
+/* Power */
+#define ASUS_WMI_DEVID_PROCESSOR_STATE  0x00120012
+
+/* DSTS masks */
+#define ASUS_WMI_DSTS_STATUS_BIT        0x00000001
+#define ASUS_WMI_DSTS_UNKNOWN_BIT       0x00000002
+#define ASUS_WMI_DSTS_PRESENCE_BIT      0x00010000
+#define ASUS_WMI_DSTS_USER_BIT          0x00020000
+#define ASUS_WMI_DSTS_BIOS_BIT          0x00040000
+#define ASUS_WMI_DSTS_BRIGHTNESS_MASK   0x000000FF
+#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK   0x0000FF00
+
+struct bios_args {
+        u32 arg0;
+        u32 arg1;
+} __packed;
+
+/*
+ * <platform>/    - debugfs root directory
+ *   dev_id      - current dev_id
+ *   ctrl_param  - current ctrl_param
+ *   method_id   - current method_id
+ *   devs        - call DEVS(dev_id, ctrl_param) and print result
+ *   dsts        - call DSTS(dev_id)  and print result
+ *   call        - call method_id(dev_id, ctrl_param) and print result
+ */
+struct asus_wmi_debug {
+        struct dentry *root;
+        u32 method_id;
+        u32 dev_id;
+        u32 ctrl_param;
+};
+
+struct asus_rfkill {
+        struct asus_wmi *asus;
+        struct rfkill *rfkill;
+        u32 dev_id;
+};
+
+struct asus_wmi {
+        int dsts_id;
+        int spec;
+        int sfun;
+
+        struct input_dev *inputdev;
+        struct backlight_device *backlight_device;
+        struct device *hwmon_device;
+        struct platform_device *platform_device;
+
+        struct led_classdev tpd_led;
+        int tpd_led_wk;
+        struct workqueue_struct *led_workqueue;
+        struct work_struct tpd_led_work;
+
+        struct asus_rfkill wlan;
+        struct asus_rfkill bluetooth;
+        struct asus_rfkill wimax;
+        struct asus_rfkill wwan3g;
+
+        struct hotplug_slot *hotplug_slot;
+        struct mutex hotplug_lock;
+        struct mutex wmi_lock;
+        struct workqueue_struct *hotplug_workqueue;
+        struct work_struct hotplug_work;
+
+        struct asus_wmi_debug debug;
+
+        struct asus_wmi_driver *driver;
+};
+
+static int asus_wmi_input_init(struct asus_wmi *asus)
+{
+        int err;
+
+        asus->inputdev = input_allocate_device();
+        if (!asus->inputdev)
+                return -ENOMEM;
+
+        asus->inputdev->name = asus->driver->input_phys;
+        asus->inputdev->phys = asus->driver->input_name;
+        asus->inputdev->id.bustype = BUS_HOST;
+        asus->inputdev->dev.parent = &asus->platform_device->dev;
+
+        err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
+        if (err)
+                goto err_free_dev;
+
+        err = input_register_device(asus->inputdev);
+        if (err)
+                goto err_free_keymap;
+
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(asus->inputdev);
+err_free_dev:
+        input_free_device(asus->inputdev);
+        return err;
+}
+
+static void asus_wmi_input_exit(struct asus_wmi *asus)
+{
+        if (asus->inputdev) {
+                sparse_keymap_free(asus->inputdev);
+                input_unregister_device(asus->inputdev);
+        }
+
+        asus->inputdev = NULL;
+}
+
+static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
+                                    u32 *retval)
+{
+        struct bios_args args = {
+                .arg0 = arg0,
+                .arg1 = arg1,
+        };
+        struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        acpi_status status;
+        union acpi_object *obj;
+        u32 tmp;
+
+        status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
+                                     &input, &output);
+
+        if (ACPI_FAILURE(status))
+                goto exit;
+
+        obj = (union acpi_object *)output.pointer;
+        if (obj && obj->type == ACPI_TYPE_INTEGER)
+                tmp = (u32) obj->integer.value;
+        else
+                tmp = 0;
+
+        if (retval)
+                *retval = tmp;
+
+        kfree(obj);
+
+exit:
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
+                return -ENODEV;
+
+        return 0;
+}
+
+static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
+{
+        return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
+}
+
+static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
+                                 u32 *retval)
+{
+        return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
+                                        ctrl_param, retval);
+}
+
+/* Helper for special devices with magic return codes */
+static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
+                                      u32 dev_id, u32 mask)
+{
+        u32 retval = 0;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, dev_id, &retval);
+
+        if (err < 0)
+                return err;
+
+        if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
+                return -ENODEV;
+
+        if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
+                if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
+                        return -ENODEV;
+        }
+
+        return retval & mask;
+}
+
+static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
+{
+        return asus_wmi_get_devstate_bits(asus, dev_id,
+                                          ASUS_WMI_DSTS_STATUS_BIT);
+}
+
+/*
+ * LEDs
+ */
+/*
+ * These functions actually update the LED's, and are called from a
+ * workqueue. By doing this as separate work rather than when the LED
+ * subsystem asks, we avoid messing with the Asus ACPI stuff during a
+ * potentially bad time, such as a timer interrupt.
+ */
+static void tpd_led_update(struct work_struct *work)
+{
+        int ctrl_param;
+        struct asus_wmi *asus;
+
+        asus = container_of(work, struct asus_wmi, tpd_led_work);
+
+        ctrl_param = asus->tpd_led_wk;
+        asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
+}
+
+static void tpd_led_set(struct led_classdev *led_cdev,
+                        enum led_brightness value)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(led_cdev, struct asus_wmi, tpd_led);
+
+        asus->tpd_led_wk = !!value;
+        queue_work(asus->led_workqueue, &asus->tpd_led_work);
+}
+
+static int read_tpd_led_state(struct asus_wmi *asus)
+{
+        return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
+}
+
+static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(led_cdev, struct asus_wmi, tpd_led);
+
+        return read_tpd_led_state(asus);
+}
+
+static int asus_wmi_led_init(struct asus_wmi *asus)
+{
+        int rv;
+
+        if (read_tpd_led_state(asus) < 0)
+                return 0;
+
+        asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
+        if (!asus->led_workqueue)
+                return -ENOMEM;
+        INIT_WORK(&asus->tpd_led_work, tpd_led_update);
+
+        asus->tpd_led.name = "asus::touchpad";
+        asus->tpd_led.brightness_set = tpd_led_set;
+        asus->tpd_led.brightness_get = tpd_led_get;
+        asus->tpd_led.max_brightness = 1;
+
+        rv = led_classdev_register(&asus->platform_device->dev, &asus->tpd_led);
+        if (rv) {
+                destroy_workqueue(asus->led_workqueue);
+                return rv;
+        }
+
+        return 0;
+}
+
+static void asus_wmi_led_exit(struct asus_wmi *asus)
+{
+        if (asus->tpd_led.dev)
+                led_classdev_unregister(&asus->tpd_led);
+        if (asus->led_workqueue)
+                destroy_workqueue(asus->led_workqueue);
+}
+
+/*
+ * PCI hotplug (for wlan rfkill)
+ */
+static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
+{
+        int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
+
+        if (result < 0)
+                return false;
+        return !result;
+}
+
+static void asus_rfkill_hotplug(struct asus_wmi *asus)
+{
+        struct pci_dev *dev;
+        struct pci_bus *bus;
+        bool blocked;
+        bool absent;
+        u32 l;
+
+        mutex_lock(&asus->wmi_lock);
+        blocked = asus_wlan_rfkill_blocked(asus);
+        mutex_unlock(&asus->wmi_lock);
+
+        mutex_lock(&asus->hotplug_lock);
+
+        if (asus->wlan.rfkill)
+                rfkill_set_sw_state(asus->wlan.rfkill, blocked);
+
+        if (asus->hotplug_slot) {
+                bus = pci_find_bus(0, 1);
+                if (!bus) {
+                        pr_warning("Unable to find PCI bus 1?\n");
+                        goto out_unlock;
+                }
+
+                if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
+                        pr_err("Unable to read PCI config space?\n");
+                        goto out_unlock;
+                }
+                absent = (l == 0xffffffff);
+
+                if (blocked != absent) {
+                        pr_warning("BIOS says wireless lan is %s, "
+                                   "but the pci device is %s\n",
+                                   blocked ? "blocked" : "unblocked",
+                                   absent ? "absent" : "present");
+                        pr_warning("skipped wireless hotplug as probably "
+                                   "inappropriate for this model\n");
+                        goto out_unlock;
+                }
+
+                if (!blocked) {
+                        dev = pci_get_slot(bus, 0);
+                        if (dev) {
+                                /* Device already present */
+                                pci_dev_put(dev);
+                                goto out_unlock;
+                        }
+                        dev = pci_scan_single_device(bus, 0);
+                        if (dev) {
+                                pci_bus_assign_resources(bus);
+                                if (pci_bus_add_device(dev))
+                                        pr_err("Unable to hotplug wifi\n");
+                        }
+                } else {
+                        dev = pci_get_slot(bus, 0);
+                        if (dev) {
+                                pci_remove_bus_device(dev);
+                                pci_dev_put(dev);
+                        }
+                }
+        }
+
+out_unlock:
+        mutex_unlock(&asus->hotplug_lock);
+}
+
+static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
+{
+        struct asus_wmi *asus = data;
+
+        if (event != ACPI_NOTIFY_BUS_CHECK)
+                return;
+
+        /*
+         * We can't call directly asus_rfkill_hotplug because most
+         * of the time WMBC is still being executed and not reetrant.
+         * There is currently no way to tell ACPICA that  we want this
+         * method to be serialized, we schedule a asus_rfkill_hotplug
+         * call later, in a safer context.
+         */
+        queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
+}
+
+static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
+{
+        acpi_status status;
+        acpi_handle handle;
+
+        status = acpi_get_handle(NULL, node, &handle);
+
+        if (ACPI_SUCCESS(status)) {
+                status = acpi_install_notify_handler(handle,
+                                                     ACPI_SYSTEM_NOTIFY,
+                                                     asus_rfkill_notify, asus);
+                if (ACPI_FAILURE(status))
+                        pr_warning("Failed to register notify on %s\n", node);
+        } else
+                return -ENODEV;
+
+        return 0;
+}
+
+static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
+{
+        acpi_status status = AE_OK;
+        acpi_handle handle;
+
+        status = acpi_get_handle(NULL, node, &handle);
+
+        if (ACPI_SUCCESS(status)) {
+                status = acpi_remove_notify_handler(handle,
+                                                    ACPI_SYSTEM_NOTIFY,
+                                                    asus_rfkill_notify);
+                if (ACPI_FAILURE(status))
+                        pr_err("Error removing rfkill notify handler %s\n",
+                               node);
+        }
+}
+
+static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
+                                   u8 *value)
+{
+        struct asus_wmi *asus = hotplug_slot->private;
+        int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
+
+        if (result < 0)
+                return result;
+
+        *value = !!result;
+        return 0;
+}
+
+static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
+{
+        kfree(hotplug_slot->info);
+        kfree(hotplug_slot);
+}
+
+static struct hotplug_slot_ops asus_hotplug_slot_ops = {
+        .owner = THIS_MODULE,
+        .get_adapter_status = asus_get_adapter_status,
+        .get_power_status = asus_get_adapter_status,
+};
+
+static void asus_hotplug_work(struct work_struct *work)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(work, struct asus_wmi, hotplug_work);
+        asus_rfkill_hotplug(asus);
+}
+
+static int asus_setup_pci_hotplug(struct asus_wmi *asus)
+{
+        int ret = -ENOMEM;
+        struct pci_bus *bus = pci_find_bus(0, 1);
+
+        if (!bus) {
+                pr_err("Unable to find wifi PCI bus\n");
+                return -ENODEV;
+        }
+
+        asus->hotplug_workqueue =
+            create_singlethread_workqueue("hotplug_workqueue");
+        if (!asus->hotplug_workqueue)
+                goto error_workqueue;
+
+        INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
+
+        asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
+        if (!asus->hotplug_slot)
+                goto error_slot;
+
+        asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
+                                           GFP_KERNEL);
+        if (!asus->hotplug_slot->info)
+                goto error_info;
+
+        asus->hotplug_slot->private = asus;
+        asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
+        asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
+        asus_get_adapter_status(asus->hotplug_slot,
+                                &asus->hotplug_slot->info->adapter_status);
+
+        ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
+        if (ret) {
+                pr_err("Unable to register hotplug slot - %d\n", ret);
+                goto error_register;
+        }
+
+        return 0;
+
+error_register:
+        kfree(asus->hotplug_slot->info);
+error_info:
+        kfree(asus->hotplug_slot);
+        asus->hotplug_slot = NULL;
+error_slot:
+        destroy_workqueue(asus->hotplug_workqueue);
+error_workqueue:
+        return ret;
+}
+
+/*
+ * Rfkill devices
+ */
+static int asus_rfkill_set(void *data, bool blocked)
+{
+        struct asus_rfkill *priv = data;
+        u32 ctrl_param = !blocked;
+
+        return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
+}
+
+static void asus_rfkill_query(struct rfkill *rfkill, void *data)
+{
+        struct asus_rfkill *priv = data;
+        int result;
+
+        result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
+
+        if (result < 0)
+                return;
+
+        rfkill_set_sw_state(priv->rfkill, !result);
+}
+
+static int asus_rfkill_wlan_set(void *data, bool blocked)
+{
+        struct asus_rfkill *priv = data;
+        struct asus_wmi *asus = priv->asus;
+        int ret;
+
+        /*
+         * This handler is enabled only if hotplug is enabled.
+         * In this case, the asus_wmi_set_devstate() will
+         * trigger a wmi notification and we need to wait
+         * this call to finish before being able to call
+         * any wmi method
+         */
+        mutex_lock(&asus->wmi_lock);
+        ret = asus_rfkill_set(data, blocked);
+        mutex_unlock(&asus->wmi_lock);
+        return ret;
+}
+
+static const struct rfkill_ops asus_rfkill_wlan_ops = {
+        .set_block = asus_rfkill_wlan_set,
+        .query = asus_rfkill_query,
+};
+
+static const struct rfkill_ops asus_rfkill_ops = {
+        .set_block = asus_rfkill_set,
+        .query = asus_rfkill_query,
+};
+
+static int asus_new_rfkill(struct asus_wmi *asus,
+                           struct asus_rfkill *arfkill,
+                           const char *name, enum rfkill_type type, int dev_id)
+{
+        int result = asus_wmi_get_devstate_simple(asus, dev_id);
+        struct rfkill **rfkill = &arfkill->rfkill;
+
+        if (result < 0)
+                return result;
+
+        arfkill->dev_id = dev_id;
+        arfkill->asus = asus;
+
+        if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
+                *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
+                                       &asus_rfkill_wlan_ops, arfkill);
+        else
+                *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
+                                       &asus_rfkill_ops, arfkill);
+
+        if (!*rfkill)
+                return -EINVAL;
+
+        rfkill_init_sw_state(*rfkill, !result);
+        result = rfkill_register(*rfkill);
+        if (result) {
+                rfkill_destroy(*rfkill);
+                *rfkill = NULL;
+                return result;
+        }
+        return 0;
+}
+
+static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
+{
+        asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
+        asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
+        asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
+        if (asus->wlan.rfkill) {
+                rfkill_unregister(asus->wlan.rfkill);
+                rfkill_destroy(asus->wlan.rfkill);
+                asus->wlan.rfkill = NULL;
+        }
+        /*
+         * Refresh pci hotplug in case the rfkill state was changed after
+         * asus_unregister_rfkill_notifier()
+         */
+        asus_rfkill_hotplug(asus);
+        if (asus->hotplug_slot)
+                pci_hp_deregister(asus->hotplug_slot);
+        if (asus->hotplug_workqueue)
+                destroy_workqueue(asus->hotplug_workqueue);
+
+        if (asus->bluetooth.rfkill) {
+                rfkill_unregister(asus->bluetooth.rfkill);
+                rfkill_destroy(asus->bluetooth.rfkill);
+                asus->bluetooth.rfkill = NULL;
+        }
+        if (asus->wimax.rfkill) {
+                rfkill_unregister(asus->wimax.rfkill);
+                rfkill_destroy(asus->wimax.rfkill);
+                asus->wimax.rfkill = NULL;
+        }
+        if (asus->wwan3g.rfkill) {
+                rfkill_unregister(asus->wwan3g.rfkill);
+                rfkill_destroy(asus->wwan3g.rfkill);
+                asus->wwan3g.rfkill = NULL;
+        }
+}
+
+static int asus_wmi_rfkill_init(struct asus_wmi *asus)
+{
+        int result = 0;
+
+        mutex_init(&asus->hotplug_lock);
+        mutex_init(&asus->wmi_lock);
+
+        result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
+                                 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->bluetooth,
+                                 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
+                                 ASUS_WMI_DEVID_BLUETOOTH);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
+                                 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
+                                 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        if (!asus->driver->hotplug_wireless)
+                goto exit;
+
+        result = asus_setup_pci_hotplug(asus);
+        /*
+         * If we get -EBUSY then something else is handling the PCI hotplug -
+         * don't fail in this case
+         */
+        if (result == -EBUSY)
+                result = 0;
+
+        asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
+        asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
+        asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
+        /*
+         * Refresh pci hotplug in case the rfkill state was changed during
+         * setup.
+         */
+        asus_rfkill_hotplug(asus);
+
+exit:
+        if (result && result != -ENODEV)
+                asus_wmi_rfkill_exit(asus);
+
+        if (result == -ENODEV)
+                result = 0;
+
+        return result;
+}
+
+/*
+ * Hwmon device
+ */
+static ssize_t asus_hwmon_pwm1(struct device *dev,
+                            struct device_attribute *attr,
+                            char *buf)
+{
+        struct asus_wmi *asus = dev_get_drvdata(dev);
+        u32 value;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
+
+        if (err < 0)
+                return err;
+
+        value |= 0xFF;
+
+        if (value == 1) /* Low Speed */
+                value = 85;
+        else if (value == 2)
+                value = 170;
+        else if (value == 3)
+                value = 255;
+        else if (value != 0) {
+                pr_err("Unknown fan speed %#x", value);
+                value = -1;
+        }
+
+        return sprintf(buf, "%d\n", value);
+}
+
+static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, asus_hwmon_pwm1, NULL, 0);
+
+static ssize_t
+show_name(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "asus\n");
+}
+static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
+
+static struct attribute *hwmon_attributes[] = {
+        &sensor_dev_attr_pwm1.dev_attr.attr,
+        &sensor_dev_attr_name.dev_attr.attr,
+        NULL
+};
+
+static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
+                                    struct attribute *attr, int idx)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev->parent);
+        struct asus_wmi *asus = platform_get_drvdata(pdev);
+        bool ok = true;
+        int dev_id = -1;
+        u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
+
+        if (attr == &sensor_dev_attr_pwm1.dev_attr.attr)
+                dev_id = ASUS_WMI_DEVID_FAN_CTRL;
+
+        if (dev_id != -1) {
+                int err = asus_wmi_get_devstate(asus, dev_id, &value);
+
+                if (err < 0)
+                        return err;
+        }
+
+        if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
+                /*
+                 * We need to find a better way, probably using sfun,
+                 * bits or spec ...
+                 * Currently we disable it if:
+                 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
+                 * - reverved bits are non-zero
+                 * - sfun and presence bit are not set
+                 */
+                if (value != ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
+                    || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
+                        ok = false;
+        }
+
+        return ok ? attr->mode : 0;
+}
+
+static struct attribute_group hwmon_attribute_group = {
+        .is_visible = asus_hwmon_sysfs_is_visible,
+        .attrs = hwmon_attributes
+};
+
+static void asus_wmi_hwmon_exit(struct asus_wmi *asus)
+{
+        struct device *hwmon;
+
+        hwmon = asus->hwmon_device;
+        if (!hwmon)
+                return;
+        sysfs_remove_group(&hwmon->kobj, &hwmon_attribute_group);
+        hwmon_device_unregister(hwmon);
+        asus->hwmon_device = NULL;
+}
+
+static int asus_wmi_hwmon_init(struct asus_wmi *asus)
+{
+        struct device *hwmon;
+        int result;
+
+        hwmon = hwmon_device_register(&asus->platform_device->dev);
+        if (IS_ERR(hwmon)) {
+                pr_err("Could not register asus hwmon device\n");
+                return PTR_ERR(hwmon);
+        }
+        asus->hwmon_device = hwmon;
+        result = sysfs_create_group(&hwmon->kobj, &hwmon_attribute_group);
+        if (result)
+                asus_wmi_hwmon_exit(asus);
+        return result;
+}
+
+/*
+ * Backlight
+ */
+static int read_backlight_power(struct asus_wmi *asus)
+{
+        int ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BACKLIGHT);
+
+        if (ret < 0)
+                return ret;
+
+        return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
+}
+
+static int read_brightness_max(struct asus_wmi *asus)
+{
+        u32 retval;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
+
+        if (err < 0)
+                return err;
+
+        retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
+        retval >>= 8;
+
+        if (!retval)
+                return -ENODEV;
+
+        return retval;
+}
+
+static int read_brightness(struct backlight_device *bd)
+{
+        struct asus_wmi *asus = bl_get_data(bd);
+        u32 retval;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
+
+        if (err < 0)
+                return err;
+
+        return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
+}
+
+static int update_bl_status(struct backlight_device *bd)
+{
+        struct asus_wmi *asus = bl_get_data(bd);
+        u32 ctrl_param;
+        int power, err;
+
+        ctrl_param = bd->props.brightness;
+
+        err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
+                                    ctrl_param, NULL);
+
+        if (err < 0)
+                return err;
+
+        power = read_backlight_power(asus);
+        if (power != -ENODEV && bd->props.power != power) {
+                ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
+                err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
+                                            ctrl_param, NULL);
+        }
+        return err;
+}
+
+static const struct backlight_ops asus_wmi_bl_ops = {
+        .get_brightness = read_brightness,
+        .update_status = update_bl_status,
+};
+
+static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
+{
+        struct backlight_device *bd = asus->backlight_device;
+        int old = bd->props.brightness;
+        int new = old;
+
+        if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
+                new = code - NOTIFY_BRNUP_MIN + 1;
+        else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
+                new = code - NOTIFY_BRNDOWN_MIN;
+
+        bd->props.brightness = new;
+        backlight_update_status(bd);
+        backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
+
+        return old;
+}
+
+static int asus_wmi_backlight_init(struct asus_wmi *asus)
+{
+        struct backlight_device *bd;
+        struct backlight_properties props;
+        int max;
+        int power;
+
+        max = read_brightness_max(asus);
+
+        if (max == -ENODEV)
+                max = 0;
+        else if (max < 0)
+                return max;
+
+        power = read_backlight_power(asus);
+
+        if (power == -ENODEV)
+                power = FB_BLANK_UNBLANK;
+        else if (power < 0)
+                return power;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = max;
+        bd = backlight_device_register(asus->driver->name,
+                                       &asus->platform_device->dev, asus,
+                                       &asus_wmi_bl_ops, &props);
+        if (IS_ERR(bd)) {
+                pr_err("Could not register backlight device\n");
+                return PTR_ERR(bd);
+        }
+
+        asus->backlight_device = bd;
+
+        bd->props.brightness = read_brightness(bd);
+        bd->props.power = power;
+        backlight_update_status(bd);
+
+        return 0;
+}
+
+static void asus_wmi_backlight_exit(struct asus_wmi *asus)
+{
+        if (asus->backlight_device)
+                backlight_device_unregister(asus->backlight_device);
+
+        asus->backlight_device = NULL;
+}
+
+static void asus_wmi_notify(u32 value, void *context)
+{
+        struct asus_wmi *asus = context;
+        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+        int code;
+        int orig_code;
+
+        status = wmi_get_event_data(value, &response);
+        if (status != AE_OK) {
+                pr_err("bad event status 0x%x\n", status);
+                return;
+        }
+
+        obj = (union acpi_object *)response.pointer;
+
+        if (!obj || obj->type != ACPI_TYPE_INTEGER)
+                goto exit;
+
+        code = obj->integer.value;
+        orig_code = code;
+
+        if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
+                code = NOTIFY_BRNUP_MIN;
+        else if (code >= NOTIFY_BRNDOWN_MIN &&
+                 code <= NOTIFY_BRNDOWN_MAX)
+                code = NOTIFY_BRNDOWN_MIN;
+
+        if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
+                if (!acpi_video_backlight_support())
+                        asus_wmi_backlight_notify(asus, orig_code);
+        } else if (!sparse_keymap_report_event(asus->inputdev, code, 1, true))
+                pr_info("Unknown key %x pressed\n", code);
+
+exit:
+        kfree(obj);
+}
+
+/*
+ * Sys helpers
+ */
+static int parse_arg(const char *buf, unsigned long count, int *val)
+{
+        if (!count)
+                return 0;
+        if (sscanf(buf, "%i", val) != 1)
+                return -EINVAL;
+        return count;
+}
+
+static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
+                             const char *buf, size_t count)
+{
+        u32 retval;
+        int rv, err, value;
+
+        value = asus_wmi_get_devstate_simple(asus, devid);
+        if (value == -ENODEV)   /* Check device presence */
+                return value;
+
+        rv = parse_arg(buf, count, &value);
+        err = asus_wmi_set_devstate(devid, value, &retval);
+
+        if (err < 0)
+                return err;
+
+        return rv;
+}
+
+static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
+{
+        int value = asus_wmi_get_devstate_simple(asus, devid);
+
+        if (value < 0)
+                return value;
+
+        return sprintf(buf, "%d\n", value);
+}
+
+#define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)                  \
+        static ssize_t show_##_name(struct device *dev,                 \
+                                    struct device_attribute *attr,      \
+                                    char *buf)                          \
+        {                                                               \
+                struct asus_wmi *asus = dev_get_drvdata(dev);           \
+                                                                        \
+                return show_sys_wmi(asus, _cm, buf);                    \
+        }                                                               \
+        static ssize_t store_##_name(struct device *dev,                \
+                                     struct device_attribute *attr,     \
+                                     const char *buf, size_t count)     \
+        {                                                               \
+                struct asus_wmi *asus = dev_get_drvdata(dev);           \
+                                                                        \
+                return store_sys_wmi(asus, _cm, buf, count);            \
+        }                                                               \
+        static struct device_attribute dev_attr_##_name = {             \
+                .attr = {                                               \
+                        .name = __stringify(_name),                     \
+                        .mode = _mode },                                \
+                .show   = show_##_name,                                 \
+                .store  = store_##_name,                                \
+        }
+
+ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
+ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
+ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
+
+static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        int value;
+
+        if (!count || sscanf(buf, "%i", &value) != 1)
+                return -EINVAL;
+        if (value < 0 || value > 2)
+                return -EINVAL;
+
+        return asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
+}
+
+static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
+
+static struct attribute *platform_attributes[] = {
+        &dev_attr_cpufv.attr,
+        &dev_attr_camera.attr,
+        &dev_attr_cardr.attr,
+        &dev_attr_touchpad.attr,
+        NULL
+};
+
+static mode_t asus_sysfs_is_visible(struct kobject *kobj,
+                                    struct attribute *attr, int idx)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct asus_wmi *asus = platform_get_drvdata(pdev);
+        bool ok = true;
+        int devid = -1;
+
+        if (attr == &dev_attr_camera.attr)
+                devid = ASUS_WMI_DEVID_CAMERA;
+        else if (attr == &dev_attr_cardr.attr)
+                devid = ASUS_WMI_DEVID_CARDREADER;
+        else if (attr == &dev_attr_touchpad.attr)
+                devid = ASUS_WMI_DEVID_TOUCHPAD;
+
+        if (devid != -1)
+                ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
+
+        return ok ? attr->mode : 0;
+}
+
+static struct attribute_group platform_attribute_group = {
+        .is_visible = asus_sysfs_is_visible,
+        .attrs = platform_attributes
+};
+
+static void asus_wmi_sysfs_exit(struct platform_device *device)
+{
+        sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
+}
+
+static int asus_wmi_sysfs_init(struct platform_device *device)
+{
+        return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
+}
+
+/*
+ * Platform device
+ */
+static int __init asus_wmi_platform_init(struct asus_wmi *asus)
+{
+        int rv;
+
+        /* INIT enable hotkeys on some models */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
+                pr_info("Initialization: %#x", rv);
+
+        /* We don't know yet what to do with this version... */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
+                pr_info("BIOS WMI version: %d.%d", rv >> 8, rv & 0xFF);
+                asus->spec = rv;
+        }
+
+        /*
+         * The SFUN method probably allows the original driver to get the list
+         * of features supported by a given model. For now, 0x0100 or 0x0800
+         * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
+         * The significance of others is yet to be found.
+         */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
+                pr_info("SFUN value: %#x", rv);
+                asus->sfun = rv;
+        }
+
+        /*
+         * Eee PC and Notebooks seems to have different method_id for DSTS,
+         * but it may also be related to the BIOS's SPEC.
+         * Note, on most Eeepc, there is no way to check if a method exist
+         * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
+         * but once again, SPEC may probably be used for that kind of things.
+         */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
+                asus->dsts_id = ASUS_WMI_METHODID_DSTS;
+        else if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS2, 0, 0, NULL))
+                asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
+
+        if (!asus->dsts_id) {
+                pr_err("Can't find DSTS");
+                return -ENODEV;
+        }
+
+        return asus_wmi_sysfs_init(asus->platform_device);
+}
+
+static void asus_wmi_platform_exit(struct asus_wmi *asus)
+{
+        asus_wmi_sysfs_exit(asus->platform_device);
+}
+
+/*
+ * debugfs
+ */
+struct asus_wmi_debugfs_node {
+        struct asus_wmi *asus;
+        char *name;
+        int (*show) (struct seq_file *m, void *data);
+};
+
+static int show_dsts(struct seq_file *m, void *data)
+{
+        struct asus_wmi *asus = m->private;
+        int err;
+        u32 retval = -1;
+
+        err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
+
+        if (err < 0)
+                return err;
+
+        seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
+
+        return 0;
+}
+
+static int show_devs(struct seq_file *m, void *data)
+{
+        struct asus_wmi *asus = m->private;
+        int err;
+        u32 retval = -1;
+
+        err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
+                                    &retval);
+
+        if (err < 0)
+                return err;
+
+        seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
+                   asus->debug.ctrl_param, retval);
+
+        return 0;
+}
+
+static int show_call(struct seq_file *m, void *data)
+{
+        struct asus_wmi *asus = m->private;
+        struct bios_args args = {
+                .arg0 = asus->debug.dev_id,
+                .arg1 = asus->debug.ctrl_param,
+        };
+        struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+
+        status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
+                                     1, asus->debug.method_id,
+                                     &input, &output);
+
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        obj = (union acpi_object *)output.pointer;
+        if (obj && obj->type == ACPI_TYPE_INTEGER)
+                seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
+                           asus->debug.dev_id, asus->debug.ctrl_param,
+                           (u32) obj->integer.value);
+        else
+                seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
+                           asus->debug.dev_id, asus->debug.ctrl_param,
+                           obj ? obj->type : -1);
+
+        kfree(obj);
+
+        return 0;
+}
+
+static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
+        {NULL, "devs", show_devs},
+        {NULL, "dsts", show_dsts},
+        {NULL, "call", show_call},
+};
+
+static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
+{
+        struct asus_wmi_debugfs_node *node = inode->i_private;
+
+        return single_open(file, node->show, node->asus);
+}
+
+static const struct file_operations asus_wmi_debugfs_io_ops = {
+        .owner = THIS_MODULE,
+        .open = asus_wmi_debugfs_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
+{
+        debugfs_remove_recursive(asus->debug.root);
+}
+
+static int asus_wmi_debugfs_init(struct asus_wmi *asus)
+{
+        struct dentry *dent;
+        int i;
+
+        asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
+        if (!asus->debug.root) {
+                pr_err("failed to create debugfs directory");
+                goto error_debugfs;
+        }
+
+        dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
+                                  asus->debug.root, &asus->debug.method_id);
+        if (!dent)
+                goto error_debugfs;
+
+        dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
+                                  asus->debug.root, &asus->debug.dev_id);
+        if (!dent)
+                goto error_debugfs;
+
+        dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
+                                  asus->debug.root, &asus->debug.ctrl_param);
+        if (!dent)
+                goto error_debugfs;
+
+        for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
+                struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
+
+                node->asus = asus;
+                dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
+                                           asus->debug.root, node,
+                                           &asus_wmi_debugfs_io_ops);
+                if (!dent) {
+                        pr_err("failed to create debug file: %s\n", node->name);
+                        goto error_debugfs;
+                }
+        }
+
+        return 0;
+
+error_debugfs:
+        asus_wmi_debugfs_exit(asus);
+        return -ENOMEM;
+}
+
+/*
+ * WMI Driver
+ */
+static int asus_wmi_add(struct platform_device *pdev)
+{
+        struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
+        struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
+        struct asus_wmi *asus;
+        acpi_status status;
+        int err;
+
+        asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
+        if (!asus)
+                return -ENOMEM;
+
+        asus->driver = wdrv;
+        asus->platform_device = pdev;
+        wdrv->platform_device = pdev;
+        platform_set_drvdata(asus->platform_device, asus);
+
+        if (wdrv->quirks)
+                wdrv->quirks(asus->driver);
+
+        err = asus_wmi_platform_init(asus);
+        if (err)
+                goto fail_platform;
+
+        err = asus_wmi_input_init(asus);
+        if (err)
+                goto fail_input;
+
+        err = asus_wmi_hwmon_init(asus);
+        if (err)
+                goto fail_hwmon;
+
+        err = asus_wmi_led_init(asus);
+        if (err)
+                goto fail_leds;
+
+        err = asus_wmi_rfkill_init(asus);
+        if (err)
+                goto fail_rfkill;
+
+        if (!acpi_video_backlight_support()) {
+                err = asus_wmi_backlight_init(asus);
+                if (err && err != -ENODEV)
+                        goto fail_backlight;
+        } else
+                pr_info("Backlight controlled by ACPI video driver\n");
+
+        status = wmi_install_notify_handler(asus->driver->event_guid,
+                                            asus_wmi_notify, asus);
+        if (ACPI_FAILURE(status)) {
+                pr_err("Unable to register notify handler - %d\n", status);
+                err = -ENODEV;
+                goto fail_wmi_handler;
+        }
+
+        err = asus_wmi_debugfs_init(asus);
+        if (err)
+                goto fail_debugfs;
+
+        return 0;
+
+fail_debugfs:
+        wmi_remove_notify_handler(asus->driver->event_guid);
+fail_wmi_handler:
+        asus_wmi_backlight_exit(asus);
+fail_backlight:
+        asus_wmi_rfkill_exit(asus);
+fail_rfkill:
+        asus_wmi_led_exit(asus);
+fail_leds:
+        asus_wmi_hwmon_exit(asus);
+fail_hwmon:
+        asus_wmi_input_exit(asus);
+fail_input:
+        asus_wmi_platform_exit(asus);
+fail_platform:
+        kfree(asus);
+        return err;
+}
+
+static int asus_wmi_remove(struct platform_device *device)
+{
+        struct asus_wmi *asus;
+
+        asus = platform_get_drvdata(device);
+        wmi_remove_notify_handler(asus->driver->event_guid);
+        asus_wmi_backlight_exit(asus);
+        asus_wmi_input_exit(asus);
+        asus_wmi_hwmon_exit(asus);
+        asus_wmi_led_exit(asus);
+        asus_wmi_rfkill_exit(asus);
+        asus_wmi_debugfs_exit(asus);
+        asus_wmi_platform_exit(asus);
+
+        kfree(asus);
+        return 0;
+}
+
+/*
+ * Platform driver - hibernate/resume callbacks
+ */
+static int asus_hotk_thaw(struct device *device)
+{
+        struct asus_wmi *asus = dev_get_drvdata(device);
+
+        if (asus->wlan.rfkill) {
+                bool wlan;
+
+                /*
+                 * Work around bios bug - acpi _PTS turns off the wireless led
+                 * during suspend.  Normally it restores it on resume, but
+                 * we should kick it ourselves in case hibernation is aborted.
+                 */
+                wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
+                asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
+        }
+
+        return 0;
+}
+
+static int asus_hotk_restore(struct device *device)
+{
+        struct asus_wmi *asus = dev_get_drvdata(device);
+        int bl;
+
+        /* Refresh both wlan rfkill state and pci hotplug */
+        if (asus->wlan.rfkill)
+                asus_rfkill_hotplug(asus);
+
+        if (asus->bluetooth.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus,
+                                                   ASUS_WMI_DEVID_BLUETOOTH);
+                rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
+        }
+        if (asus->wimax.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
+                rfkill_set_sw_state(asus->wimax.rfkill, bl);
+        }
+        if (asus->wwan3g.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
+                rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
+        }
+
+        return 0;
+}
+
+static const struct dev_pm_ops asus_pm_ops = {
+        .thaw = asus_hotk_thaw,
+        .restore = asus_hotk_restore,
+};
+
+static int asus_wmi_probe(struct platform_device *pdev)
+{
+        struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
+        struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
+        int ret;
+
+        if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
+                pr_warning("Management GUID not found\n");
+                return -ENODEV;
+        }
+
+        if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
+                pr_warning("Event GUID not found\n");
+                return -ENODEV;
+        }
+
+        if (wdrv->probe) {
+                ret = wdrv->probe(pdev);
+                if (ret)
+                        return ret;
+        }
+
+        return asus_wmi_add(pdev);
+}
+
+static bool used;
+
+int asus_wmi_register_driver(struct asus_wmi_driver *driver)
+{
+        struct platform_driver *platform_driver;
+        struct platform_device *platform_device;
+
+        if (used)
+                return -EBUSY;
+
+        platform_driver = &driver->platform_driver;
+        platform_driver->remove = asus_wmi_remove;
+        platform_driver->driver.owner = driver->owner;
+        platform_driver->driver.name = driver->name;
+        platform_driver->driver.pm = &asus_pm_ops;
+
+        platform_device = platform_create_bundle(platform_driver,
+                                                 asus_wmi_probe,
+                                                 NULL, 0, NULL, 0);
+        if (IS_ERR(platform_device))
+                return PTR_ERR(platform_device);
+
+        used = true;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
+
+void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
+{
+        platform_device_unregister(driver->platform_device);
+        platform_driver_unregister(&driver->platform_driver);
+        used = false;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
+
+static int __init asus_wmi_init(void)
+{
+        if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
+                pr_info("Asus Management GUID not found");
+                return -ENODEV;
+        }
+
+        pr_info("ASUS WMI generic driver loaded");
+        return 0;
+}
+
+static void __exit asus_wmi_exit(void)
+{
+        pr_info("ASUS WMI generic driver unloaded");
+}
+
+module_init(asus_wmi_init);
+module_exit(asus_wmi_exit);
diff --git a/drivers/platform/x86/asus-wmi.h b/drivers/platform/x86/asus-wmi.h
new file mode 100644
index 000000000000..c044522c8766
--- /dev/null
+++ b/drivers/platform/x86/asus-wmi.h
@@ -0,0 +1,58 @@
+/*
+ * Asus PC WMI hotkey driver
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * Portions based on wistron_btns.c:
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ *  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 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; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _ASUS_WMI_H_
+#define _ASUS_WMI_H_
+
+#include <linux/platform_device.h>
+
+struct module;
+struct key_entry;
+struct asus_wmi;
+
+struct asus_wmi_driver {
+        bool                    hotplug_wireless;
+
+        const char              *name;
+        struct module           *owner;
+
+        const char              *event_guid;
+
+        const struct key_entry  *keymap;
+        const char              *input_name;
+        const char              *input_phys;
+
+        int (*probe) (struct platform_device *device);
+        void (*quirks) (struct asus_wmi_driver *driver);
+
+        struct platform_driver  platform_driver;
+        struct platform_device *platform_device;
+};
+
+int asus_wmi_register_driver(struct asus_wmi_driver *driver);
+void asus_wmi_unregister_driver(struct asus_wmi_driver *driver);
+
+#endif /* !_ASUS_WMI_H_ */
diff --git a/drivers/platform/x86/compal-laptop.c b/drivers/platform/x86/compal-laptop.c
index eb95878fa583..c16a27641ced 100644
--- a/drivers/platform/x86/compal-laptop.c
+++ b/drivers/platform/x86/compal-laptop.c
@@ -201,7 +201,7 @@ static bool extra_features;
  * into 0x4F and read a few bytes from the output, like so:
  *      u8 writeData = 0x33;
  *      ec_transaction(0x4F, &writeData, 1, buffer, 32, 0);
- * That address is labled "fan1 table information" in the service manual.
+ * That address is labelled "fan1 table information" in the service manual.
  * It should be clear which value in 'buffer' changes). This seems to be
  * related to fan speed. It isn't a proper 'realtime' fan speed value
  * though, because physically stopping or speeding up the fan doesn't
@@ -275,7 +275,7 @@ static int set_backlight_level(int level)
 
         ec_write(BACKLIGHT_LEVEL_ADDR, level);
 
-        return 1;
+        return 0;
 }
 
 static int get_backlight_level(void)
@@ -763,7 +763,7 @@ static int dmi_check_cb(const struct dmi_system_id *id)
         printk(KERN_INFO DRIVER_NAME": Identified laptop model '%s'\n",
                 id->ident);
         extra_features = false;
-        return 0;
+        return 1;
 }
 
 static int dmi_check_cb_extra(const struct dmi_system_id *id)
@@ -772,7 +772,7 @@ static int dmi_check_cb_extra(const struct dmi_system_id *id)
                 "enabling extra features\n",
                 id->ident);
         extra_features = true;
-        return 0;
+        return 1;
 }
 
 static struct dmi_system_id __initdata compal_dmi_table[] = {
diff --git a/drivers/platform/x86/dell-wmi-aio.c b/drivers/platform/x86/dell-wmi-aio.c
new file mode 100644
index 000000000000..0ed84573ae1f
--- /dev/null
+++ b/drivers/platform/x86/dell-wmi-aio.c
@@ -0,0 +1,171 @@
+/*
+ *  WMI hotkeys support for Dell All-In-One series
+ *
+ *  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 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; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+#include <acpi/acpi_drivers.h>
+#include <linux/acpi.h>
+#include <linux/string.h>
+
+MODULE_DESCRIPTION("WMI hotkeys driver for Dell All-In-One series");
+MODULE_LICENSE("GPL");
+
+#define EVENT_GUID1 "284A0E6B-380E-472A-921F-E52786257FB4"
+#define EVENT_GUID2 "02314822-307C-4F66-BF0E-48AEAEB26CC8"
+
+static const char *dell_wmi_aio_guids[] = {
+        EVENT_GUID1,
+        EVENT_GUID2,
+        NULL
+};
+
+MODULE_ALIAS("wmi:"EVENT_GUID1);
+MODULE_ALIAS("wmi:"EVENT_GUID2);
+
+static const struct key_entry dell_wmi_aio_keymap[] = {
+        { KE_KEY, 0xc0, { KEY_VOLUMEUP } },
+        { KE_KEY, 0xc1, { KEY_VOLUMEDOWN } },
+        { KE_END, 0 }
+};
+
+static struct input_dev *dell_wmi_aio_input_dev;
+
+static void dell_wmi_aio_notify(u32 value, void *context)
+{
+        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+
+        status = wmi_get_event_data(value, &response);
+        if (status != AE_OK) {
+                pr_info("bad event status 0x%x\n", status);
+                return;
+        }
+
+        obj = (union acpi_object *)response.pointer;
+        if (obj) {
+                unsigned int scancode;
+
+                switch (obj->type) {
+                case ACPI_TYPE_INTEGER:
+                        /* Most All-In-One correctly return integer scancode */
+                        scancode = obj->integer.value;
+                        sparse_keymap_report_event(dell_wmi_aio_input_dev,
+                                scancode, 1, true);
+                        break;
+                case ACPI_TYPE_BUFFER:
+                        /* Broken machines return the scancode in a buffer */
+                        if (obj->buffer.pointer && obj->buffer.length > 0) {
+                                scancode = obj->buffer.pointer[0];
+                                sparse_keymap_report_event(
+                                        dell_wmi_aio_input_dev,
+                                        scancode, 1, true);
+                        }
+                        break;
+                }
+        }
+        kfree(obj);
+}
+
+static int __init dell_wmi_aio_input_setup(void)
+{
+        int err;
+
+        dell_wmi_aio_input_dev = input_allocate_device();
+
+        if (!dell_wmi_aio_input_dev)
+                return -ENOMEM;
+
+        dell_wmi_aio_input_dev->name = "Dell AIO WMI hotkeys";
+        dell_wmi_aio_input_dev->phys = "wmi/input0";
+        dell_wmi_aio_input_dev->id.bustype = BUS_HOST;
+
+        err = sparse_keymap_setup(dell_wmi_aio_input_dev,
+                        dell_wmi_aio_keymap, NULL);
+        if (err) {
+                pr_err("Unable to setup input device keymap\n");
+                goto err_free_dev;
+        }
+        err = input_register_device(dell_wmi_aio_input_dev);
+        if (err) {
+                pr_info("Unable to register input device\n");
+                goto err_free_keymap;
+        }
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(dell_wmi_aio_input_dev);
+err_free_dev:
+        input_free_device(dell_wmi_aio_input_dev);
+        return err;
+}
+
+static const char *dell_wmi_aio_find(void)
+{
+        int i;
+
+        for (i = 0; dell_wmi_aio_guids[i] != NULL; i++)
+                if (wmi_has_guid(dell_wmi_aio_guids[i]))
+                        return dell_wmi_aio_guids[i];
+
+        return NULL;
+}
+
+static int __init dell_wmi_aio_init(void)
+{
+        int err;
+        const char *guid;
+
+        guid = dell_wmi_aio_find();
+        if (!guid) {
+                pr_warning("No known WMI GUID found\n");
+                return -ENXIO;
+        }
+
+        err = dell_wmi_aio_input_setup();
+        if (err)
+                return err;
+
+        err = wmi_install_notify_handler(guid, dell_wmi_aio_notify, NULL);
+        if (err) {
+                pr_err("Unable to register notify handler - %d\n", err);
+                sparse_keymap_free(dell_wmi_aio_input_dev);
+                input_unregister_device(dell_wmi_aio_input_dev);
+                return err;
+        }
+
+        return 0;
+}
+
+static void __exit dell_wmi_aio_exit(void)
+{
+        const char *guid;
+
+        guid = dell_wmi_aio_find();
+        wmi_remove_notify_handler(guid);
+        sparse_keymap_free(dell_wmi_aio_input_dev);
+        input_unregister_device(dell_wmi_aio_input_dev);
+}
+
+module_init(dell_wmi_aio_init);
+module_exit(dell_wmi_aio_exit);
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 6605beac0d0e..5f2dd386152b 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -1322,7 +1322,7 @@ static void cmsg_quirk(struct eeepc_laptop *eeepc, int cm, const char *name)
 {
         int dummy;
 
-        /* Some BIOSes do not report cm although it is avaliable.
+        /* Some BIOSes do not report cm although it is available.
            Check if cm_getv[cm] works and, if yes, assume cm should be set. */
         if (!(eeepc->cm_supported & (1 << cm))
             && !read_acpi_int(eeepc->handle, cm_getv[cm], &dummy)) {
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
index 4d38f98aa976..0ddc434fb93b 100644
--- a/drivers/platform/x86/eeepc-wmi.c
+++ b/drivers/platform/x86/eeepc-wmi.c
@@ -2,7 +2,7 @@
  * Eee PC WMI hotkey driver
  *
  * Copyright(C) 2010 Intel Corporation.
- * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
  *
  * Portions based on wistron_btns.c:
  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
@@ -29,841 +29,57 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
-#include <linux/types.h>
-#include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/input/sparse-keymap.h>
-#include <linux/fb.h>
-#include <linux/backlight.h>
-#include <linux/leds.h>
-#include <linux/rfkill.h>
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
-#include <linux/platform_device.h>
+#include <linux/dmi.h>
 #include <acpi/acpi_bus.h>
-#include <acpi/acpi_drivers.h>
+
+#include "asus-wmi.h"
 
 #define EEEPC_WMI_FILE  "eeepc-wmi"
 
-MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>");
 MODULE_DESCRIPTION("Eee PC WMI Hotkey Driver");
 MODULE_LICENSE("GPL");
 
 #define EEEPC_ACPI_HID          "ASUS010" /* old _HID used in eeepc-laptop */
 
 #define EEEPC_WMI_EVENT_GUID    "ABBC0F72-8EA1-11D1-00A0-C90629100000"
-#define EEEPC_WMI_MGMT_GUID     "97845ED0-4E6D-11DE-8A39-0800200C9A66"
 
 MODULE_ALIAS("wmi:"EEEPC_WMI_EVENT_GUID);
-MODULE_ALIAS("wmi:"EEEPC_WMI_MGMT_GUID);
-
-#define NOTIFY_BRNUP_MIN        0x11
-#define NOTIFY_BRNUP_MAX        0x1f
-#define NOTIFY_BRNDOWN_MIN      0x20
-#define NOTIFY_BRNDOWN_MAX      0x2e
 
-#define EEEPC_WMI_METHODID_DEVS 0x53564544
-#define EEEPC_WMI_METHODID_DSTS 0x53544344
-#define EEEPC_WMI_METHODID_CFVS 0x53564643
+static bool hotplug_wireless;
 
-#define EEEPC_WMI_DEVID_BACKLIGHT       0x00050012
-#define EEEPC_WMI_DEVID_TPDLED          0x00100011
-#define EEEPC_WMI_DEVID_WLAN            0x00010011
-#define EEEPC_WMI_DEVID_BLUETOOTH       0x00010013
-#define EEEPC_WMI_DEVID_WWAN3G          0x00010019
+module_param(hotplug_wireless, bool, 0444);
+MODULE_PARM_DESC(hotplug_wireless,
+                 "Enable hotplug for wireless device. "
+                 "If your laptop needs that, please report to "
+                 "acpi4asus-user@lists.sourceforge.net.");
 
 static const struct key_entry eeepc_wmi_keymap[] = {
         /* Sleep already handled via generic ACPI code */
-        { KE_KEY, 0x5d, { KEY_WLAN } },
-        { KE_KEY, 0x32, { KEY_MUTE } },
-        { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
         { KE_KEY, 0x30, { KEY_VOLUMEUP } },
-        { KE_IGNORE, NOTIFY_BRNDOWN_MIN, { KEY_BRIGHTNESSDOWN } },
-        { KE_IGNORE, NOTIFY_BRNUP_MIN, { KEY_BRIGHTNESSUP } },
+        { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
+        { KE_KEY, 0x32, { KEY_MUTE } },
+        { KE_KEY, 0x5c, { KEY_F15 } }, /* Power Gear key */
+        { KE_KEY, 0x5d, { KEY_WLAN } },
+        { KE_KEY, 0x6b, { KEY_TOUCHPAD_TOGGLE } }, /* Toggle Touchpad */
+        { KE_KEY, 0x82, { KEY_CAMERA } },
+        { KE_KEY, 0x83, { KEY_CAMERA_ZOOMIN } },
+        { KE_KEY, 0x88, { KEY_WLAN } },
         { KE_KEY, 0xcc, { KEY_SWITCHVIDEOMODE } },
-        { KE_KEY, 0x6b, { KEY_F13 } }, /* Disable Touchpad */
-        { KE_KEY, 0xe1, { KEY_F14 } },
-        { KE_KEY, 0xe9, { KEY_DISPLAY_OFF } },
-        { KE_KEY, 0xe0, { KEY_PROG1 } },
-        { KE_KEY, 0x5c, { KEY_F15 } },
+        { KE_KEY, 0xe0, { KEY_PROG1 } }, /* Task Manager */
+        { KE_KEY, 0xe1, { KEY_F14 } }, /* Change Resolution */
+        { KE_KEY, 0xe9, { KEY_BRIGHTNESS_ZERO } },
+        { KE_KEY, 0xeb, { KEY_CAMERA_ZOOMOUT } },
+        { KE_KEY, 0xec, { KEY_CAMERA_UP } },
+        { KE_KEY, 0xed, { KEY_CAMERA_DOWN } },
+        { KE_KEY, 0xee, { KEY_CAMERA_LEFT } },
+        { KE_KEY, 0xef, { KEY_CAMERA_RIGHT } },
         { KE_END, 0},
 };
 
-struct bios_args {
-        u32     dev_id;
-        u32     ctrl_param;
-};
-
-/*
- * eeepc-wmi/    - debugfs root directory
- *   dev_id      - current dev_id
- *   ctrl_param  - current ctrl_param
- *   devs        - call DEVS(dev_id, ctrl_param) and print result
- *   dsts        - call DSTS(dev_id)  and print result
- */
-struct eeepc_wmi_debug {
-        struct dentry *root;
-        u32 dev_id;
-        u32 ctrl_param;
-};
-
-struct eeepc_wmi {
-        struct input_dev *inputdev;
-        struct backlight_device *backlight_device;
-        struct platform_device *platform_device;
-
-        struct led_classdev tpd_led;
-        int tpd_led_wk;
-        struct workqueue_struct *led_workqueue;
-        struct work_struct tpd_led_work;
-
-        struct rfkill *wlan_rfkill;
-        struct rfkill *bluetooth_rfkill;
-        struct rfkill *wwan3g_rfkill;
-
-        struct eeepc_wmi_debug debug;
-};
-
-/* Only used in eeepc_wmi_init() and eeepc_wmi_exit() */
-static struct platform_device *platform_device;
-
-static int eeepc_wmi_input_init(struct eeepc_wmi *eeepc)
-{
-        int err;
-
-        eeepc->inputdev = input_allocate_device();
-        if (!eeepc->inputdev)
-                return -ENOMEM;
-
-        eeepc->inputdev->name = "Eee PC WMI hotkeys";
-        eeepc->inputdev->phys = EEEPC_WMI_FILE "/input0";
-        eeepc->inputdev->id.bustype = BUS_HOST;
-        eeepc->inputdev->dev.parent = &eeepc->platform_device->dev;
-
-        err = sparse_keymap_setup(eeepc->inputdev, eeepc_wmi_keymap, NULL);
-        if (err)
-                goto err_free_dev;
-
-        err = input_register_device(eeepc->inputdev);
-        if (err)
-                goto err_free_keymap;
-
-        return 0;
-
-err_free_keymap:
-        sparse_keymap_free(eeepc->inputdev);
-err_free_dev:
-        input_free_device(eeepc->inputdev);
-        return err;
-}
-
-static void eeepc_wmi_input_exit(struct eeepc_wmi *eeepc)
-{
-        if (eeepc->inputdev) {
-                sparse_keymap_free(eeepc->inputdev);
-                input_unregister_device(eeepc->inputdev);
-        }
-
-        eeepc->inputdev = NULL;
-}
-
-static acpi_status eeepc_wmi_get_devstate(u32 dev_id, u32 *retval)
-{
-        struct acpi_buffer input = { (acpi_size)sizeof(u32), &dev_id };
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
-        acpi_status status;
-        u32 tmp;
-
-        status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
-                        1, EEEPC_WMI_METHODID_DSTS, &input, &output);
-
-        if (ACPI_FAILURE(status))
-                return status;
-
-        obj = (union acpi_object *)output.pointer;
-        if (obj && obj->type == ACPI_TYPE_INTEGER)
-                tmp = (u32)obj->integer.value;
-        else
-                tmp = 0;
-
-        if (retval)
-                *retval = tmp;
-
-        kfree(obj);
-
-        return status;
-
-}
-
-static acpi_status eeepc_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
-                                          u32 *retval)
-{
-        struct bios_args args = {
-                .dev_id = dev_id,
-                .ctrl_param = ctrl_param,
-        };
-        struct acpi_buffer input = { (acpi_size)sizeof(args), &args };
-        acpi_status status;
-
-        if (!retval) {
-                status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
-                                             EEEPC_WMI_METHODID_DEVS,
-                                             &input, NULL);
-        } else {
-                struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-                union acpi_object *obj;
-                u32 tmp;
-
-                status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
-                                             EEEPC_WMI_METHODID_DEVS,
-                                             &input, &output);
-
-                if (ACPI_FAILURE(status))
-                        return status;
-
-                obj = (union acpi_object *)output.pointer;
-                if (obj && obj->type == ACPI_TYPE_INTEGER)
-                        tmp = (u32)obj->integer.value;
-                else
-                        tmp = 0;
-
-                *retval = tmp;
-
-                kfree(obj);
-        }
-
-        return status;
-}
-
-/*
- * LEDs
- */
-/*
- * These functions actually update the LED's, and are called from a
- * workqueue. By doing this as separate work rather than when the LED
- * subsystem asks, we avoid messing with the Eeepc ACPI stuff during a
- * potentially bad time, such as a timer interrupt.
- */
-static void tpd_led_update(struct work_struct *work)
-{
-        int ctrl_param;
-        struct eeepc_wmi *eeepc;
-
-        eeepc = container_of(work, struct eeepc_wmi, tpd_led_work);
-
-        ctrl_param = eeepc->tpd_led_wk;
-        eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_TPDLED, ctrl_param, NULL);
-}
-
-static void tpd_led_set(struct led_classdev *led_cdev,
-                        enum led_brightness value)
-{
-        struct eeepc_wmi *eeepc;
-
-        eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
-
-        eeepc->tpd_led_wk = !!value;
-        queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
-}
-
-static int read_tpd_state(struct eeepc_wmi *eeepc)
-{
-        u32 retval;
-        acpi_status status;
-
-        status = eeepc_wmi_get_devstate(EEEPC_WMI_DEVID_TPDLED, &retval);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-        else if (!retval || retval == 0x00060000)
-                /*
-                 * if touchpad led is present, DSTS will set some bits,
-                 * usually 0x00020000.
-                 * 0x00060000 means that the device is not supported
-                 */
-                return -ENODEV;
-        else
-                /* Status is stored in the first bit */
-                return retval & 0x1;
-}
-
-static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
-{
-        struct eeepc_wmi *eeepc;
-
-        eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
-
-        return read_tpd_state(eeepc);
-}
-
-static int eeepc_wmi_led_init(struct eeepc_wmi *eeepc)
-{
-        int rv;
-
-        if (read_tpd_state(eeepc) < 0)
-                return 0;
-
-        eeepc->led_workqueue = create_singlethread_workqueue("led_workqueue");
-        if (!eeepc->led_workqueue)
-                return -ENOMEM;
-        INIT_WORK(&eeepc->tpd_led_work, tpd_led_update);
-
-        eeepc->tpd_led.name = "eeepc::touchpad";
-        eeepc->tpd_led.brightness_set = tpd_led_set;
-        eeepc->tpd_led.brightness_get = tpd_led_get;
-        eeepc->tpd_led.max_brightness = 1;
-
-        rv = led_classdev_register(&eeepc->platform_device->dev,
-                                   &eeepc->tpd_led);
-        if (rv) {
-                destroy_workqueue(eeepc->led_workqueue);
-                return rv;
-        }
-
-        return 0;
-}
-
-static void eeepc_wmi_led_exit(struct eeepc_wmi *eeepc)
-{
-        if (eeepc->tpd_led.dev)
-                led_classdev_unregister(&eeepc->tpd_led);
-        if (eeepc->led_workqueue)
-                destroy_workqueue(eeepc->led_workqueue);
-}
-
-/*
- * Rfkill devices
- */
-static int eeepc_rfkill_set(void *data, bool blocked)
-{
-        int dev_id = (unsigned long)data;
-        u32 ctrl_param = !blocked;
-
-        return eeepc_wmi_set_devstate(dev_id, ctrl_param, NULL);
-}
-
-static void eeepc_rfkill_query(struct rfkill *rfkill, void *data)
-{
-        int dev_id = (unsigned long)data;
-        u32 retval;
-        acpi_status status;
-
-        status = eeepc_wmi_get_devstate(dev_id, &retval);
-
-        if (ACPI_FAILURE(status))
-                return ;
-
-        rfkill_set_sw_state(rfkill, !(retval & 0x1));
-}
-
-static const struct rfkill_ops eeepc_rfkill_ops = {
-        .set_block = eeepc_rfkill_set,
-        .query = eeepc_rfkill_query,
-};
-
-static int eeepc_new_rfkill(struct eeepc_wmi *eeepc,
-                            struct rfkill **rfkill,
-                            const char *name,
-                            enum rfkill_type type, int dev_id)
-{
-        int result;
-        u32 retval;
-        acpi_status status;
-
-        status = eeepc_wmi_get_devstate(dev_id, &retval);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-
-        /* If the device is present, DSTS will always set some bits
-         * 0x00070000 - 1110000000000000000 - device supported
-         * 0x00060000 - 1100000000000000000 - not supported
-         * 0x00020000 - 0100000000000000000 - device supported
-         * 0x00010000 - 0010000000000000000 - not supported / special mode ?
-         */
-        if (!retval || retval == 0x00060000)
-                return -ENODEV;
-
-        *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
-                               &eeepc_rfkill_ops, (void *)(long)dev_id);
-
-        if (!*rfkill)
-                return -EINVAL;
-
-        rfkill_init_sw_state(*rfkill, !(retval & 0x1));
-        result = rfkill_register(*rfkill);
-        if (result) {
-                rfkill_destroy(*rfkill);
-                *rfkill = NULL;
-                return result;
-        }
-        return 0;
-}
-
-static void eeepc_wmi_rfkill_exit(struct eeepc_wmi *eeepc)
-{
-        if (eeepc->wlan_rfkill) {
-                rfkill_unregister(eeepc->wlan_rfkill);
-                rfkill_destroy(eeepc->wlan_rfkill);
-                eeepc->wlan_rfkill = NULL;
-        }
-        if (eeepc->bluetooth_rfkill) {
-                rfkill_unregister(eeepc->bluetooth_rfkill);
-                rfkill_destroy(eeepc->bluetooth_rfkill);
-                eeepc->bluetooth_rfkill = NULL;
-        }
-        if (eeepc->wwan3g_rfkill) {
-                rfkill_unregister(eeepc->wwan3g_rfkill);
-                rfkill_destroy(eeepc->wwan3g_rfkill);
-                eeepc->wwan3g_rfkill = NULL;
-        }
-}
-
-static int eeepc_wmi_rfkill_init(struct eeepc_wmi *eeepc)
-{
-        int result = 0;
-
-        result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
-                                  "eeepc-wlan", RFKILL_TYPE_WLAN,
-                                  EEEPC_WMI_DEVID_WLAN);
-
-        if (result && result != -ENODEV)
-                goto exit;
-
-        result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
-                                  "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
-                                  EEEPC_WMI_DEVID_BLUETOOTH);
-
-        if (result && result != -ENODEV)
-                goto exit;
-
-        result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
-                                  "eeepc-wwan3g", RFKILL_TYPE_WWAN,
-                                  EEEPC_WMI_DEVID_WWAN3G);
-
-        if (result && result != -ENODEV)
-                goto exit;
-
-exit:
-        if (result && result != -ENODEV)
-                eeepc_wmi_rfkill_exit(eeepc);
-
-        if (result == -ENODEV)
-                result = 0;
-
-        return result;
-}
-
-/*
- * Backlight
- */
-static int read_brightness(struct backlight_device *bd)
-{
-        u32 retval;
-        acpi_status status;
-
-        status = eeepc_wmi_get_devstate(EEEPC_WMI_DEVID_BACKLIGHT, &retval);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-        else
-                return retval & 0xFF;
-}
-
-static int update_bl_status(struct backlight_device *bd)
-{
-
-        u32 ctrl_param;
-        acpi_status status;
-
-        ctrl_param = bd->props.brightness;
-
-        status = eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BACKLIGHT,
-                                        ctrl_param, NULL);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-        else
-                return 0;
-}
-
-static const struct backlight_ops eeepc_wmi_bl_ops = {
-        .get_brightness = read_brightness,
-        .update_status = update_bl_status,
-};
-
-static int eeepc_wmi_backlight_notify(struct eeepc_wmi *eeepc, int code)
-{
-        struct backlight_device *bd = eeepc->backlight_device;
-        int old = bd->props.brightness;
-        int new = old;
-
-        if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
-                new = code - NOTIFY_BRNUP_MIN + 1;
-        else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
-                new = code - NOTIFY_BRNDOWN_MIN;
-
-        bd->props.brightness = new;
-        backlight_update_status(bd);
-        backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
-
-        return old;
-}
-
-static int eeepc_wmi_backlight_init(struct eeepc_wmi *eeepc)
-{
-        struct backlight_device *bd;
-        struct backlight_properties props;
-
-        memset(&props, 0, sizeof(struct backlight_properties));
-        props.max_brightness = 15;
-        bd = backlight_device_register(EEEPC_WMI_FILE,
-                                       &eeepc->platform_device->dev, eeepc,
-                                       &eeepc_wmi_bl_ops, &props);
-        if (IS_ERR(bd)) {
-                pr_err("Could not register backlight device\n");
-                return PTR_ERR(bd);
-        }
-
-        eeepc->backlight_device = bd;
-
-        bd->props.brightness = read_brightness(bd);
-        bd->props.power = FB_BLANK_UNBLANK;
-        backlight_update_status(bd);
-
-        return 0;
-}
-
-static void eeepc_wmi_backlight_exit(struct eeepc_wmi *eeepc)
-{
-        if (eeepc->backlight_device)
-                backlight_device_unregister(eeepc->backlight_device);
-
-        eeepc->backlight_device = NULL;
-}
-
-static void eeepc_wmi_notify(u32 value, void *context)
-{
-        struct eeepc_wmi *eeepc = context;
-        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
-        acpi_status status;
-        int code;
-        int orig_code;
-
-        status = wmi_get_event_data(value, &response);
-        if (status != AE_OK) {
-                pr_err("bad event status 0x%x\n", status);
-                return;
-        }
-
-        obj = (union acpi_object *)response.pointer;
-
-        if (obj && obj->type == ACPI_TYPE_INTEGER) {
-                code = obj->integer.value;
-                orig_code = code;
-
-                if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
-                        code = NOTIFY_BRNUP_MIN;
-                else if (code >= NOTIFY_BRNDOWN_MIN &&
-                         code <= NOTIFY_BRNDOWN_MAX)
-                        code = NOTIFY_BRNDOWN_MIN;
-
-                if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
-                        if (!acpi_video_backlight_support())
-                                eeepc_wmi_backlight_notify(eeepc, orig_code);
-                }
-
-                if (!sparse_keymap_report_event(eeepc->inputdev,
-                                                code, 1, true))
-                        pr_info("Unknown key %x pressed\n", code);
-        }
-
-        kfree(obj);
-}
-
-static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
-                           const char *buf, size_t count)
-{
-        int value;
-        struct acpi_buffer input = { (acpi_size)sizeof(value), &value };
-        acpi_status status;
-
-        if (!count || sscanf(buf, "%i", &value) != 1)
-                return -EINVAL;
-        if (value < 0 || value > 2)
-                return -EINVAL;
-
-        status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
-                                     1, EEEPC_WMI_METHODID_CFVS, &input, NULL);
-
-        if (ACPI_FAILURE(status))
-                return -EIO;
-        else
-                return count;
-}
-
-static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
-
-static struct attribute *platform_attributes[] = {
-        &dev_attr_cpufv.attr,
-        NULL
-};
-
-static struct attribute_group platform_attribute_group = {
-        .attrs = platform_attributes
-};
-
-static void eeepc_wmi_sysfs_exit(struct platform_device *device)
-{
-        sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
-}
-
-static int eeepc_wmi_sysfs_init(struct platform_device *device)
-{
-        return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
-}
-
-/*
- * Platform device
- */
-static int __init eeepc_wmi_platform_init(struct eeepc_wmi *eeepc)
-{
-        int err;
-
-        eeepc->platform_device = platform_device_alloc(EEEPC_WMI_FILE, -1);
-        if (!eeepc->platform_device)
-                return -ENOMEM;
-        platform_set_drvdata(eeepc->platform_device, eeepc);
-
-        err = platform_device_add(eeepc->platform_device);
-        if (err)
-                goto fail_platform_device;
-
-        err = eeepc_wmi_sysfs_init(eeepc->platform_device);
-        if (err)
-                goto fail_sysfs;
-        return 0;
-
-fail_sysfs:
-        platform_device_del(eeepc->platform_device);
-fail_platform_device:
-        platform_device_put(eeepc->platform_device);
-        return err;
-}
-
-static void eeepc_wmi_platform_exit(struct eeepc_wmi *eeepc)
-{
-        eeepc_wmi_sysfs_exit(eeepc->platform_device);
-        platform_device_unregister(eeepc->platform_device);
-}
-
-/*
- * debugfs
- */
-struct eeepc_wmi_debugfs_node {
-        struct eeepc_wmi *eeepc;
-        char *name;
-        int (*show)(struct seq_file *m, void *data);
-};
-
-static int show_dsts(struct seq_file *m, void *data)
-{
-        struct eeepc_wmi *eeepc = m->private;
-        acpi_status status;
-        u32 retval = -1;
-
-        status = eeepc_wmi_get_devstate(eeepc->debug.dev_id, &retval);
-
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        seq_printf(m, "DSTS(%x) = %x\n", eeepc->debug.dev_id, retval);
-
-        return 0;
-}
-
-static int show_devs(struct seq_file *m, void *data)
-{
-        struct eeepc_wmi *eeepc = m->private;
-        acpi_status status;
-        u32 retval = -1;
-
-        status = eeepc_wmi_set_devstate(eeepc->debug.dev_id,
-                                        eeepc->debug.ctrl_param, &retval);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        seq_printf(m, "DEVS(%x, %x) = %x\n", eeepc->debug.dev_id,
-                   eeepc->debug.ctrl_param, retval);
-
-        return 0;
-}
-
-static struct eeepc_wmi_debugfs_node eeepc_wmi_debug_files[] = {
-        { NULL, "devs", show_devs },
-        { NULL, "dsts", show_dsts },
-};
-
-static int eeepc_wmi_debugfs_open(struct inode *inode, struct file *file)
-{
-        struct eeepc_wmi_debugfs_node *node = inode->i_private;
-
-        return single_open(file, node->show, node->eeepc);
-}
-
-static const struct file_operations eeepc_wmi_debugfs_io_ops = {
-        .owner = THIS_MODULE,
-        .open  = eeepc_wmi_debugfs_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-
-static void eeepc_wmi_debugfs_exit(struct eeepc_wmi *eeepc)
-{
-        debugfs_remove_recursive(eeepc->debug.root);
-}
-
-static int eeepc_wmi_debugfs_init(struct eeepc_wmi *eeepc)
-{
-        struct dentry *dent;
-        int i;
-
-        eeepc->debug.root = debugfs_create_dir(EEEPC_WMI_FILE, NULL);
-        if (!eeepc->debug.root) {
-                pr_err("failed to create debugfs directory");
-                goto error_debugfs;
-        }
-
-        dent = debugfs_create_x32("dev_id", S_IRUGO|S_IWUSR,
-                                  eeepc->debug.root, &eeepc->debug.dev_id);
-        if (!dent)
-                goto error_debugfs;
-
-        dent = debugfs_create_x32("ctrl_param", S_IRUGO|S_IWUSR,
-                                  eeepc->debug.root, &eeepc->debug.ctrl_param);
-        if (!dent)
-                goto error_debugfs;
-
-        for (i = 0; i < ARRAY_SIZE(eeepc_wmi_debug_files); i++) {
-                struct eeepc_wmi_debugfs_node *node = &eeepc_wmi_debug_files[i];
-
-                node->eeepc = eeepc;
-                dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
-                                           eeepc->debug.root, node,
-                                           &eeepc_wmi_debugfs_io_ops);
-                if (!dent) {
-                        pr_err("failed to create debug file: %s\n", node->name);
-                        goto error_debugfs;
-                }
-        }
-
-        return 0;
-
-error_debugfs:
-        eeepc_wmi_debugfs_exit(eeepc);
-        return -ENOMEM;
-}
-
-/*
- * WMI Driver
- */
-static struct platform_device * __init eeepc_wmi_add(void)
-{
-        struct eeepc_wmi *eeepc;
-        acpi_status status;
-        int err;
-
-        eeepc = kzalloc(sizeof(struct eeepc_wmi), GFP_KERNEL);
-        if (!eeepc)
-                return ERR_PTR(-ENOMEM);
-
-        /*
-         * Register the platform device first.  It is used as a parent for the
-         * sub-devices below.
-         */
-        err = eeepc_wmi_platform_init(eeepc);
-        if (err)
-                goto fail_platform;
-
-        err = eeepc_wmi_input_init(eeepc);
-        if (err)
-                goto fail_input;
-
-        err = eeepc_wmi_led_init(eeepc);
-        if (err)
-                goto fail_leds;
-
-        err = eeepc_wmi_rfkill_init(eeepc);
-        if (err)
-                goto fail_rfkill;
-
-        if (!acpi_video_backlight_support()) {
-                err = eeepc_wmi_backlight_init(eeepc);
-                if (err)
-                        goto fail_backlight;
-        } else
-                pr_info("Backlight controlled by ACPI video driver\n");
-
-        status = wmi_install_notify_handler(EEEPC_WMI_EVENT_GUID,
-                                            eeepc_wmi_notify, eeepc);
-        if (ACPI_FAILURE(status)) {
-                pr_err("Unable to register notify handler - %d\n",
-                        status);
-                err = -ENODEV;
-                goto fail_wmi_handler;
-        }
-
-        err = eeepc_wmi_debugfs_init(eeepc);
-        if (err)
-                goto fail_debugfs;
-
-        return eeepc->platform_device;
-
-fail_debugfs:
-        wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
-fail_wmi_handler:
-        eeepc_wmi_backlight_exit(eeepc);
-fail_backlight:
-        eeepc_wmi_rfkill_exit(eeepc);
-fail_rfkill:
-        eeepc_wmi_led_exit(eeepc);
-fail_leds:
-        eeepc_wmi_input_exit(eeepc);
-fail_input:
-        eeepc_wmi_platform_exit(eeepc);
-fail_platform:
-        kfree(eeepc);
-        return ERR_PTR(err);
-}
-
-static int eeepc_wmi_remove(struct platform_device *device)
-{
-        struct eeepc_wmi *eeepc;
-
-        eeepc = platform_get_drvdata(device);
-        wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
-        eeepc_wmi_backlight_exit(eeepc);
-        eeepc_wmi_input_exit(eeepc);
-        eeepc_wmi_led_exit(eeepc);
-        eeepc_wmi_rfkill_exit(eeepc);
-        eeepc_wmi_debugfs_exit(eeepc);
-        eeepc_wmi_platform_exit(eeepc);
-
-        kfree(eeepc);
-        return 0;
-}
-
-static struct platform_driver platform_driver = {
-        .driver = {
-                .name = EEEPC_WMI_FILE,
-                .owner = THIS_MODULE,
-        },
-};
-
-static acpi_status __init eeepc_wmi_parse_device(acpi_handle handle, u32 level,
+static acpi_status eeepc_wmi_parse_device(acpi_handle handle, u32 level,
                                                  void *context, void **retval)
 {
         pr_warning("Found legacy ATKD device (%s)", EEEPC_ACPI_HID);
@@ -871,7 +87,7 @@ static acpi_status __init eeepc_wmi_parse_device(acpi_handle handle, u32 level,
         return AE_CTRL_TERMINATE;
 }
 
-static int __init eeepc_wmi_check_atkd(void)
+static int eeepc_wmi_check_atkd(void)
 {
         acpi_status status;
         bool found = false;
@@ -884,16 +100,8 @@ static int __init eeepc_wmi_check_atkd(void)
         return -1;
 }
 
-static int __init eeepc_wmi_init(void)
+static int eeepc_wmi_probe(struct platform_device *pdev)
 {
-        int err;
-
-        if (!wmi_has_guid(EEEPC_WMI_EVENT_GUID) ||
-            !wmi_has_guid(EEEPC_WMI_MGMT_GUID)) {
-                pr_warning("No known WMI GUID found\n");
-                return -ENODEV;
-        }
-
         if (eeepc_wmi_check_atkd()) {
                 pr_warning("WMI device present, but legacy ATKD device is also "
                            "present and enabled.");
@@ -901,33 +109,59 @@ static int __init eeepc_wmi_init(void)
                            "acpi_osi=\"!Windows 2009\"");
                 pr_warning("Can't load eeepc-wmi, use default acpi_osi "
                            "(preferred) or eeepc-laptop");
-                return -ENODEV;
+                return -EBUSY;
         }
+        return 0;
+}
 
-        platform_device = eeepc_wmi_add();
-        if (IS_ERR(platform_device)) {
-                err = PTR_ERR(platform_device);
-                goto fail_eeepc_wmi;
-        }
+static void eeepc_dmi_check(struct asus_wmi_driver *driver)
+{
+        const char *model;
+
+        model = dmi_get_system_info(DMI_PRODUCT_NAME);
+        if (!model)
+                return;
 
-        err = platform_driver_register(&platform_driver);
-        if (err) {
-                pr_warning("Unable to register platform driver\n");
-                goto fail_platform_driver;
+        /*
+         * Whitelist for wlan hotplug
+         *
+         * Asus 1000H needs the current hotplug code to handle
+         * Fn+F2 correctly. We may add other Asus here later, but
+         * it seems that most of the laptops supported by asus-wmi
+         * don't need to be on this list
+         */
+        if (strcmp(model, "1000H") == 0) {
+                driver->hotplug_wireless = true;
+                pr_info("wlan hotplug enabled\n");
         }
+}
+
+static void eeepc_wmi_quirks(struct asus_wmi_driver *driver)
+{
+        driver->hotplug_wireless = hotplug_wireless;
+        eeepc_dmi_check(driver);
+}
+
+static struct asus_wmi_driver asus_wmi_driver = {
+        .name = EEEPC_WMI_FILE,
+        .owner = THIS_MODULE,
+        .event_guid = EEEPC_WMI_EVENT_GUID,
+        .keymap = eeepc_wmi_keymap,
+        .input_name = "Eee PC WMI hotkeys",
+        .input_phys = EEEPC_WMI_FILE "/input0",
+        .probe = eeepc_wmi_probe,
+        .quirks = eeepc_wmi_quirks,
+};
 
-        return 0;
 
-fail_platform_driver:
-        eeepc_wmi_remove(platform_device);
-fail_eeepc_wmi:
-        return err;
+static int __init eeepc_wmi_init(void)
+{
+        return asus_wmi_register_driver(&asus_wmi_driver);
 }
 
 static void __exit eeepc_wmi_exit(void)
 {
-        eeepc_wmi_remove(platform_device);
-        platform_driver_unregister(&platform_driver);
+        asus_wmi_unregister_driver(&asus_wmi_driver);
 }
 
 module_init(eeepc_wmi_init);
diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c
index 9e05af9c41cb..1bc4a7539ba9 100644
--- a/drivers/platform/x86/hp-wmi.c
+++ b/drivers/platform/x86/hp-wmi.c
@@ -2,6 +2,7 @@
  * HP WMI hotkeys
  *
  * Copyright (C) 2008 Red Hat <mjg@redhat.com>
+ * Copyright (C) 2010, 2011 Anssi Hannula <anssi.hannula@iki.fi>
  *
  * Portions based on wistron_btns.c:
  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
@@ -51,6 +52,7 @@ MODULE_ALIAS("wmi:5FB7F034-2C63-45e9-BE91-3D44E2C707E4");
 #define HPWMI_HARDWARE_QUERY 0x4
 #define HPWMI_WIRELESS_QUERY 0x5
 #define HPWMI_HOTKEY_QUERY 0xc
+#define HPWMI_WIRELESS2_QUERY 0x1b
 
 #define PREFIX "HP WMI: "
 #define UNIMP "Unimplemented "
@@ -86,7 +88,46 @@ struct bios_args {
 struct bios_return {
         u32 sigpass;
         u32 return_code;
-        u32 value;
+};
+
+enum hp_return_value {
+        HPWMI_RET_WRONG_SIGNATURE       = 0x02,
+        HPWMI_RET_UNKNOWN_COMMAND       = 0x03,
+        HPWMI_RET_UNKNOWN_CMDTYPE       = 0x04,
+        HPWMI_RET_INVALID_PARAMETERS    = 0x05,
+};
+
+enum hp_wireless2_bits {
+        HPWMI_POWER_STATE       = 0x01,
+        HPWMI_POWER_SOFT        = 0x02,
+        HPWMI_POWER_BIOS        = 0x04,
+        HPWMI_POWER_HARD        = 0x08,
+};
+
+#define IS_HWBLOCKED(x) ((x & (HPWMI_POWER_BIOS | HPWMI_POWER_HARD)) \
+                         != (HPWMI_POWER_BIOS | HPWMI_POWER_HARD))
+#define IS_SWBLOCKED(x) !(x & HPWMI_POWER_SOFT)
+
+struct bios_rfkill2_device_state {
+        u8 radio_type;
+        u8 bus_type;
+        u16 vendor_id;
+        u16 product_id;
+        u16 subsys_vendor_id;
+        u16 subsys_product_id;
+        u8 rfkill_id;
+        u8 power;
+        u8 unknown[4];
+};
+
+/* 7 devices fit into the 128 byte buffer */
+#define HPWMI_MAX_RFKILL2_DEVICES       7
+
+struct bios_rfkill2_state {
+        u8 unknown[7];
+        u8 count;
+        u8 pad[8];
+        struct bios_rfkill2_device_state device[HPWMI_MAX_RFKILL2_DEVICES];
 };
 
 static const struct key_entry hp_wmi_keymap[] = {
@@ -108,6 +149,15 @@ static struct rfkill *wifi_rfkill;
 static struct rfkill *bluetooth_rfkill;
 static struct rfkill *wwan_rfkill;
 
+struct rfkill2_device {
+        u8 id;
+        int num;
+        struct rfkill *rfkill;
+};
+
+static int rfkill2_count;
+static struct rfkill2_device rfkill2[HPWMI_MAX_RFKILL2_DEVICES];
+
 static const struct dev_pm_ops hp_wmi_pm_ops = {
         .resume  = hp_wmi_resume_handler,
         .restore  = hp_wmi_resume_handler,
@@ -129,7 +179,8 @@ static struct platform_driver hp_wmi_driver = {
  * query:       The commandtype -> What should be queried
  * write:       The command -> 0 read, 1 write, 3 ODM specific
  * buffer:      Buffer used as input and/or output
- * buffersize:  Size of buffer
+ * insize:      Size of input buffer
+ * outsize:     Size of output buffer
  *
  * returns zero on success
  *         an HP WMI query specific error code (which is positive)
@@ -140,25 +191,29 @@ static struct platform_driver hp_wmi_driver = {
  *       size. E.g. Battery info query (0x7) is defined to have 1 byte input
  *       and 128 byte output. The caller would do:
  *       buffer = kzalloc(128, GFP_KERNEL);
- *       ret = hp_wmi_perform_query(0x7, 0, buffer, 128)
+ *       ret = hp_wmi_perform_query(0x7, 0, buffer, 1, 128)
  */
-static int hp_wmi_perform_query(int query, int write, u32 *buffer,
-                                int buffersize)
+static int hp_wmi_perform_query(int query, int write, void *buffer,
+                                int insize, int outsize)
 {
-        struct bios_return bios_return;
-        acpi_status status;
+        struct bios_return *bios_return;
+        int actual_outsize;
         union acpi_object *obj;
         struct bios_args args = {
                 .signature = 0x55434553,
                 .command = write ? 0x2 : 0x1,
                 .commandtype = query,
-                .datasize = buffersize,
-                .data = *buffer,
+                .datasize = insize,
+                .data = 0,
         };
         struct acpi_buffer input = { sizeof(struct bios_args), &args };
         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 
-        status = wmi_evaluate_method(HPWMI_BIOS_GUID, 0, 0x3, &input, &output);
+        if (WARN_ON(insize > sizeof(args.data)))
+                return -EINVAL;
+        memcpy(&args.data, buffer, insize);
+
+        wmi_evaluate_method(HPWMI_BIOS_GUID, 0, 0x3, &input, &output);
 
         obj = output.pointer;
 
@@ -169,10 +224,26 @@ static int hp_wmi_perform_query(int query, int write, u32 *buffer,
                 return -EINVAL;
         }
 
-        bios_return = *((struct bios_return *)obj->buffer.pointer);
+        bios_return = (struct bios_return *)obj->buffer.pointer;
 
-        memcpy(buffer, &bios_return.value, sizeof(bios_return.value));
+        if (bios_return->return_code) {
+                if (bios_return->return_code != HPWMI_RET_UNKNOWN_CMDTYPE)
+                        printk(KERN_WARNING PREFIX "query 0x%x returned "
+                                                   "error 0x%x\n",
+                               query, bios_return->return_code);
+                kfree(obj);
+                return bios_return->return_code;
+        }
+
+        if (!outsize) {
+                /* ignore output data */
+                kfree(obj);
+                return 0;
+        }
 
+        actual_outsize = min(outsize, (int)(obj->buffer.length - sizeof(*bios_return)));
+        memcpy(buffer, obj->buffer.pointer + sizeof(*bios_return), actual_outsize);
+        memset(buffer + actual_outsize, 0, outsize - actual_outsize);
         kfree(obj);
         return 0;
 }
@@ -181,7 +252,7 @@ static int hp_wmi_display_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_DISPLAY_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return -EINVAL;
         return state;
@@ -191,7 +262,7 @@ static int hp_wmi_hddtemp_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_HDDTEMP_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return -EINVAL;
         return state;
@@ -201,7 +272,7 @@ static int hp_wmi_als_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return -EINVAL;
         return state;
@@ -211,7 +282,7 @@ static int hp_wmi_dock_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
 
         if (ret)
                 return -EINVAL;
@@ -223,7 +294,7 @@ static int hp_wmi_tablet_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return ret;
 
@@ -237,7 +308,7 @@ static int hp_wmi_set_block(void *data, bool blocked)
         int ret;
 
         ret = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1,
-                                   &query, sizeof(query));
+                                   &query, sizeof(query), 0);
         if (ret)
                 return -EINVAL;
         return 0;
@@ -252,7 +323,8 @@ static bool hp_wmi_get_sw_state(enum hp_wmi_radio r)
         int wireless = 0;
         int mask;
         hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
-                             &wireless, sizeof(wireless));
+                             &wireless, sizeof(wireless),
+                             sizeof(wireless));
         /* TBD: Pass error */
 
         mask = 0x200 << (r * 8);
@@ -268,7 +340,8 @@ static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)
         int wireless = 0;
         int mask;
         hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
-                             &wireless, sizeof(wireless));
+                             &wireless, sizeof(wireless),
+                             sizeof(wireless));
         /* TBD: Pass error */
 
         mask = 0x800 << (r * 8);
@@ -279,6 +352,51 @@ static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)
                 return true;
 }
 
+static int hp_wmi_rfkill2_set_block(void *data, bool blocked)
+{
+        int rfkill_id = (int)(long)data;
+        char buffer[4] = { 0x01, 0x00, rfkill_id, !blocked };
+
+        if (hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 1,
+                                   buffer, sizeof(buffer), 0))
+                return -EINVAL;
+        return 0;
+}
+
+static const struct rfkill_ops hp_wmi_rfkill2_ops = {
+        .set_block = hp_wmi_rfkill2_set_block,
+};
+
+static int hp_wmi_rfkill2_refresh(void)
+{
+        int err, i;
+        struct bios_rfkill2_state state;
+
+        err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
+                                   0, sizeof(state));
+        if (err)
+                return err;
+
+        for (i = 0; i < rfkill2_count; i++) {
+                int num = rfkill2[i].num;
+                struct bios_rfkill2_device_state *devstate;
+                devstate = &state.device[num];
+
+                if (num >= state.count ||
+                    devstate->rfkill_id != rfkill2[i].id) {
+                        printk(KERN_WARNING PREFIX "power configuration of "
+                               "the wireless devices unexpectedly changed\n");
+                        continue;
+                }
+
+                rfkill_set_states(rfkill2[i].rfkill,
+                                  IS_SWBLOCKED(devstate->power),
+                                  IS_HWBLOCKED(devstate->power));
+        }
+
+        return 0;
+}
+
 static ssize_t show_display(struct device *dev, struct device_attribute *attr,
                             char *buf)
 {
@@ -329,7 +447,7 @@ static ssize_t set_als(struct device *dev, struct device_attribute *attr,
 {
         u32 tmp = simple_strtoul(buf, NULL, 10);
         int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 1, &tmp,
-                                       sizeof(tmp));
+                                       sizeof(tmp), sizeof(tmp));
         if (ret)
                 return -EINVAL;
 
@@ -402,6 +520,7 @@ static void hp_wmi_notify(u32 value, void *context)
         case HPWMI_BEZEL_BUTTON:
                 ret = hp_wmi_perform_query(HPWMI_HOTKEY_QUERY, 0,
                                            &key_code,
+                                           sizeof(key_code),
                                            sizeof(key_code));
                 if (ret)
                         break;
@@ -412,6 +531,11 @@ static void hp_wmi_notify(u32 value, void *context)
                                key_code);
                 break;
         case HPWMI_WIRELESS:
+                if (rfkill2_count) {
+                        hp_wmi_rfkill2_refresh();
+                        break;
+                }
+
                 if (wifi_rfkill)
                         rfkill_set_states(wifi_rfkill,
                                           hp_wmi_get_sw_state(HPWMI_WIFI),
@@ -502,32 +626,16 @@ static void cleanup_sysfs(struct platform_device *device)
         device_remove_file(&device->dev, &dev_attr_tablet);
 }
 
-static int __devinit hp_wmi_bios_setup(struct platform_device *device)
+static int __devinit hp_wmi_rfkill_setup(struct platform_device *device)
 {
         int err;
         int wireless = 0;
 
         err = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0, &wireless,
-                                   sizeof(wireless));
+                                   sizeof(wireless), sizeof(wireless));
         if (err)
                 return err;
 
-        err = device_create_file(&device->dev, &dev_attr_display);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_hddtemp);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_als);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_dock);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_tablet);
-        if (err)
-                goto add_sysfs_error;
-
         if (wireless & 0x1) {
                 wifi_rfkill = rfkill_alloc("hp-wifi", &device->dev,
                                            RFKILL_TYPE_WLAN,
@@ -573,14 +681,131 @@ static int __devinit hp_wmi_bios_setup(struct platform_device *device)
         return 0;
 register_wwan_err:
         rfkill_destroy(wwan_rfkill);
+        wwan_rfkill = NULL;
         if (bluetooth_rfkill)
                 rfkill_unregister(bluetooth_rfkill);
 register_bluetooth_error:
         rfkill_destroy(bluetooth_rfkill);
+        bluetooth_rfkill = NULL;
         if (wifi_rfkill)
                 rfkill_unregister(wifi_rfkill);
 register_wifi_error:
         rfkill_destroy(wifi_rfkill);
+        wifi_rfkill = NULL;
+        return err;
+}
+
+static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
+{
+        int err, i;
+        struct bios_rfkill2_state state;
+        err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
+                                   0, sizeof(state));
+        if (err)
+                return err;
+
+        if (state.count > HPWMI_MAX_RFKILL2_DEVICES) {
+                printk(KERN_WARNING PREFIX "unable to parse 0x1b query output\n");
+                return -EINVAL;
+        }
+
+        for (i = 0; i < state.count; i++) {
+                struct rfkill *rfkill;
+                enum rfkill_type type;
+                char *name;
+                switch (state.device[i].radio_type) {
+                case HPWMI_WIFI:
+                        type = RFKILL_TYPE_WLAN;
+                        name = "hp-wifi";
+                        break;
+                case HPWMI_BLUETOOTH:
+                        type = RFKILL_TYPE_BLUETOOTH;
+                        name = "hp-bluetooth";
+                        break;
+                case HPWMI_WWAN:
+                        type = RFKILL_TYPE_WWAN;
+                        name = "hp-wwan";
+                        break;
+                default:
+                        printk(KERN_WARNING PREFIX "unknown device type 0x%x\n",
+                                 state.device[i].radio_type);
+                        continue;
+                }
+
+                if (!state.device[i].vendor_id) {
+                        printk(KERN_WARNING PREFIX "zero device %d while %d "
+                               "reported\n", i, state.count);
+                        continue;
+                }
+
+                rfkill = rfkill_alloc(name, &device->dev, type,
+                                      &hp_wmi_rfkill2_ops, (void *)(long)i);
+                if (!rfkill) {
+                        err = -ENOMEM;
+                        goto fail;
+                }
+
+                rfkill2[rfkill2_count].id = state.device[i].rfkill_id;
+                rfkill2[rfkill2_count].num = i;
+                rfkill2[rfkill2_count].rfkill = rfkill;
+
+                rfkill_init_sw_state(rfkill,
+                                     IS_SWBLOCKED(state.device[i].power));
+                rfkill_set_hw_state(rfkill,
+                                    IS_HWBLOCKED(state.device[i].power));
+
+                if (!(state.device[i].power & HPWMI_POWER_BIOS))
+                        printk(KERN_INFO PREFIX "device %s blocked by BIOS\n",
+                               name);
+
+                err = rfkill_register(rfkill);
+                if (err) {
+                        rfkill_destroy(rfkill);
+                        goto fail;
+                }
+
+                rfkill2_count++;
+        }
+
+        return 0;
+fail:
+        for (; rfkill2_count > 0; rfkill2_count--) {
+                rfkill_unregister(rfkill2[rfkill2_count - 1].rfkill);
+                rfkill_destroy(rfkill2[rfkill2_count - 1].rfkill);
+        }
+        return err;
+}
+
+static int __devinit hp_wmi_bios_setup(struct platform_device *device)
+{
+        int err;
+
+        /* clear detected rfkill devices */
+        wifi_rfkill = NULL;
+        bluetooth_rfkill = NULL;
+        wwan_rfkill = NULL;
+        rfkill2_count = 0;
+
+        if (hp_wmi_rfkill_setup(device))
+                hp_wmi_rfkill2_setup(device);
+
+        err = device_create_file(&device->dev, &dev_attr_display);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_hddtemp);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_als);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_dock);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_tablet);
+        if (err)
+                goto add_sysfs_error;
+        return 0;
+
 add_sysfs_error:
         cleanup_sysfs(device);
         return err;
@@ -588,8 +813,14 @@ add_sysfs_error:
 
 static int __exit hp_wmi_bios_remove(struct platform_device *device)
 {
+        int i;
         cleanup_sysfs(device);
 
+        for (i = 0; i < rfkill2_count; i++) {
+                rfkill_unregister(rfkill2[i].rfkill);
+                rfkill_destroy(rfkill2[i].rfkill);
+        }
+
         if (wifi_rfkill) {
                 rfkill_unregister(wifi_rfkill);
                 rfkill_destroy(wifi_rfkill);
@@ -622,6 +853,9 @@ static int hp_wmi_resume_handler(struct device *device)
                 input_sync(hp_wmi_input_dev);
         }
 
+        if (rfkill2_count)
+                hp_wmi_rfkill2_refresh();
+
         if (wifi_rfkill)
                 rfkill_set_states(wifi_rfkill,
                                   hp_wmi_get_sw_state(HPWMI_WIFI),
diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index 114d95247cdf..21b101899bae 100644
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -459,6 +459,8 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
                 if (test_bit(vpc_bit, &vpc1)) {
                         if (vpc_bit == 9)
                                 ideapad_sync_rfk_state(adevice);
+                        else if (vpc_bit == 4)
+                                read_ec_data(handle, 0x12, &vpc2);
                         else
                                 ideapad_input_report(priv, vpc_bit);
                 }
diff --git a/drivers/platform/x86/intel_ips.c b/drivers/platform/x86/intel_ips.c
index 1294a39373ba..85c8ad43c0c5 100644
--- a/drivers/platform/x86/intel_ips.c
+++ b/drivers/platform/x86/intel_ips.c
@@ -1111,7 +1111,7 @@ static int ips_monitor(void *data)
                 last_msecs = jiffies_to_msecs(jiffies);
                 expire = jiffies + msecs_to_jiffies(IPS_SAMPLE_PERIOD);
 
-                __set_current_state(TASK_UNINTERRUPTIBLE);
+                __set_current_state(TASK_INTERRUPTIBLE);
                 mod_timer(&timer, expire);
                 schedule();
 
diff --git a/drivers/platform/x86/intel_mid_powerbtn.c b/drivers/platform/x86/intel_mid_powerbtn.c
new file mode 100644
index 000000000000..213e79ba68d5
--- /dev/null
+++ b/drivers/platform/x86/intel_mid_powerbtn.c
@@ -0,0 +1,148 @@
+/*
+ * Power button driver for Medfield.
+ *
+ * Copyright (C) 2010 Intel Corp
+ *
+ * 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; version 2 of the License.
+ *
+ * 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; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <asm/intel_scu_ipc.h>
+
+#define DRIVER_NAME "msic_power_btn"
+
+#define MSIC_IRQ_STAT   0x02
+  #define MSIC_IRQ_PB   (1 << 0)
+#define MSIC_PB_CONFIG  0x3e
+#define MSIC_PB_STATUS  0x3f
+  #define MSIC_PB_LEVEL (1 << 3) /* 1 - release, 0 - press */
+
+struct mfld_pb_priv {
+        struct input_dev *input;
+        unsigned int irq;
+};
+
+static irqreturn_t mfld_pb_isr(int irq, void *dev_id)
+{
+        struct mfld_pb_priv *priv = dev_id;
+        int ret;
+        u8 pbstat;
+
+        ret = intel_scu_ipc_ioread8(MSIC_PB_STATUS, &pbstat);
+        if (ret < 0)
+                return IRQ_HANDLED;
+
+        input_event(priv->input, EV_KEY, KEY_POWER, !(pbstat & MSIC_PB_LEVEL));
+        input_sync(priv->input);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit mfld_pb_probe(struct platform_device *pdev)
+{
+        struct mfld_pb_priv *priv;
+        struct input_dev *input;
+        int irq;
+        int error;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return -EINVAL;
+
+        priv = kzalloc(sizeof(struct mfld_pb_priv), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!priv || !input) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        priv->input = input;
+        priv->irq = irq;
+
+        input->name = pdev->name;
+        input->phys = "power-button/input0";
+        input->id.bustype = BUS_HOST;
+        input->dev.parent = &pdev->dev;
+
+        input_set_capability(input, EV_KEY, KEY_POWER);
+
+        error = request_threaded_irq(priv->irq, NULL, mfld_pb_isr,
+                                     0, DRIVER_NAME, priv);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "unable to request irq %d for mfld power button\n",
+                        irq);
+                goto err_free_mem;
+        }
+
+        error = input_register_device(input);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "unable to register input dev, error %d\n", error);
+                goto err_free_irq;
+        }
+
+        platform_set_drvdata(pdev, priv);
+        return 0;
+
+err_free_irq:
+        free_irq(priv->irq, priv);
+err_free_mem:
+        input_free_device(input);
+        kfree(priv);
+        return error;
+}
+
+static int __devexit mfld_pb_remove(struct platform_device *pdev)
+{
+        struct mfld_pb_priv *priv = platform_get_drvdata(pdev);
+
+        free_irq(priv->irq, priv);
+        input_unregister_device(priv->input);
+        kfree(priv);
+
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+static struct platform_driver mfld_pb_driver = {
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe  = mfld_pb_probe,
+        .remove = __devexit_p(mfld_pb_remove),
+};
+
+static int __init mfld_pb_init(void)
+{
+        return platform_driver_register(&mfld_pb_driver);
+}
+module_init(mfld_pb_init);
+
+static void __exit mfld_pb_exit(void)
+{
+        platform_driver_unregister(&mfld_pb_driver);
+}
+module_exit(mfld_pb_exit);
+
+MODULE_AUTHOR("Hong Liu <hong.liu@intel.com>");
+MODULE_DESCRIPTION("Intel Medfield Power Button Driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c
new file mode 100644
index 000000000000..6c12db503161
--- /dev/null
+++ b/drivers/platform/x86/intel_mid_thermal.c
@@ -0,0 +1,576 @@
+/*
+ * intel_mid_thermal.c - Intel MID platform thermal driver
+ *
+ * Copyright (C) 2011 Intel Corporation
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * 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; version 2 of the License.
+ *
+ * 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; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * Author: Durgadoss R <durgadoss.r@intel.com>
+ */
+
+#define pr_fmt(fmt) "intel_mid_thermal: " fmt
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/param.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/pm.h>
+#include <linux/thermal.h>
+
+#include <asm/intel_scu_ipc.h>
+
+/* Number of thermal sensors */
+#define MSIC_THERMAL_SENSORS   4
+
+/* ADC1 - thermal registers */
+#define MSIC_THERM_ADC1CNTL1   0x1C0
+#define MSIC_ADC_ENBL          0x10
+#define MSIC_ADC_START         0x08
+
+#define MSIC_THERM_ADC1CNTL3   0x1C2
+#define MSIC_ADCTHERM_ENBL     0x04
+#define MSIC_ADCRRDATA_ENBL    0x05
+#define MSIC_CHANL_MASK_VAL    0x0F
+
+#define MSIC_STOPBIT_MASK      16
+#define MSIC_ADCTHERM_MASK     4
+#define ADC_CHANLS_MAX         15 /* Number of ADC channels */
+#define ADC_LOOP_MAX           (ADC_CHANLS_MAX - MSIC_THERMAL_SENSORS)
+
+/* ADC channel code values */
+#define SKIN_SENSOR0_CODE      0x08
+#define SKIN_SENSOR1_CODE      0x09
+#define SYS_SENSOR_CODE                0x0A
+#define MSIC_DIE_SENSOR_CODE   0x03
+
+#define SKIN_THERM_SENSOR0     0
+#define SKIN_THERM_SENSOR1     1
+#define SYS_THERM_SENSOR2      2
+#define MSIC_DIE_THERM_SENSOR3 3
+
+/* ADC code range */
+#define ADC_MAX                        977
+#define ADC_MIN                        162
+#define ADC_VAL0C              887
+#define ADC_VAL20C             720
+#define ADC_VAL40C             508
+#define ADC_VAL60C             315
+
+/* ADC base addresses */
+#define ADC_CHNL_START_ADDR    0x1C5   /* increments by 1 */
+#define ADC_DATA_START_ADDR     0x1D4   /* increments by 2 */
+
+/* MSIC die attributes */
+#define MSIC_DIE_ADC_MIN       488
+#define MSIC_DIE_ADC_MAX       1004
+
+/* This holds the address of the first free ADC channel,
+ * among the 15 channels
+ */
+static int channel_index;
+
+struct platform_info {
+       struct platform_device *pdev;
+       struct thermal_zone_device *tzd[MSIC_THERMAL_SENSORS];
+};
+
+struct thermal_device_info {
+       unsigned int chnl_addr;
+       int direct;
+       /* This holds the current temperature in millidegree celsius */
+       long curr_temp;
+};
+
+/**
+ * to_msic_die_temp - converts adc_val to msic_die temperature
+ * @adc_val: ADC value to be converted
+ *
+ * Can sleep
+ */
+static int to_msic_die_temp(uint16_t adc_val)
+{
+       return (368 * (adc_val) / 1000) - 220;
+}
+
+/**
+ * is_valid_adc - checks whether the adc code is within the defined range
+ * @min: minimum value for the sensor
+ * @max: maximum value for the sensor
+ *
+ * Can sleep
+ */
+static int is_valid_adc(uint16_t adc_val, uint16_t min, uint16_t max)
+{
+       return (adc_val >= min) && (adc_val <= max);
+}
+
+/**
+ * adc_to_temp - converts the ADC code to temperature in C
+ * @direct: true if ths channel is direct index
+ * @adc_val: the adc_val that needs to be converted
+ * @tp: temperature return value
+ *
+ * Linear approximation is used to covert the skin adc value into temperature.
+ * This technique is used to avoid very long look-up table to get
+ * the appropriate temp value from ADC value.
+ * The adc code vs sensor temp curve is split into five parts
+ * to achieve very close approximate temp value with less than
+ * 0.5C error
+ */
+static int adc_to_temp(int direct, uint16_t adc_val, unsigned long *tp)
+{
+       int temp;
+
+       /* Direct conversion for die temperature */
+       if (direct) {
+               if (is_valid_adc(adc_val, MSIC_DIE_ADC_MIN, MSIC_DIE_ADC_MAX)) {
+                       *tp = to_msic_die_temp(adc_val) * 1000;
+                       return 0;
+               }
+               return -ERANGE;
+       }
+
+       if (!is_valid_adc(adc_val, ADC_MIN, ADC_MAX))
+               return -ERANGE;
+
+       /* Linear approximation for skin temperature */
+       if (adc_val > ADC_VAL0C)
+               temp = 177 - (adc_val/5);
+       else if ((adc_val <= ADC_VAL0C) && (adc_val > ADC_VAL20C))
+               temp = 111 - (adc_val/8);
+       else if ((adc_val <= ADC_VAL20C) && (adc_val > ADC_VAL40C))
+               temp = 92 - (adc_val/10);
+       else if ((adc_val <= ADC_VAL40C) && (adc_val > ADC_VAL60C))
+               temp = 91 - (adc_val/10);
+       else
+               temp = 112 - (adc_val/6);
+
+       /* Convert temperature in celsius to milli degree celsius */
+       *tp = temp * 1000;
+       return 0;
+}
+
+/**
+ * mid_read_temp - read sensors for temperature
+ * @temp: holds the current temperature for the sensor after reading
+ *
+ * reads the adc_code from the channel and converts it to real
+ * temperature. The converted value is stored in temp.
+ *
+ * Can sleep
+ */
+static int mid_read_temp(struct thermal_zone_device *tzd, unsigned long *temp)
+{
+       struct thermal_device_info *td_info = tzd->devdata;
+       uint16_t adc_val, addr;
+       uint8_t data = 0;
+       int ret;
+       unsigned long curr_temp;
+
+
+       addr = td_info->chnl_addr;
+
+       /* Enable the msic for conversion before reading */
+       ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCRRDATA_ENBL);
+       if (ret)
+               return ret;
+
+       /* Re-toggle the RRDATARD bit (temporary workaround) */
+       ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCTHERM_ENBL);
+       if (ret)
+               return ret;
+
+       /* Read the higher bits of data */
+       ret = intel_scu_ipc_ioread8(addr, &data);
+       if (ret)
+               return ret;
+
+       /* Shift bits to accomodate the lower two data bits */
+       adc_val = (data << 2);
+       addr++;
+
+       ret = intel_scu_ipc_ioread8(addr, &data);/* Read lower bits */
+       if (ret)
+               return ret;
+
+       /* Adding lower two bits to the higher bits */
+       data &= 03;
+       adc_val += data;
+
+       /* Convert ADC value to temperature */
+       ret = adc_to_temp(td_info->direct, adc_val, &curr_temp);
+       if (ret == 0)
+               *temp = td_info->curr_temp = curr_temp;
+       return ret;
+}
+
+/**
+ * configure_adc - enables/disables the ADC for conversion
+ * @val: zero: disables the ADC non-zero:enables the ADC
+ *
+ * Enable/Disable the ADC depending on the argument
+ *
+ * Can sleep
+ */
+static int configure_adc(int val)
+{
+       int ret;
+       uint8_t data;
+
+       ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
+       if (ret)
+               return ret;
+
+       if (val) {
+               /* Enable and start the ADC */
+               data |= (MSIC_ADC_ENBL | MSIC_ADC_START);
+       } else {
+               /* Just stop the ADC */
+               data &= (~MSIC_ADC_START);
+       }
+
+       return intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL1, data);
+}
+
+/**
+ * set_up_therm_channel - enable thermal channel for conversion
+ * @base_addr: index of free msic ADC channel
+ *
+ * Enable all the three channels for conversion
+ *
+ * Can sleep
+ */
+static int set_up_therm_channel(u16 base_addr)
+{
+       int ret;
+
+       /* Enable all the sensor channels */
+       ret = intel_scu_ipc_iowrite8(base_addr, SKIN_SENSOR0_CODE);
+       if (ret)
+               return ret;
+
+       ret = intel_scu_ipc_iowrite8(base_addr + 1, SKIN_SENSOR1_CODE);
+       if (ret)
+               return ret;
+
+       ret = intel_scu_ipc_iowrite8(base_addr + 2, SYS_SENSOR_CODE);
+       if (ret)
+               return ret;
+
+       /* Since this is the last channel, set the stop bit
+          to 1 by ORing the DIE_SENSOR_CODE with 0x10 */
+       ret = intel_scu_ipc_iowrite8(base_addr + 3,
+                                       (MSIC_DIE_SENSOR_CODE | 0x10));
+       if (ret)
+               return ret;
+
+       /* Enable ADC and start it */
+       return configure_adc(1);
+}
+
+/**
+ * reset_stopbit - sets the stop bit to 0 on the given channel
+ * @addr: address of the channel
+ *
+ * Can sleep
+ */
+static int reset_stopbit(uint16_t addr)
+{
+       int ret;
+       uint8_t data;
+       ret = intel_scu_ipc_ioread8(addr, &data);
+       if (ret)
+               return ret;
+       /* Set the stop bit to zero */
+       return intel_scu_ipc_iowrite8(addr, (data & 0xEF));
+}
+
+/**
+ * find_free_channel - finds an empty channel for conversion
+ *
+ * If the ADC is not enabled then start using 0th channel
+ * itself. Otherwise find an empty channel by looking for a
+ * channel in which the stopbit is set to 1. returns the index
+ * of the first free channel if succeeds or an error code.
+ *
+ * Context: can sleep
+ *
+ * FIXME: Ultimately the channel allocator will move into the intel_scu_ipc
+ * code.
+ */
+static int find_free_channel(void)
+{
+       int ret;
+       int i;
+       uint8_t data;
+
+       /* check whether ADC is enabled */
+       ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
+       if (ret)
+               return ret;
+
+       if ((data & MSIC_ADC_ENBL) == 0)
+               return 0;
+
+       /* ADC is already enabled; Looking for an empty channel */
+       for (i = 0; i < ADC_CHANLS_MAX; i++) {
+               ret = intel_scu_ipc_ioread8(ADC_CHNL_START_ADDR + i, &data);
+               if (ret)
+                       return ret;
+
+               if (data & MSIC_STOPBIT_MASK) {
+                       ret = i;
+                       break;
+               }
+       }
+       return (ret > ADC_LOOP_MAX) ? (-EINVAL) : ret;
+}
+
+/**
+ * mid_initialize_adc - initializing the ADC
+ * @dev: our device structure
+ *
+ * Initialize the ADC for reading thermistor values. Can sleep.
+ */
+static int mid_initialize_adc(struct device *dev)
+{
+       u8  data;
+       u16 base_addr;
+       int ret;
+
+       /*
+        * Ensure that adctherm is disabled before we
+        * initialize the ADC
+        */
+       ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL3, &data);
+       if (ret)
+               return ret;
+
+       if (data & MSIC_ADCTHERM_MASK)
+               dev_warn(dev, "ADCTHERM already set");
+
+       /* Index of the first channel in which the stop bit is set */
+       channel_index = find_free_channel();
+       if (channel_index < 0) {
+               dev_err(dev, "No free ADC channels");
+               return channel_index;
+       }
+
+       base_addr = ADC_CHNL_START_ADDR + channel_index;
+
+       if (!(channel_index == 0 || channel_index == ADC_LOOP_MAX)) {
+               /* Reset stop bit for channels other than 0 and 12 */
+               ret = reset_stopbit(base_addr);
+               if (ret)
+                       return ret;
+
+               /* Index of the first free channel */
+               base_addr++;
+               channel_index++;
+       }
+
+       ret = set_up_therm_channel(base_addr);
+       if (ret) {
+               dev_err(dev, "unable to enable ADC");
+               return ret;
+       }
+       dev_dbg(dev, "ADC initialization successful");
+       return ret;
+}
+
+/**
+ * initialize_sensor - sets default temp and timer ranges
+ * @index: index of the sensor
+ *
+ * Context: can sleep
+ */
+static struct thermal_device_info *initialize_sensor(int index)
+{
+       struct thermal_device_info *td_info =
+               kzalloc(sizeof(struct thermal_device_info), GFP_KERNEL);
+
+       if (!td_info)
+               return NULL;
+
+       /* Set the base addr of the channel for this sensor */
+       td_info->chnl_addr = ADC_DATA_START_ADDR + 2 * (channel_index + index);
+       /* Sensor 3 is direct conversion */
+       if (index == 3)
+               td_info->direct = 1;
+       return td_info;
+}
+
+/**
+ * mid_thermal_resume - resume routine
+ * @pdev: platform device structure
+ *
+ * mid thermal resume: re-initializes the adc. Can sleep.
+ */
+static int mid_thermal_resume(struct platform_device *pdev)
+{
+       return mid_initialize_adc(&pdev->dev);
+}
+
+/**
+ * mid_thermal_suspend - suspend routine
+ * @pdev: platform device structure
+ *
+ * mid thermal suspend implements the suspend functionality
+ * by stopping the ADC. Can sleep.
+ */
+static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
+{
+       /*
+        * This just stops the ADC and does not disable it.
+        * temporary workaround until we have a generic ADC driver.
+        * If 0 is passed, it disables the ADC.
+        */
+       return configure_adc(0);
+}
+
+/**
+ * read_curr_temp - reads the current temperature and stores in temp
+ * @temp: holds the current temperature value after reading
+ *
+ * Can sleep
+ */
+static int read_curr_temp(struct thermal_zone_device *tzd, unsigned long *temp)
+{
+       WARN_ON(tzd == NULL);
+       return mid_read_temp(tzd, temp);
+}
+
+/* Can't be const */
+static struct thermal_zone_device_ops tzd_ops = {
+       .get_temp = read_curr_temp,
+};
+
+
+/**
+ * mid_thermal_probe - mfld thermal initialize
+ * @pdev: platform device structure
+ *
+ * mid thermal probe initializes the hardware and registers
+ * all the sensors with the generic thermal framework. Can sleep.
+ */
+static int mid_thermal_probe(struct platform_device *pdev)
+{
+       static char *name[MSIC_THERMAL_SENSORS] = {
+               "skin0", "skin1", "sys", "msicdie"
+       };
+
+       int ret;
+       int i;
+       struct platform_info *pinfo;
+
+       pinfo = kzalloc(sizeof(struct platform_info), GFP_KERNEL);
+       if (!pinfo)
+               return -ENOMEM;
+
+       /* Initializing the hardware */
+       ret = mid_initialize_adc(&pdev->dev);
+       if (ret) {
+               dev_err(&pdev->dev, "ADC init failed");
+               kfree(pinfo);
+               return ret;
+       }
+
+       /* Register each sensor with the generic thermal framework*/
+       for (i = 0; i < MSIC_THERMAL_SENSORS; i++) {
+               pinfo->tzd[i] = thermal_zone_device_register(name[i],
+                                       0, initialize_sensor(i),
+                                       &tzd_ops, 0, 0, 0, 0);
+               if (IS_ERR(pinfo->tzd[i]))
+                       goto reg_fail;
+       }
+
+       pinfo->pdev = pdev;
+       platform_set_drvdata(pdev, pinfo);
+       return 0;
+
+reg_fail:
+       ret = PTR_ERR(pinfo->tzd[i]);
+       while (--i >= 0)
+               thermal_zone_device_unregister(pinfo->tzd[i]);
+       configure_adc(0);
+       kfree(pinfo);
+       return ret;
+}
+
+/**
+ * mid_thermal_remove - mfld thermal finalize
+ * @dev: platform device structure
+ *
+ * MLFD thermal remove unregisters all the sensors from the generic
+ * thermal framework. Can sleep.
+ */
+static int mid_thermal_remove(struct platform_device *pdev)
+{
+       int i;
+       struct platform_info *pinfo = platform_get_drvdata(pdev);
+
+       for (i = 0; i < MSIC_THERMAL_SENSORS; i++)
+               thermal_zone_device_unregister(pinfo->tzd[i]);
+
+       platform_set_drvdata(pdev, NULL);
+
+       /* Stop the ADC */
+       return configure_adc(0);
+}
+
+/*********************************************************************
+ *             Driver initialisation and finalization
+ *********************************************************************/
+
+#define DRIVER_NAME "msic_sensor"
+
+static const struct platform_device_id therm_id_table[] = {
+       { DRIVER_NAME, 1 },
+       { }
+};
+
+static struct platform_driver mid_thermal_driver = {
+       .driver = {
+               .name = DRIVER_NAME,
+               .owner = THIS_MODULE,
+       },
+       .probe = mid_thermal_probe,
+       .suspend = mid_thermal_suspend,
+       .resume = mid_thermal_resume,
+       .remove = __devexit_p(mid_thermal_remove),
+       .id_table = therm_id_table,
+};
+
+static int __init mid_thermal_module_init(void)
+{
+       return platform_driver_register(&mid_thermal_driver);
+}
+
+static void __exit mid_thermal_module_exit(void)
+{
+       platform_driver_unregister(&mid_thermal_driver);
+}
+
+module_init(mid_thermal_module_init);
+module_exit(mid_thermal_module_exit);
+
+MODULE_AUTHOR("Durgadoss R <durgadoss.r@intel.com>");
+MODULE_DESCRIPTION("Intel Medfield Platform Thermal Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/intel_pmic_gpio.c b/drivers/platform/x86/intel_pmic_gpio.c
index 61433d492862..d653104b59cb 100644
--- a/drivers/platform/x86/intel_pmic_gpio.c
+++ b/drivers/platform/x86/intel_pmic_gpio.c
@@ -257,9 +257,11 @@ static int __devinit platform_pmic_gpio_probe(struct platform_device *pdev)
         }
 
         for (i = 0; i < 8; i++) {
-                set_irq_chip_and_handler_name(i + pg->irq_base, &pmic_irqchip,
-                                        handle_simple_irq, "demux");
-                set_irq_chip_data(i + pg->irq_base, pg);
+                irq_set_chip_and_handler_name(i + pg->irq_base,
+                                              &pmic_irqchip,
+                                              handle_simple_irq,
+                                              "demux");
+                irq_set_chip_data(i + pg->irq_base, pg);
         }
         return 0;
 err:
diff --git a/drivers/platform/x86/intel_rar_register.c b/drivers/platform/x86/intel_rar_register.c
index 2b11a33325e6..bde47e9080cd 100644
--- a/drivers/platform/x86/intel_rar_register.c
+++ b/drivers/platform/x86/intel_rar_register.c
@@ -485,7 +485,7 @@ EXPORT_SYMBOL(rar_lock);
  *
  *      The register_rar function is to used by other device drivers
  *      to ensure that this driver is ready. As we cannot be sure of
- *      the compile/execute order of drivers in ther kernel, it is
+ *      the compile/execute order of drivers in the kernel, it is
  *      best to give this driver a callback function to call when
  *      it is ready to give out addresses. The callback function
  *      would have those steps that continue the initialization of
diff --git a/drivers/platform/x86/intel_scu_ipc.c b/drivers/platform/x86/intel_scu_ipc.c
index a91d510a798b..940accbe28d3 100644
--- a/drivers/platform/x86/intel_scu_ipc.c
+++ b/drivers/platform/x86/intel_scu_ipc.c
@@ -9,7 +9,7 @@
  * as published by the Free Software Foundation; version 2
  * of the License.
  *
- * SCU runing in ARC processor communicates with other entity running in IA
+ * SCU running in ARC processor communicates with other entity running in IA
  * core through IPC mechanism which in turn messaging between IA core ad SCU.
  * SCU has two IPC mechanism IPC-1 and IPC-2. IPC-1 is used between IA32 and
  * SCU where IPC-2 is used between P-Unit and SCU. This driver delas with
diff --git a/drivers/platform/x86/msi-laptop.c b/drivers/platform/x86/msi-laptop.c
index 142d38579314..23fb2afda00b 100644
--- a/drivers/platform/x86/msi-laptop.c
+++ b/drivers/platform/x86/msi-laptop.c
@@ -51,6 +51,8 @@
  * laptop as MSI S270. YMMV.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -60,6 +62,8 @@
 #include <linux/platform_device.h>
 #include <linux/rfkill.h>
 #include <linux/i8042.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
 
 #define MSI_DRIVER_VERSION "0.5"
 
@@ -78,6 +82,9 @@
 #define MSI_STANDARD_EC_SCM_LOAD_ADDRESS        0x2d
 #define MSI_STANDARD_EC_SCM_LOAD_MASK           (1 << 0)
 
+#define MSI_STANDARD_EC_TOUCHPAD_ADDRESS        0xe4
+#define MSI_STANDARD_EC_TOUCHPAD_MASK           (1 << 4)
+
 static int msi_laptop_resume(struct platform_device *device);
 
 #define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS  0x2f
@@ -90,6 +97,14 @@ static int auto_brightness;
 module_param(auto_brightness, int, 0);
 MODULE_PARM_DESC(auto_brightness, "Enable automatic brightness control (0: disabled; 1: enabled; 2: don't touch)");
 
+static const struct key_entry msi_laptop_keymap[] = {
+        {KE_KEY, KEY_TOUCHPAD_ON, {KEY_TOUCHPAD_ON} },  /* Touch Pad On */
+        {KE_KEY, KEY_TOUCHPAD_OFF, {KEY_TOUCHPAD_OFF} },/* Touch Pad On */
+        {KE_END, 0}
+};
+
+static struct input_dev *msi_laptop_input_dev;
+
 static bool old_ec_model;
 static int wlan_s, bluetooth_s, threeg_s;
 static int threeg_exists;
@@ -432,8 +447,7 @@ static struct platform_device *msipf_device;
 
 static int dmi_check_cb(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO "msi-laptop: Identified laptop model '%s'.\n",
-               id->ident);
+        pr_info("Identified laptop model '%s'.\n", id->ident);
         return 1;
 }
 
@@ -605,6 +619,21 @@ static void msi_update_rfkill(struct work_struct *ignored)
 }
 static DECLARE_DELAYED_WORK(msi_rfkill_work, msi_update_rfkill);
 
+static void msi_send_touchpad_key(struct work_struct *ignored)
+{
+        u8 rdata;
+        int result;
+
+        result = ec_read(MSI_STANDARD_EC_TOUCHPAD_ADDRESS, &rdata);
+        if (result < 0)
+                return;
+
+        sparse_keymap_report_event(msi_laptop_input_dev,
+                (rdata & MSI_STANDARD_EC_TOUCHPAD_MASK) ?
+                KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF, 1, true);
+}
+static DECLARE_DELAYED_WORK(msi_touchpad_work, msi_send_touchpad_key);
+
 static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
                                 struct serio *port)
 {
@@ -613,12 +642,17 @@ static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
         if (str & 0x20)
                 return false;
 
-        /* 0x54 wwan, 0x62 bluetooth, 0x76 wlan*/
+        /* 0x54 wwan, 0x62 bluetooth, 0x76 wlan, 0xE4 touchpad toggle*/
         if (unlikely(data == 0xe0)) {
                 extended = true;
                 return false;
         } else if (unlikely(extended)) {
+                extended = false;
                 switch (data) {
+                case 0xE4:
+                        schedule_delayed_work(&msi_touchpad_work,
+                                round_jiffies_relative(0.5 * HZ));
+                        break;
                 case 0x54:
                 case 0x62:
                 case 0x76:
@@ -626,7 +660,6 @@ static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
                                 round_jiffies_relative(0.5 * HZ));
                         break;
                 }
-                extended = false;
         }
 
         return false;
@@ -731,6 +764,42 @@ static int msi_laptop_resume(struct platform_device *device)
         return 0;
 }
 
+static int __init msi_laptop_input_setup(void)
+{
+        int err;
+
+        msi_laptop_input_dev = input_allocate_device();
+        if (!msi_laptop_input_dev)
+                return -ENOMEM;
+
+        msi_laptop_input_dev->name = "MSI Laptop hotkeys";
+        msi_laptop_input_dev->phys = "msi-laptop/input0";
+        msi_laptop_input_dev->id.bustype = BUS_HOST;
+
+        err = sparse_keymap_setup(msi_laptop_input_dev,
+                msi_laptop_keymap, NULL);
+        if (err)
+                goto err_free_dev;
+
+        err = input_register_device(msi_laptop_input_dev);
+        if (err)
+                goto err_free_keymap;
+
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(msi_laptop_input_dev);
+err_free_dev:
+        input_free_device(msi_laptop_input_dev);
+        return err;
+}
+
+static void msi_laptop_input_destroy(void)
+{
+        sparse_keymap_free(msi_laptop_input_dev);
+        input_unregister_device(msi_laptop_input_dev);
+}
+
 static int load_scm_model_init(struct platform_device *sdev)
 {
         u8 data;
@@ -759,16 +828,23 @@ static int load_scm_model_init(struct platform_device *sdev)
         if (result < 0)
                 goto fail_rfkill;
 
+        /* setup input device */
+        result = msi_laptop_input_setup();
+        if (result)
+                goto fail_input;
+
         result = i8042_install_filter(msi_laptop_i8042_filter);
         if (result) {
-                printk(KERN_ERR
-                        "msi-laptop: Unable to install key filter\n");
+                pr_err("Unable to install key filter\n");
                 goto fail_filter;
         }
 
         return 0;
 
 fail_filter:
+        msi_laptop_input_destroy();
+
+fail_input:
         rfkill_cleanup();
 
 fail_rfkill:
@@ -799,7 +875,7 @@ static int __init msi_init(void)
         /* Register backlight stuff */
 
         if (acpi_video_backlight_support()) {
-                printk(KERN_INFO "MSI: Brightness ignored, must be controlled "
+                pr_info("Brightness ignored, must be controlled "
                        "by ACPI video driver\n");
         } else {
                 struct backlight_properties props;
@@ -854,7 +930,7 @@ static int __init msi_init(void)
         if (auto_brightness != 2)
                 set_auto_brightness(auto_brightness);
 
-        printk(KERN_INFO "msi-laptop: driver "MSI_DRIVER_VERSION" successfully loaded.\n");
+        pr_info("driver "MSI_DRIVER_VERSION" successfully loaded.\n");
 
         return 0;
 
@@ -886,6 +962,7 @@ static void __exit msi_cleanup(void)
 {
         if (load_scm_model) {
                 i8042_remove_filter(msi_laptop_i8042_filter);
+                msi_laptop_input_destroy();
                 cancel_delayed_work_sync(&msi_rfkill_work);
                 rfkill_cleanup();
         }
@@ -901,7 +978,7 @@ static void __exit msi_cleanup(void)
         if (auto_brightness != 2)
                 set_auto_brightness(1);
 
-        printk(KERN_INFO "msi-laptop: driver unloaded.\n");
+        pr_info("driver unloaded.\n");
 }
 
 module_init(msi_init);
diff --git a/drivers/platform/x86/samsung-laptop.c b/drivers/platform/x86/samsung-laptop.c
new file mode 100644
index 000000000000..de434c6dc2d6
--- /dev/null
+++ b/drivers/platform/x86/samsung-laptop.c
@@ -0,0 +1,832 @@
+/*
+ * Samsung Laptop driver
+ *
+ * Copyright (C) 2009,2011 Greg Kroah-Hartman (gregkh@suse.de)
+ * Copyright (C) 2009,2011 Novell Inc.
+ *
+ * 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.
+ *
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/backlight.h>
+#include <linux/fb.h>
+#include <linux/dmi.h>
+#include <linux/platform_device.h>
+#include <linux/rfkill.h>
+
+/*
+ * This driver is needed because a number of Samsung laptops do not hook
+ * their control settings through ACPI.  So we have to poke around in the
+ * BIOS to do things like brightness values, and "special" key controls.
+ */
+
+/*
+ * We have 0 - 8 as valid brightness levels.  The specs say that level 0 should
+ * be reserved by the BIOS (which really doesn't make much sense), we tell
+ * userspace that the value is 0 - 7 and then just tell the hardware 1 - 8
+ */
+#define MAX_BRIGHT      0x07
+
+
+#define SABI_IFACE_MAIN                 0x00
+#define SABI_IFACE_SUB                  0x02
+#define SABI_IFACE_COMPLETE             0x04
+#define SABI_IFACE_DATA                 0x05
+
+/* Structure to get data back to the calling function */
+struct sabi_retval {
+        u8 retval[20];
+};
+
+struct sabi_header_offsets {
+        u8 port;
+        u8 re_mem;
+        u8 iface_func;
+        u8 en_mem;
+        u8 data_offset;
+        u8 data_segment;
+};
+
+struct sabi_commands {
+        /*
+         * Brightness is 0 - 8, as described above.
+         * Value 0 is for the BIOS to use
+         */
+        u8 get_brightness;
+        u8 set_brightness;
+
+        /*
+         * first byte:
+         * 0x00 - wireless is off
+         * 0x01 - wireless is on
+         * second byte:
+         * 0x02 - 3G is off
+         * 0x03 - 3G is on
+         * TODO, verify 3G is correct, that doesn't seem right...
+         */
+        u8 get_wireless_button;
+        u8 set_wireless_button;
+
+        /* 0 is off, 1 is on */
+        u8 get_backlight;
+        u8 set_backlight;
+
+        /*
+         * 0x80 or 0x00 - no action
+         * 0x81 - recovery key pressed
+         */
+        u8 get_recovery_mode;
+        u8 set_recovery_mode;
+
+        /*
+         * on seclinux: 0 is low, 1 is high,
+         * on swsmi: 0 is normal, 1 is silent, 2 is turbo
+         */
+        u8 get_performance_level;
+        u8 set_performance_level;
+
+        /*
+         * Tell the BIOS that Linux is running on this machine.
+         * 81 is on, 80 is off
+         */
+        u8 set_linux;
+};
+
+struct sabi_performance_level {
+        const char *name;
+        u8 value;
+};
+
+struct sabi_config {
+        const char *test_string;
+        u16 main_function;
+        const struct sabi_header_offsets header_offsets;
+        const struct sabi_commands commands;
+        const struct sabi_performance_level performance_levels[4];
+        u8 min_brightness;
+        u8 max_brightness;
+};
+
+static const struct sabi_config sabi_configs[] = {
+        {
+                .test_string = "SECLINUX",
+
+                .main_function = 0x4c49,
+
+                .header_offsets = {
+                        .port = 0x00,
+                        .re_mem = 0x02,
+                        .iface_func = 0x03,
+                        .en_mem = 0x04,
+                        .data_offset = 0x05,
+                        .data_segment = 0x07,
+                },
+
+                .commands = {
+                        .get_brightness = 0x00,
+                        .set_brightness = 0x01,
+
+                        .get_wireless_button = 0x02,
+                        .set_wireless_button = 0x03,
+
+                        .get_backlight = 0x04,
+                        .set_backlight = 0x05,
+
+                        .get_recovery_mode = 0x06,
+                        .set_recovery_mode = 0x07,
+
+                        .get_performance_level = 0x08,
+                        .set_performance_level = 0x09,
+
+                        .set_linux = 0x0a,
+                },
+
+                .performance_levels = {
+                        {
+                                .name = "silent",
+                                .value = 0,
+                        },
+                        {
+                                .name = "normal",
+                                .value = 1,
+                        },
+                        { },
+                },
+                .min_brightness = 1,
+                .max_brightness = 8,
+        },
+        {
+                .test_string = "SwSmi@",
+
+                .main_function = 0x5843,
+
+                .header_offsets = {
+                        .port = 0x00,
+                        .re_mem = 0x04,
+                        .iface_func = 0x02,
+                        .en_mem = 0x03,
+                        .data_offset = 0x05,
+                        .data_segment = 0x07,
+                },
+
+                .commands = {
+                        .get_brightness = 0x10,
+                        .set_brightness = 0x11,
+
+                        .get_wireless_button = 0x12,
+                        .set_wireless_button = 0x13,
+
+                        .get_backlight = 0x2d,
+                        .set_backlight = 0x2e,
+
+                        .get_recovery_mode = 0xff,
+                        .set_recovery_mode = 0xff,
+
+                        .get_performance_level = 0x31,
+                        .set_performance_level = 0x32,
+
+                        .set_linux = 0xff,
+                },
+
+                .performance_levels = {
+                        {
+                                .name = "normal",
+                                .value = 0,
+                        },
+                        {
+                                .name = "silent",
+                                .value = 1,
+                        },
+                        {
+                                .name = "overclock",
+                                .value = 2,
+                        },
+                        { },
+                },
+                .min_brightness = 0,
+                .max_brightness = 8,
+        },
+        { },
+};
+
+static const struct sabi_config *sabi_config;
+
+static void __iomem *sabi;
+static void __iomem *sabi_iface;
+static void __iomem *f0000_segment;
+static struct backlight_device *backlight_device;
+static struct mutex sabi_mutex;
+static struct platform_device *sdev;
+static struct rfkill *rfk;
+
+static int force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force,
+                "Disable the DMI check and forces the driver to be loaded");
+
+static int debug;
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug enabled or not");
+
+static int sabi_get_command(u8 command, struct sabi_retval *sretval)
+{
+        int retval = 0;
+        u16 port = readw(sabi + sabi_config->header_offsets.port);
+        u8 complete, iface_data;
+
+        mutex_lock(&sabi_mutex);
+
+        /* enable memory to be able to write to it */
+        outb(readb(sabi + sabi_config->header_offsets.en_mem), port);
+
+        /* write out the command */
+        writew(sabi_config->main_function, sabi_iface + SABI_IFACE_MAIN);
+        writew(command, sabi_iface + SABI_IFACE_SUB);
+        writeb(0, sabi_iface + SABI_IFACE_COMPLETE);
+        outb(readb(sabi + sabi_config->header_offsets.iface_func), port);
+
+        /* write protect memory to make it safe */
+        outb(readb(sabi + sabi_config->header_offsets.re_mem), port);
+
+        /* see if the command actually succeeded */
+        complete = readb(sabi_iface + SABI_IFACE_COMPLETE);
+        iface_data = readb(sabi_iface + SABI_IFACE_DATA);
+        if (complete != 0xaa || iface_data == 0xff) {
+                pr_warn("SABI get command 0x%02x failed with completion flag 0x%02x and data 0x%02x\n",
+                        command, complete, iface_data);
+                retval = -EINVAL;
+                goto exit;
+        }
+        /*
+         * Save off the data into a structure so the caller use it.
+         * Right now we only want the first 4 bytes,
+         * There are commands that need more, but not for the ones we
+         * currently care about.
+         */
+        sretval->retval[0] = readb(sabi_iface + SABI_IFACE_DATA);
+        sretval->retval[1] = readb(sabi_iface + SABI_IFACE_DATA + 1);
+        sretval->retval[2] = readb(sabi_iface + SABI_IFACE_DATA + 2);
+        sretval->retval[3] = readb(sabi_iface + SABI_IFACE_DATA + 3);
+
+exit:
+        mutex_unlock(&sabi_mutex);
+        return retval;
+
+}
+
+static int sabi_set_command(u8 command, u8 data)
+{
+        int retval = 0;
+        u16 port = readw(sabi + sabi_config->header_offsets.port);
+        u8 complete, iface_data;
+
+        mutex_lock(&sabi_mutex);
+
+        /* enable memory to be able to write to it */
+        outb(readb(sabi + sabi_config->header_offsets.en_mem), port);
+
+        /* write out the command */
+        writew(sabi_config->main_function, sabi_iface + SABI_IFACE_MAIN);
+        writew(command, sabi_iface + SABI_IFACE_SUB);
+        writeb(0, sabi_iface + SABI_IFACE_COMPLETE);
+        writeb(data, sabi_iface + SABI_IFACE_DATA);
+        outb(readb(sabi + sabi_config->header_offsets.iface_func), port);
+
+        /* write protect memory to make it safe */
+        outb(readb(sabi + sabi_config->header_offsets.re_mem), port);
+
+        /* see if the command actually succeeded */
+        complete = readb(sabi_iface + SABI_IFACE_COMPLETE);
+        iface_data = readb(sabi_iface + SABI_IFACE_DATA);
+        if (complete != 0xaa || iface_data == 0xff) {
+                pr_warn("SABI set command 0x%02x failed with completion flag 0x%02x and data 0x%02x\n",
+                       command, complete, iface_data);
+                retval = -EINVAL;
+        }
+
+        mutex_unlock(&sabi_mutex);
+        return retval;
+}
+
+static void test_backlight(void)
+{
+        struct sabi_retval sretval;
+
+        sabi_get_command(sabi_config->commands.get_backlight, &sretval);
+        printk(KERN_DEBUG "backlight = 0x%02x\n", sretval.retval[0]);
+
+        sabi_set_command(sabi_config->commands.set_backlight, 0);
+        printk(KERN_DEBUG "backlight should be off\n");
+
+        sabi_get_command(sabi_config->commands.get_backlight, &sretval);
+        printk(KERN_DEBUG "backlight = 0x%02x\n", sretval.retval[0]);
+
+        msleep(1000);
+
+        sabi_set_command(sabi_config->commands.set_backlight, 1);
+        printk(KERN_DEBUG "backlight should be on\n");
+
+        sabi_get_command(sabi_config->commands.get_backlight, &sretval);
+        printk(KERN_DEBUG "backlight = 0x%02x\n", sretval.retval[0]);
+}
+
+static void test_wireless(void)
+{
+        struct sabi_retval sretval;
+
+        sabi_get_command(sabi_config->commands.get_wireless_button, &sretval);
+        printk(KERN_DEBUG "wireless led = 0x%02x\n", sretval.retval[0]);
+
+        sabi_set_command(sabi_config->commands.set_wireless_button, 0);
+        printk(KERN_DEBUG "wireless led should be off\n");
+
+        sabi_get_command(sabi_config->commands.get_wireless_button, &sretval);
+        printk(KERN_DEBUG "wireless led = 0x%02x\n", sretval.retval[0]);
+
+        msleep(1000);
+
+        sabi_set_command(sabi_config->commands.set_wireless_button, 1);
+        printk(KERN_DEBUG "wireless led should be on\n");
+
+        sabi_get_command(sabi_config->commands.get_wireless_button, &sretval);
+        printk(KERN_DEBUG "wireless led = 0x%02x\n", sretval.retval[0]);
+}
+
+static u8 read_brightness(void)
+{
+        struct sabi_retval sretval;
+        int user_brightness = 0;
+        int retval;
+
+        retval = sabi_get_command(sabi_config->commands.get_brightness,
+                                  &sretval);
+        if (!retval) {
+                user_brightness = sretval.retval[0];
+                if (user_brightness != 0)
+                        user_brightness -= sabi_config->min_brightness;
+        }
+        return user_brightness;
+}
+
+static void set_brightness(u8 user_brightness)
+{
+        u8 user_level = user_brightness - sabi_config->min_brightness;
+
+        sabi_set_command(sabi_config->commands.set_brightness, user_level);
+}
+
+static int get_brightness(struct backlight_device *bd)
+{
+        return (int)read_brightness();
+}
+
+static int update_status(struct backlight_device *bd)
+{
+        set_brightness(bd->props.brightness);
+
+        if (bd->props.power == FB_BLANK_UNBLANK)
+                sabi_set_command(sabi_config->commands.set_backlight, 1);
+        else
+                sabi_set_command(sabi_config->commands.set_backlight, 0);
+        return 0;
+}
+
+static const struct backlight_ops backlight_ops = {
+        .get_brightness = get_brightness,
+        .update_status  = update_status,
+};
+
+static int rfkill_set(void *data, bool blocked)
+{
+        /* Do something with blocked...*/
+        /*
+         * blocked == false is on
+         * blocked == true is off
+         */
+        if (blocked)
+                sabi_set_command(sabi_config->commands.set_wireless_button, 0);
+        else
+                sabi_set_command(sabi_config->commands.set_wireless_button, 1);
+
+        return 0;
+}
+
+static struct rfkill_ops rfkill_ops = {
+        .set_block = rfkill_set,
+};
+
+static int init_wireless(struct platform_device *sdev)
+{
+        int retval;
+
+        rfk = rfkill_alloc("samsung-wifi", &sdev->dev, RFKILL_TYPE_WLAN,
+                           &rfkill_ops, NULL);
+        if (!rfk)
+                return -ENOMEM;
+
+        retval = rfkill_register(rfk);
+        if (retval) {
+                rfkill_destroy(rfk);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void destroy_wireless(void)
+{
+        rfkill_unregister(rfk);
+        rfkill_destroy(rfk);
+}
+
+static ssize_t get_performance_level(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct sabi_retval sretval;
+        int retval;
+        int i;
+
+        /* Read the state */
+        retval = sabi_get_command(sabi_config->commands.get_performance_level,
+                                  &sretval);
+        if (retval)
+                return retval;
+
+        /* The logic is backwards, yeah, lots of fun... */
+        for (i = 0; sabi_config->performance_levels[i].name; ++i) {
+                if (sretval.retval[0] == sabi_config->performance_levels[i].value)
+                        return sprintf(buf, "%s\n", sabi_config->performance_levels[i].name);
+        }
+        return sprintf(buf, "%s\n", "unknown");
+}
+
+static ssize_t set_performance_level(struct device *dev,
+                                struct device_attribute *attr, const char *buf,
+                                size_t count)
+{
+        if (count >= 1) {
+                int i;
+                for (i = 0; sabi_config->performance_levels[i].name; ++i) {
+                        const struct sabi_performance_level *level =
+                                &sabi_config->performance_levels[i];
+                        if (!strncasecmp(level->name, buf, strlen(level->name))) {
+                                sabi_set_command(sabi_config->commands.set_performance_level,
+                                                 level->value);
+                                break;
+                        }
+                }
+                if (!sabi_config->performance_levels[i].name)
+                        return -EINVAL;
+        }
+        return count;
+}
+static DEVICE_ATTR(performance_level, S_IWUSR | S_IRUGO,
+                   get_performance_level, set_performance_level);
+
+
+static int __init dmi_check_cb(const struct dmi_system_id *id)
+{
+        pr_info("found laptop model '%s'\n",
+                id->ident);
+        return 1;
+}
+
+static struct dmi_system_id __initdata samsung_dmi_table[] = {
+        {
+                .ident = "N128",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N128"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N128"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N130",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N130"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N130"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "X125",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X125"),
+                        DMI_MATCH(DMI_BOARD_NAME, "X125"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "X120/X170",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X120/X170"),
+                        DMI_MATCH(DMI_BOARD_NAME, "X120/X170"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "NC10",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
+                        DMI_MATCH(DMI_BOARD_NAME, "NC10"),
+                },
+                .callback = dmi_check_cb,
+        },
+                {
+                .ident = "NP-Q45",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
+                        DMI_MATCH(DMI_BOARD_NAME, "SQ45S70S"),
+                },
+                .callback = dmi_check_cb,
+                },
+        {
+                .ident = "X360",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X360"),
+                        DMI_MATCH(DMI_BOARD_NAME, "X360"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R518",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R518"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R518"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R519/R719",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R519/R719"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R519/R719"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N150/N210/N220",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N150/N210/N220"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N150/N210/N220"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N150P/N210P/N220P",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N150P/N210P/N220P"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N150P/N210P/N220P"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R530/R730",
+                .matches = {
+                      DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                      DMI_MATCH(DMI_PRODUCT_NAME, "R530/R730"),
+                      DMI_MATCH(DMI_BOARD_NAME, "R530/R730"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "NF110/NF210/NF310",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "NF110/NF210/NF310"),
+                        DMI_MATCH(DMI_BOARD_NAME, "NF110/NF210/NF310"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N145P/N250P/N260P",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N145P/N250P/N260P"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N145P/N250P/N260P"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R70/R71",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R70/R71"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R70/R71"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "P460",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "P460"),
+                        DMI_MATCH(DMI_BOARD_NAME, "P460"),
+                },
+                .callback = dmi_check_cb,
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(dmi, samsung_dmi_table);
+
+static int find_signature(void __iomem *memcheck, const char *testStr)
+{
+        int i = 0;
+        int loca;
+
+        for (loca = 0; loca < 0xffff; loca++) {
+                char temp = readb(memcheck + loca);
+
+                if (temp == testStr[i]) {
+                        if (i == strlen(testStr)-1)
+                                break;
+                        ++i;
+                } else {
+                        i = 0;
+                }
+        }
+        return loca;
+}
+
+static int __init samsung_init(void)
+{
+        struct backlight_properties props;
+        struct sabi_retval sretval;
+        unsigned int ifaceP;
+        int i;
+        int loca;
+        int retval;
+
+        mutex_init(&sabi_mutex);
+
+        if (!force && !dmi_check_system(samsung_dmi_table))
+                return -ENODEV;
+
+        f0000_segment = ioremap_nocache(0xf0000, 0xffff);
+        if (!f0000_segment) {
+                pr_err("Can't map the segment at 0xf0000\n");
+                return -EINVAL;
+        }
+
+        /* Try to find one of the signatures in memory to find the header */
+        for (i = 0; sabi_configs[i].test_string != 0; ++i) {
+                sabi_config = &sabi_configs[i];
+                loca = find_signature(f0000_segment, sabi_config->test_string);
+                if (loca != 0xffff)
+                        break;
+        }
+
+        if (loca == 0xffff) {
+                pr_err("This computer does not support SABI\n");
+                goto error_no_signature;
+        }
+
+        /* point to the SMI port Number */
+        loca += 1;
+        sabi = (f0000_segment + loca);
+
+        if (debug) {
+                printk(KERN_DEBUG "This computer supports SABI==%x\n",
+                        loca + 0xf0000 - 6);
+                printk(KERN_DEBUG "SABI header:\n");
+                printk(KERN_DEBUG " SMI Port Number = 0x%04x\n",
+                        readw(sabi + sabi_config->header_offsets.port));
+                printk(KERN_DEBUG " SMI Interface Function = 0x%02x\n",
+                        readb(sabi + sabi_config->header_offsets.iface_func));
+                printk(KERN_DEBUG " SMI enable memory buffer = 0x%02x\n",
+                        readb(sabi + sabi_config->header_offsets.en_mem));
+                printk(KERN_DEBUG " SMI restore memory buffer = 0x%02x\n",
+                        readb(sabi + sabi_config->header_offsets.re_mem));
+                printk(KERN_DEBUG " SABI data offset = 0x%04x\n",
+                        readw(sabi + sabi_config->header_offsets.data_offset));
+                printk(KERN_DEBUG " SABI data segment = 0x%04x\n",
+                        readw(sabi + sabi_config->header_offsets.data_segment));
+        }
+
+        /* Get a pointer to the SABI Interface */
+        ifaceP = (readw(sabi + sabi_config->header_offsets.data_segment) & 0x0ffff) << 4;
+        ifaceP += readw(sabi + sabi_config->header_offsets.data_offset) & 0x0ffff;
+        sabi_iface = ioremap_nocache(ifaceP, 16);
+        if (!sabi_iface) {
+                pr_err("Can't remap %x\n", ifaceP);
+                goto exit;
+        }
+        if (debug) {
+                printk(KERN_DEBUG "ifaceP = 0x%08x\n", ifaceP);
+                printk(KERN_DEBUG "sabi_iface = %p\n", sabi_iface);
+
+                test_backlight();
+                test_wireless();
+
+                retval = sabi_get_command(sabi_config->commands.get_brightness,
+                                          &sretval);
+                printk(KERN_DEBUG "brightness = 0x%02x\n", sretval.retval[0]);
+        }
+
+        /* Turn on "Linux" mode in the BIOS */
+        if (sabi_config->commands.set_linux != 0xff) {
+                retval = sabi_set_command(sabi_config->commands.set_linux,
+                                          0x81);
+                if (retval) {
+                        pr_warn("Linux mode was not set!\n");
+                        goto error_no_platform;
+                }
+        }
+
+        /* knock up a platform device to hang stuff off of */
+        sdev = platform_device_register_simple("samsung", -1, NULL, 0);
+        if (IS_ERR(sdev))
+                goto error_no_platform;
+
+        /* create a backlight device to talk to this one */
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = sabi_config->max_brightness;
+        backlight_device = backlight_device_register("samsung", &sdev->dev,
+                                                     NULL, &backlight_ops,
+                                                     &props);
+        if (IS_ERR(backlight_device))
+                goto error_no_backlight;
+
+        backlight_device->props.brightness = read_brightness();
+        backlight_device->props.power = FB_BLANK_UNBLANK;
+        backlight_update_status(backlight_device);
+
+        retval = init_wireless(sdev);
+        if (retval)
+                goto error_no_rfk;
+
+        retval = device_create_file(&sdev->dev, &dev_attr_performance_level);
+        if (retval)
+                goto error_file_create;
+
+exit:
+        return 0;
+
+error_file_create:
+        destroy_wireless();
+
+error_no_rfk:
+        backlight_device_unregister(backlight_device);
+
+error_no_backlight:
+        platform_device_unregister(sdev);
+
+error_no_platform:
+        iounmap(sabi_iface);
+
+error_no_signature:
+        iounmap(f0000_segment);
+        return -EINVAL;
+}
+
+static void __exit samsung_exit(void)
+{
+        /* Turn off "Linux" mode in the BIOS */
+        if (sabi_config->commands.set_linux != 0xff)
+                sabi_set_command(sabi_config->commands.set_linux, 0x80);
+
+        device_remove_file(&sdev->dev, &dev_attr_performance_level);
+        backlight_device_unregister(backlight_device);
+        destroy_wireless();
+        iounmap(sabi_iface);
+        iounmap(f0000_segment);
+        platform_device_unregister(sdev);
+}
+
+module_init(samsung_init);
+module_exit(samsung_exit);
+
+MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@suse.de>");
+MODULE_DESCRIPTION("Samsung Backlight driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 13d8d63bcca9..e642f5f29504 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -71,8 +71,9 @@
 #endif
 
 #define DRV_PFX                 "sony-laptop: "
-#define dprintk(msg...)         do {                    \
-        if (debug) printk(KERN_WARNING DRV_PFX  msg);   \
+#define dprintk(msg...)         do {    \
+        if (debug)                      \
+                pr_warn(DRV_PFX msg);   \
 } while (0)
 
 #define SONY_LAPTOP_DRIVER_VERSION      "0.6"
@@ -124,6 +125,19 @@ MODULE_PARM_DESC(minor,
                  "default is -1 (automatic)");
 #endif
 
+static int kbd_backlight;       /* = 1 */
+module_param(kbd_backlight, int, 0444);
+MODULE_PARM_DESC(kbd_backlight,
+                 "set this to 0 to disable keyboard backlight, "
+                 "1 to enable it (default: 0)");
+
+static int kbd_backlight_timeout;       /* = 0 */
+module_param(kbd_backlight_timeout, int, 0444);
+MODULE_PARM_DESC(kbd_backlight_timeout,
+                 "set this to 0 to set the default 10 seconds timeout, "
+                 "1 for 30 seconds, 2 for 60 seconds and 3 to disable timeout "
+                 "(default: 0)");
+
 enum sony_nc_rfkill {
         SONY_WIFI,
         SONY_BLUETOOTH,
@@ -402,7 +416,7 @@ static int sony_laptop_setup_input(struct acpi_device *acpi_device)
         error = kfifo_alloc(&sony_laptop_input.fifo,
                             SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
-                printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
+                pr_err(DRV_PFX "kfifo_alloc failed\n");
                 goto err_dec_users;
         }
 
@@ -591,7 +605,7 @@ struct sony_nc_value {
         int value;              /* current setting */
         int valid;              /* Has ever been set */
         int debug;              /* active only in debug mode ? */
-        struct device_attribute devattr;        /* sysfs atribute */
+        struct device_attribute devattr;        /* sysfs attribute */
 };
 
 #define SNC_HANDLE_NAMES(_name, _values...) \
@@ -686,7 +700,7 @@ static int acpi_callgetfunc(acpi_handle handle, char *name, int *result)
                 return 0;
         }
 
-        printk(KERN_WARNING DRV_PFX "acpi_callreadfunc failed\n");
+        pr_warn(DRV_PFX "acpi_callreadfunc failed\n");
 
         return -1;
 }
@@ -712,7 +726,7 @@ static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
         if (status == AE_OK) {
                 if (result != NULL) {
                         if (out_obj.type != ACPI_TYPE_INTEGER) {
-                                printk(KERN_WARNING DRV_PFX "acpi_evaluate_object bad "
+                                pr_warn(DRV_PFX "acpi_evaluate_object bad "
                                        "return type\n");
                                 return -1;
                         }
@@ -721,34 +735,103 @@ static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
                 return 0;
         }
 
-        printk(KERN_WARNING DRV_PFX "acpi_evaluate_object failed\n");
+        pr_warn(DRV_PFX "acpi_evaluate_object failed\n");
 
         return -1;
 }
 
-static int sony_find_snc_handle(int handle)
+struct sony_nc_handles {
+        u16 cap[0x10];
+        struct device_attribute devattr;
+};
+
+static struct sony_nc_handles *handles;
+
+static ssize_t sony_nc_handles_show(struct device *dev,
+                struct device_attribute *attr, char *buffer)
+{
+        ssize_t len = 0;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
+                len += snprintf(buffer + len, PAGE_SIZE - len, "0x%.4x ",
+                                handles->cap[i]);
+        }
+        len += snprintf(buffer + len, PAGE_SIZE - len, "\n");
+
+        return len;
+}
+
+static int sony_nc_handles_setup(struct platform_device *pd)
 {
         int i;
         int result;
 
-        for (i = 0x20; i < 0x30; i++) {
-                acpi_callsetfunc(sony_nc_acpi_handle, "SN00", i, &result);
-                if (result == handle)
-                        return i-0x20;
+        handles = kzalloc(sizeof(*handles), GFP_KERNEL);
+        if (!handles)
+                return -ENOMEM;
+
+        sysfs_attr_init(&handles->devattr.attr);
+        handles->devattr.attr.name = "handles";
+        handles->devattr.attr.mode = S_IRUGO;
+        handles->devattr.show = sony_nc_handles_show;
+
+        for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
+                if (!acpi_callsetfunc(sony_nc_acpi_handle,
+                                        "SN00", i + 0x20, &result)) {
+                        dprintk("caching handle 0x%.4x (offset: 0x%.2x)\n",
+                                        result, i);
+                        handles->cap[i] = result;
+                }
+        }
+
+        /* allow reading capabilities via sysfs */
+        if (device_create_file(&pd->dev, &handles->devattr)) {
+                kfree(handles);
+                handles = NULL;
+                return -1;
+        }
+
+        return 0;
+}
+
+static int sony_nc_handles_cleanup(struct platform_device *pd)
+{
+        if (handles) {
+                device_remove_file(&pd->dev, &handles->devattr);
+                kfree(handles);
+                handles = NULL;
         }
+        return 0;
+}
 
+static int sony_find_snc_handle(int handle)
+{
+        int i;
+        for (i = 0; i < 0x10; i++) {
+                if (handles->cap[i] == handle) {
+                        dprintk("found handle 0x%.4x (offset: 0x%.2x)\n",
+                                        handle, i);
+                        return i;
+                }
+        }
+        dprintk("handle 0x%.4x not found\n", handle);
         return -1;
 }
 
 static int sony_call_snc_handle(int handle, int argument, int *result)
 {
+        int ret = 0;
         int offset = sony_find_snc_handle(handle);
 
         if (offset < 0)
                 return -1;
 
-        return acpi_callsetfunc(sony_nc_acpi_handle, "SN07", offset | argument,
-                                result);
+        ret = acpi_callsetfunc(sony_nc_acpi_handle, "SN07", offset | argument,
+                        result);
+        dprintk("called SN07 with 0x%.4x (result: 0x%.4x)\n", offset | argument,
+                        *result);
+        return ret;
 }
 
 /*
@@ -857,11 +940,39 @@ static int sony_backlight_get_brightness(struct backlight_device *bd)
         return value - 1;
 }
 
-static struct backlight_device *sony_backlight_device;
+static int sony_nc_get_brightness_ng(struct backlight_device *bd)
+{
+        int result;
+        int *handle = (int *)bl_get_data(bd);
+
+        sony_call_snc_handle(*handle, 0x0200, &result);
+
+        return result & 0xff;
+}
+
+static int sony_nc_update_status_ng(struct backlight_device *bd)
+{
+        int value, result;
+        int *handle = (int *)bl_get_data(bd);
+
+        value = bd->props.brightness;
+        sony_call_snc_handle(*handle, 0x0100 | (value << 16), &result);
+
+        return sony_nc_get_brightness_ng(bd);
+}
+
 static const struct backlight_ops sony_backlight_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
         .update_status = sony_backlight_update_status,
         .get_brightness = sony_backlight_get_brightness,
 };
+static const struct backlight_ops sony_backlight_ng_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
+        .update_status = sony_nc_update_status_ng,
+        .get_brightness = sony_nc_get_brightness_ng,
+};
+static int backlight_ng_handle;
+static struct backlight_device *sony_backlight_device;
 
 /*
  * New SNC-only Vaios event mapping to driver known keys
@@ -972,7 +1083,7 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
                                 }
 
                                 if (!key_event->data)
-                                        printk(KERN_INFO DRV_PFX
+                                        pr_info(DRV_PFX
                                                         "Unknown event: 0x%x 0x%x\n",
                                                         key_handle,
                                                         ev);
@@ -996,7 +1107,7 @@ static acpi_status sony_walk_callback(acpi_handle handle, u32 level,
         struct acpi_device_info *info;
 
         if (ACPI_SUCCESS(acpi_get_object_info(handle, &info))) {
-                printk(KERN_WARNING DRV_PFX "method: name: %4.4s, args %X\n",
+                pr_warn(DRV_PFX "method: name: %4.4s, args %X\n",
                         (char *)&info->name, info->param_count);
 
                 kfree(info);
@@ -1037,7 +1148,7 @@ static int sony_nc_resume(struct acpi_device *device)
                 ret = acpi_callsetfunc(sony_nc_acpi_handle, *item->acpiset,
                                        item->value, NULL);
                 if (ret < 0) {
-                        printk("%s: %d\n", __func__, ret);
+                        pr_err(DRV_PFX "%s: %d\n", __func__, ret);
                         break;
                 }
         }
@@ -1054,11 +1165,6 @@ static int sony_nc_resume(struct acpi_device *device)
                 sony_nc_function_setup(device);
         }
 
-        /* set the last requested brightness level */
-        if (sony_backlight_device &&
-                        sony_backlight_update_status(sony_backlight_device) < 0)
-                printk(KERN_WARNING DRV_PFX "unable to restore brightness level\n");
-
         /* re-read rfkill state */
         sony_nc_rfkill_update();
 
@@ -1206,12 +1312,12 @@ static void sony_nc_rfkill_setup(struct acpi_device *device)
 
         device_enum = (union acpi_object *) buffer.pointer;
         if (!device_enum) {
-                pr_err("Invalid SN06 return object\n");
+                pr_err(DRV_PFX "No SN06 return object.");
                 goto out_no_enum;
         }
         if (device_enum->type != ACPI_TYPE_BUFFER) {
-                pr_err("Invalid SN06 return object type 0x%.2x\n",
-                       device_enum->type);
+                pr_err(DRV_PFX "Invalid SN06 return object 0x%.2x\n",
+                                device_enum->type);
                 goto out_no_enum;
         }
 
@@ -1245,6 +1351,209 @@ out_no_enum:
         return;
 }
 
+/* Keyboard backlight feature */
+#define KBDBL_HANDLER   0x137
+#define KBDBL_PRESENT   0xB00
+#define SET_MODE        0xC00
+#define SET_TIMEOUT     0xE00
+
+struct kbd_backlight {
+        int mode;
+        int timeout;
+        struct device_attribute mode_attr;
+        struct device_attribute timeout_attr;
+};
+
+static struct kbd_backlight *kbdbl_handle;
+
+static ssize_t __sony_nc_kbd_backlight_mode_set(u8 value)
+{
+        int result;
+
+        if (value > 1)
+                return -EINVAL;
+
+        if (sony_call_snc_handle(KBDBL_HANDLER,
+                                (value << 0x10) | SET_MODE, &result))
+                return -EIO;
+
+        kbdbl_handle->mode = value;
+
+        return 0;
+}
+
+static ssize_t sony_nc_kbd_backlight_mode_store(struct device *dev,
+                struct device_attribute *attr,
+                const char *buffer, size_t count)
+{
+        int ret = 0;
+        unsigned long value;
+
+        if (count > 31)
+                return -EINVAL;
+
+        if (strict_strtoul(buffer, 10, &value))
+                return -EINVAL;
+
+        ret = __sony_nc_kbd_backlight_mode_set(value);
+        if (ret < 0)
+                return ret;
+
+        return count;
+}
+
+static ssize_t sony_nc_kbd_backlight_mode_show(struct device *dev,
+                struct device_attribute *attr, char *buffer)
+{
+        ssize_t count = 0;
+        count = snprintf(buffer, PAGE_SIZE, "%d\n", kbdbl_handle->mode);
+        return count;
+}
+
+static int __sony_nc_kbd_backlight_timeout_set(u8 value)
+{
+        int result;
+
+        if (value > 3)
+                return -EINVAL;
+
+        if (sony_call_snc_handle(KBDBL_HANDLER,
+                                (value << 0x10) | SET_TIMEOUT, &result))
+                return -EIO;
+
+        kbdbl_handle->timeout = value;
+
+        return 0;
+}
+
+static ssize_t sony_nc_kbd_backlight_timeout_store(struct device *dev,
+                struct device_attribute *attr,
+                const char *buffer, size_t count)
+{
+        int ret = 0;
+        unsigned long value;
+
+        if (count > 31)
+                return -EINVAL;
+
+        if (strict_strtoul(buffer, 10, &value))
+                return -EINVAL;
+
+        ret = __sony_nc_kbd_backlight_timeout_set(value);
+        if (ret < 0)
+                return ret;
+
+        return count;
+}
+
+static ssize_t sony_nc_kbd_backlight_timeout_show(struct device *dev,
+                struct device_attribute *attr, char *buffer)
+{
+        ssize_t count = 0;
+        count = snprintf(buffer, PAGE_SIZE, "%d\n", kbdbl_handle->timeout);
+        return count;
+}
+
+static int sony_nc_kbd_backlight_setup(struct platform_device *pd)
+{
+        int result;
+
+        if (sony_call_snc_handle(0x137, KBDBL_PRESENT, &result))
+                return 0;
+        if (!(result & 0x02))
+                return 0;
+
+        kbdbl_handle = kzalloc(sizeof(*kbdbl_handle), GFP_KERNEL);
+        if (!kbdbl_handle)
+                return -ENOMEM;
+
+        sysfs_attr_init(&kbdbl_handle->mode_attr.attr);
+        kbdbl_handle->mode_attr.attr.name = "kbd_backlight";
+        kbdbl_handle->mode_attr.attr.mode = S_IRUGO | S_IWUSR;
+        kbdbl_handle->mode_attr.show = sony_nc_kbd_backlight_mode_show;
+        kbdbl_handle->mode_attr.store = sony_nc_kbd_backlight_mode_store;
+
+        sysfs_attr_init(&kbdbl_handle->timeout_attr.attr);
+        kbdbl_handle->timeout_attr.attr.name = "kbd_backlight_timeout";
+        kbdbl_handle->timeout_attr.attr.mode = S_IRUGO | S_IWUSR;
+        kbdbl_handle->timeout_attr.show = sony_nc_kbd_backlight_timeout_show;
+        kbdbl_handle->timeout_attr.store = sony_nc_kbd_backlight_timeout_store;
+
+        if (device_create_file(&pd->dev, &kbdbl_handle->mode_attr))
+                goto outkzalloc;
+
+        if (device_create_file(&pd->dev, &kbdbl_handle->timeout_attr))
+                goto outmode;
+
+        __sony_nc_kbd_backlight_mode_set(kbd_backlight);
+        __sony_nc_kbd_backlight_timeout_set(kbd_backlight_timeout);
+
+        return 0;
+
+outmode:
+        device_remove_file(&pd->dev, &kbdbl_handle->mode_attr);
+outkzalloc:
+        kfree(kbdbl_handle);
+        kbdbl_handle = NULL;
+        return -1;
+}
+
+static int sony_nc_kbd_backlight_cleanup(struct platform_device *pd)
+{
+        if (kbdbl_handle) {
+                device_remove_file(&pd->dev, &kbdbl_handle->mode_attr);
+                device_remove_file(&pd->dev, &kbdbl_handle->timeout_attr);
+                kfree(kbdbl_handle);
+        }
+        return 0;
+}
+
+static void sony_nc_backlight_setup(void)
+{
+        acpi_handle unused;
+        int max_brightness = 0;
+        const struct backlight_ops *ops = NULL;
+        struct backlight_properties props;
+
+        if (sony_find_snc_handle(0x12f) != -1) {
+                backlight_ng_handle = 0x12f;
+                ops = &sony_backlight_ng_ops;
+                max_brightness = 0xff;
+
+        } else if (sony_find_snc_handle(0x137) != -1) {
+                backlight_ng_handle = 0x137;
+                ops = &sony_backlight_ng_ops;
+                max_brightness = 0xff;
+
+        } else if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "GBRT",
+                                                &unused))) {
+                ops = &sony_backlight_ops;
+                max_brightness = SONY_MAX_BRIGHTNESS - 1;
+
+        } else
+                return;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
+        props.max_brightness = max_brightness;
+        sony_backlight_device = backlight_device_register("sony", NULL,
+                                                          &backlight_ng_handle,
+                                                          ops, &props);
+
+        if (IS_ERR(sony_backlight_device)) {
+                pr_warning(DRV_PFX "unable to register backlight device\n");
+                sony_backlight_device = NULL;
+        } else
+                sony_backlight_device->props.brightness =
+                    ops->get_brightness(sony_backlight_device);
+}
+
+static void sony_nc_backlight_cleanup(void)
+{
+        if (sony_backlight_device)
+                backlight_device_unregister(sony_backlight_device);
+}
+
 static int sony_nc_add(struct acpi_device *device)
 {
         acpi_status status;
@@ -1252,8 +1561,8 @@ static int sony_nc_add(struct acpi_device *device)
         acpi_handle handle;
         struct sony_nc_value *item;
 
-        printk(KERN_INFO DRV_PFX "%s v%s.\n",
-                SONY_NC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
+        pr_info(DRV_PFX "%s v%s.\n", SONY_NC_DRIVER_NAME,
+                        SONY_LAPTOP_DRIVER_VERSION);
 
         sony_nc_acpi_device = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -1269,13 +1578,18 @@ static int sony_nc_add(struct acpi_device *device)
                 goto outwalk;
         }
 
+        result = sony_pf_add();
+        if (result)
+                goto outpresent;
+
         if (debug) {
-                status = acpi_walk_namespace(ACPI_TYPE_METHOD, sony_nc_acpi_handle,
-                                             1, sony_walk_callback, NULL, NULL, NULL);
+                status = acpi_walk_namespace(ACPI_TYPE_METHOD,
+                                sony_nc_acpi_handle, 1, sony_walk_callback,
+                                NULL, NULL, NULL);
                 if (ACPI_FAILURE(status)) {
-                        printk(KERN_WARNING DRV_PFX "unable to walk acpi resources\n");
+                        pr_warn(DRV_PFX "unable to walk acpi resources\n");
                         result = -ENODEV;
-                        goto outwalk;
+                        goto outpresent;
                 }
         }
 
@@ -1288,6 +1602,12 @@ static int sony_nc_add(struct acpi_device *device)
         if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "SN00",
                                          &handle))) {
                 dprintk("Doing SNC setup\n");
+                result = sony_nc_handles_setup(sony_pf_device);
+                if (result)
+                        goto outpresent;
+                result = sony_nc_kbd_backlight_setup(sony_pf_device);
+                if (result)
+                        goto outsnc;
                 sony_nc_function_setup(device);
                 sony_nc_rfkill_setup(device);
         }
@@ -1295,40 +1615,17 @@ static int sony_nc_add(struct acpi_device *device)
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to create input devices.\n");
-                goto outwalk;
+                pr_err(DRV_PFX "Unable to create input devices.\n");
+                goto outkbdbacklight;
         }
 
         if (acpi_video_backlight_support()) {
-                printk(KERN_INFO DRV_PFX "brightness ignored, must be "
+                pr_info(DRV_PFX "brightness ignored, must be "
                        "controlled by ACPI video driver\n");
-        } else if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "GBRT",
-                                                &handle))) {
-                struct backlight_properties props;
-                memset(&props, 0, sizeof(struct backlight_properties));
-                props.type = BACKLIGHT_PLATFORM;
-                props.max_brightness = SONY_MAX_BRIGHTNESS - 1;
-                sony_backlight_device = backlight_device_register("sony", NULL,
-                                                                  NULL,
-                                                                  &sony_backlight_ops,
-                                                                  &props);
-
-                if (IS_ERR(sony_backlight_device)) {
-                        printk(KERN_WARNING DRV_PFX "unable to register backlight device\n");
-                        sony_backlight_device = NULL;
-                } else {
-                        sony_backlight_device->props.brightness =
-                            sony_backlight_get_brightness
-                            (sony_backlight_device);
-                }
-
+        } else {
+                sony_nc_backlight_setup();
         }
 
-        result = sony_pf_add();
-        if (result)
-                goto outbacklight;
-
         /* create sony_pf sysfs attributes related to the SNC device */
         for (item = sony_nc_values; item->name; ++item) {
 
@@ -1374,14 +1671,19 @@ static int sony_nc_add(struct acpi_device *device)
         for (item = sony_nc_values; item->name; ++item) {
                 device_remove_file(&sony_pf_device->dev, &item->devattr);
         }
-        sony_pf_remove();
-
-      outbacklight:
-        if (sony_backlight_device)
-                backlight_device_unregister(sony_backlight_device);
+        sony_nc_backlight_cleanup();
 
         sony_laptop_remove_input();
 
+      outkbdbacklight:
+        sony_nc_kbd_backlight_cleanup(sony_pf_device);
+
+      outsnc:
+        sony_nc_handles_cleanup(sony_pf_device);
+
+      outpresent:
+        sony_pf_remove();
+
       outwalk:
         sony_nc_rfkill_cleanup();
         return result;
@@ -1391,8 +1693,7 @@ static int sony_nc_remove(struct acpi_device *device, int type)
 {
         struct sony_nc_value *item;
 
-        if (sony_backlight_device)
-                backlight_device_unregister(sony_backlight_device);
+        sony_nc_backlight_cleanup();
 
         sony_nc_acpi_device = NULL;
 
@@ -1400,6 +1701,8 @@ static int sony_nc_remove(struct acpi_device *device, int type)
                 device_remove_file(&sony_pf_device->dev, &item->devattr);
         }
 
+        sony_nc_kbd_backlight_cleanup(sony_pf_device);
+        sony_nc_handles_cleanup(sony_pf_device);
         sony_pf_remove();
         sony_laptop_remove_input();
         sony_nc_rfkill_cleanup();
@@ -1438,7 +1741,6 @@ static struct acpi_driver sony_nc_driver = {
 #define SONYPI_DEVICE_TYPE1     0x00000001
 #define SONYPI_DEVICE_TYPE2     0x00000002
 #define SONYPI_DEVICE_TYPE3     0x00000004
-#define SONYPI_DEVICE_TYPE4     0x00000008
 
 #define SONYPI_TYPE1_OFFSET     0x04
 #define SONYPI_TYPE2_OFFSET     0x12
@@ -1584,8 +1886,8 @@ static struct sonypi_event sonypi_blueev[] = {
 
 /* The set of possible wireless events */
 static struct sonypi_event sonypi_wlessev[] = {
-        { 0x59, SONYPI_EVENT_WIRELESS_ON },
-        { 0x5a, SONYPI_EVENT_WIRELESS_OFF },
+        { 0x59, SONYPI_EVENT_IGNORE },
+        { 0x5a, SONYPI_EVENT_IGNORE },
         { 0, 0 }
 };
 
@@ -1842,7 +2144,7 @@ out:
         if (pcidev)
                 pci_dev_put(pcidev);
 
-        printk(KERN_INFO DRV_PFX "detected Type%d model\n",
+        pr_info(DRV_PFX "detected Type%d model\n",
                         dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
                         dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
 }
@@ -1890,7 +2192,7 @@ static int __sony_pic_camera_ready(void)
 static int __sony_pic_camera_off(void)
 {
         if (!camera) {
-                printk(KERN_WARNING DRV_PFX "camera control not enabled\n");
+                pr_warn(DRV_PFX "camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -1910,7 +2212,7 @@ static int __sony_pic_camera_on(void)
         int i, j, x;
 
         if (!camera) {
-                printk(KERN_WARNING DRV_PFX "camera control not enabled\n");
+                pr_warn(DRV_PFX "camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -1933,7 +2235,7 @@ static int __sony_pic_camera_on(void)
         }
 
         if (j == 0) {
-                printk(KERN_WARNING DRV_PFX "failed to power on camera\n");
+                pr_warn(DRV_PFX "failed to power on camera\n");
                 return -ENODEV;
         }
 
@@ -1989,7 +2291,7 @@ int sony_pic_camera_command(int command, u8 value)
                                 ITERATIONS_SHORT);
                 break;
         default:
-                printk(KERN_ERR DRV_PFX "sony_pic_camera_command invalid: %d\n",
+                pr_err(DRV_PFX "sony_pic_camera_command invalid: %d\n",
                        command);
                 break;
         }
@@ -2396,7 +2698,7 @@ static int sonypi_compat_init(void)
         error =
          kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
-                printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
+                pr_err(DRV_PFX "kfifo_alloc failed\n");
                 return error;
         }
 
@@ -2406,11 +2708,11 @@ static int sonypi_compat_init(void)
                 sonypi_misc_device.minor = minor;
         error = misc_register(&sonypi_misc_device);
         if (error) {
-                printk(KERN_ERR DRV_PFX "misc_register failed\n");
+                pr_err(DRV_PFX "misc_register failed\n");
                 goto err_free_kfifo;
         }
         if (minor == -1)
-                printk(KERN_INFO DRV_PFX "device allocated minor is %d\n",
+                pr_info(DRV_PFX "device allocated minor is %d\n",
                        sonypi_misc_device.minor);
 
         return 0;
@@ -2470,8 +2772,7 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                         }
                         for (i = 0; i < p->interrupt_count; i++) {
                                 if (!p->interrupts[i]) {
-                                        printk(KERN_WARNING DRV_PFX
-                                                        "Invalid IRQ %d\n",
+                                        pr_warn(DRV_PFX "Invalid IRQ %d\n",
                                                         p->interrupts[i]);
                                         continue;
                                 }
@@ -2510,7 +2811,7 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                                                 ioport->io2.address_length);
                         }
                         else {
-                                printk(KERN_ERR DRV_PFX "Unknown SPIC Type, more than 2 IO Ports\n");
+                                pr_err(DRV_PFX "Unknown SPIC Type, more than 2 IO Ports\n");
                                 return AE_ERROR;
                         }
                         return AE_OK;
@@ -2538,7 +2839,7 @@ static int sony_pic_possible_resources(struct acpi_device *device)
         dprintk("Evaluating _STA\n");
         result = acpi_bus_get_status(device);
         if (result) {
-                printk(KERN_WARNING DRV_PFX "Unable to read status\n");
+                pr_warn(DRV_PFX "Unable to read status\n");
                 goto end;
         }
 
@@ -2554,8 +2855,7 @@ static int sony_pic_possible_resources(struct acpi_device *device)
         status = acpi_walk_resources(device->handle, METHOD_NAME__PRS,
                         sony_pic_read_possible_resource, &spic_dev);
         if (ACPI_FAILURE(status)) {
-                printk(KERN_WARNING DRV_PFX
-                                "Failure evaluating %s\n",
+                pr_warn(DRV_PFX "Failure evaluating %s\n",
                                 METHOD_NAME__PRS);
                 result = -ENODEV;
         }
@@ -2669,7 +2969,7 @@ static int sony_pic_enable(struct acpi_device *device,
 
         /* check for total failure */
         if (ACPI_FAILURE(status)) {
-                printk(KERN_ERR DRV_PFX "Error evaluating _SRS\n");
+                pr_err(DRV_PFX "Error evaluating _SRS\n");
                 result = -ENODEV;
                 goto end;
         }
@@ -2725,6 +3025,9 @@ static irqreturn_t sony_pic_irq(int irq, void *dev_id)
                         if (ev == dev->event_types[i].events[j].data) {
                                 device_event =
                                         dev->event_types[i].events[j].event;
+                                /* some events may require ignoring */
+                                if (!device_event)
+                                        return IRQ_HANDLED;
                                 goto found;
                         }
                 }
@@ -2744,7 +3047,6 @@ found:
         sony_laptop_report_input_event(device_event);
         acpi_bus_generate_proc_event(dev->acpi_dev, 1, device_event);
         sonypi_compat_report_event(device_event);
-
         return IRQ_HANDLED;
 }
 
@@ -2759,7 +3061,7 @@ static int sony_pic_remove(struct acpi_device *device, int type)
         struct sony_pic_irq *irq, *tmp_irq;
 
         if (sony_pic_disable(device)) {
-                printk(KERN_ERR DRV_PFX "Couldn't disable device.\n");
+                pr_err(DRV_PFX "Couldn't disable device.\n");
                 return -ENXIO;
         }
 
@@ -2799,8 +3101,8 @@ static int sony_pic_add(struct acpi_device *device)
         struct sony_pic_ioport *io, *tmp_io;
         struct sony_pic_irq *irq, *tmp_irq;
 
-        printk(KERN_INFO DRV_PFX "%s v%s.\n",
-                SONY_PIC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
+        pr_info(DRV_PFX "%s v%s.\n", SONY_PIC_DRIVER_NAME,
+                        SONY_LAPTOP_DRIVER_VERSION);
 
         spic_dev.acpi_dev = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -2810,16 +3112,14 @@ static int sony_pic_add(struct acpi_device *device)
         /* read _PRS resources */
         result = sony_pic_possible_resources(device);
         if (result) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to read possible resources.\n");
+                pr_err(DRV_PFX "Unable to read possible resources.\n");
                 goto err_free_resources;
         }
 
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to create input devices.\n");
+                pr_err(DRV_PFX "Unable to create input devices.\n");
                 goto err_free_resources;
         }
 
@@ -2829,7 +3129,7 @@ static int sony_pic_add(struct acpi_device *device)
         /* request io port */
         list_for_each_entry_reverse(io, &spic_dev.ioports, list) {
                 if (request_region(io->io1.minimum, io->io1.address_length,
-                                        "Sony Programable I/O Device")) {
+                                        "Sony Programmable I/O Device")) {
                         dprintk("I/O port1: 0x%.4x (0x%.4x) + 0x%.2x\n",
                                         io->io1.minimum, io->io1.maximum,
                                         io->io1.address_length);
@@ -2837,7 +3137,7 @@ static int sony_pic_add(struct acpi_device *device)
                         if (io->io2.minimum) {
                                 if (request_region(io->io2.minimum,
                                                 io->io2.address_length,
-                                                "Sony Programable I/O Device")) {
+                                                "Sony Programmable I/O Device")) {
                                         dprintk("I/O port2: 0x%.4x (0x%.4x) + 0x%.2x\n",
                                                         io->io2.minimum, io->io2.maximum,
                                                         io->io2.address_length);
@@ -2860,7 +3160,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_ioport) {
-                printk(KERN_ERR DRV_PFX "Failed to request_region.\n");
+                pr_err(DRV_PFX "Failed to request_region.\n");
                 result = -ENODEV;
                 goto err_remove_compat;
         }
@@ -2880,7 +3180,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_irq) {
-                printk(KERN_ERR DRV_PFX "Failed to request_irq.\n");
+                pr_err(DRV_PFX "Failed to request_irq.\n");
                 result = -ENODEV;
                 goto err_release_region;
         }
@@ -2888,7 +3188,7 @@ static int sony_pic_add(struct acpi_device *device)
         /* set resource status _SRS */
         result = sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq);
         if (result) {
-                printk(KERN_ERR DRV_PFX "Couldn't enable device.\n");
+                pr_err(DRV_PFX "Couldn't enable device.\n");
                 goto err_free_irq;
         }
 
@@ -2997,8 +3297,7 @@ static int __init sony_laptop_init(void)
         if (!no_spic && dmi_check_system(sonypi_dmi_table)) {
                 result = acpi_bus_register_driver(&sony_pic_driver);
                 if (result) {
-                        printk(KERN_ERR DRV_PFX
-                                        "Unable to register SPIC driver.");
+                        pr_err(DRV_PFX "Unable to register SPIC driver.");
                         goto out;
                 }
                 spic_drv_registered = 1;
@@ -3006,7 +3305,7 @@ static int __init sony_laptop_init(void)
 
         result = acpi_bus_register_driver(&sony_nc_driver);
         if (result) {
-                printk(KERN_ERR DRV_PFX "Unable to register SNC driver.");
+                pr_err(DRV_PFX "Unable to register SNC driver.");
                 goto out_unregister_pic;
         }
 
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 947bdcaa0ce9..a08561f5349e 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -2407,7 +2407,7 @@ static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn,
          * This code is supposed to duplicate the IBM firmware behaviour:
          * - Pressing MUTE issues mute hotkey message, even when already mute
          * - Pressing Volume up/down issues volume up/down hotkey messages,
-         *   even when already at maximum or minumum volume
+         *   even when already at maximum or minimum volume
          * - The act of unmuting issues volume up/down notification,
          *   depending which key was used to unmute
          *
@@ -2990,7 +2990,7 @@ static void tpacpi_send_radiosw_update(void)
          * rfkill input events, or we will race the rfkill core input
          * handler.
          *
-         * tpacpi_inputdev_send_mutex works as a syncronization point
+         * tpacpi_inputdev_send_mutex works as a synchronization point
          * for the above.
          *
          * We optimize to avoid numerous calls to hotkey_get_wlsw.
diff --git a/drivers/platform/x86/xo15-ebook.c b/drivers/platform/x86/xo15-ebook.c
new file mode 100644
index 000000000000..c1372ed9d2e9
--- /dev/null
+++ b/drivers/platform/x86/xo15-ebook.c
@@ -0,0 +1,180 @@
+/*
+ *  OLPC XO-1.5 ebook switch driver
+ *  (based on generic ACPI button driver)
+ *
+ *  Copyright (C) 2009 Paul Fox <pgf@laptop.org>
+ *  Copyright (C) 2010 One Laptop per Child
+ *
+ *  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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/input.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#define MODULE_NAME "xo15-ebook"
+#define PREFIX MODULE_NAME ": "
+
+#define XO15_EBOOK_CLASS                MODULE_NAME
+#define XO15_EBOOK_TYPE_UNKNOWN 0x00
+#define XO15_EBOOK_NOTIFY_STATUS        0x80
+
+#define XO15_EBOOK_SUBCLASS             "ebook"
+#define XO15_EBOOK_HID                  "XO15EBK"
+#define XO15_EBOOK_DEVICE_NAME          "EBook Switch"
+
+ACPI_MODULE_NAME(MODULE_NAME);
+
+MODULE_DESCRIPTION("OLPC XO-1.5 ebook switch driver");
+MODULE_LICENSE("GPL");
+
+static const struct acpi_device_id ebook_device_ids[] = {
+        { XO15_EBOOK_HID, 0 },
+        { "", 0 },
+};
+MODULE_DEVICE_TABLE(acpi, ebook_device_ids);
+
+struct ebook_switch {
+        struct input_dev *input;
+        char phys[32];                  /* for input device */
+};
+
+static int ebook_send_state(struct acpi_device *device)
+{
+        struct ebook_switch *button = acpi_driver_data(device);
+        unsigned long long state;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(device->handle, "EBK", NULL, &state);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        /* input layer checks if event is redundant */
+        input_report_switch(button->input, SW_TABLET_MODE, !state);
+        input_sync(button->input);
+        return 0;
+}
+
+static void ebook_switch_notify(struct acpi_device *device, u32 event)
+{
+        switch (event) {
+        case ACPI_FIXED_HARDWARE_EVENT:
+        case XO15_EBOOK_NOTIFY_STATUS:
+                ebook_send_state(device);
+                break;
+        default:
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                                  "Unsupported event [0x%x]\n", event));
+                break;
+        }
+}
+
+static int ebook_switch_resume(struct acpi_device *device)
+{
+        return ebook_send_state(device);
+}
+
+static int ebook_switch_add(struct acpi_device *device)
+{
+        struct ebook_switch *button;
+        struct input_dev *input;
+        const char *hid = acpi_device_hid(device);
+        char *name, *class;
+        int error;
+
+        button = kzalloc(sizeof(struct ebook_switch), GFP_KERNEL);
+        if (!button)
+                return -ENOMEM;
+
+        device->driver_data = button;
+
+        button->input = input = input_allocate_device();
+        if (!input) {
+                error = -ENOMEM;
+                goto err_free_button;
+        }
+
+        name = acpi_device_name(device);
+        class = acpi_device_class(device);
+
+        if (strcmp(hid, XO15_EBOOK_HID)) {
+                printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
+                error = -ENODEV;
+                goto err_free_input;
+        }
+
+        strcpy(name, XO15_EBOOK_DEVICE_NAME);
+        sprintf(class, "%s/%s", XO15_EBOOK_CLASS, XO15_EBOOK_SUBCLASS);
+
+        snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
+
+        input->name = name;
+        input->phys = button->phys;
+        input->id.bustype = BUS_HOST;
+        input->dev.parent = &device->dev;
+
+        input->evbit[0] = BIT_MASK(EV_SW);
+        set_bit(SW_TABLET_MODE, input->swbit);
+
+        error = input_register_device(input);
+        if (error)
+                goto err_free_input;
+
+        ebook_send_state(device);
+
+        if (device->wakeup.flags.valid) {
+                /* Button's GPE is run-wake GPE */
+                acpi_enable_gpe(device->wakeup.gpe_device,
+                                device->wakeup.gpe_number);
+                device_set_wakeup_enable(&device->dev, true);
+        }
+
+        return 0;
+
+ err_free_input:
+        input_free_device(input);
+ err_free_button:
+        kfree(button);
+        return error;
+}
+
+static int ebook_switch_remove(struct acpi_device *device, int type)
+{
+        struct ebook_switch *button = acpi_driver_data(device);
+
+        input_unregister_device(button->input);
+        kfree(button);
+        return 0;
+}
+
+static struct acpi_driver xo15_ebook_driver = {
+        .name = MODULE_NAME,
+        .class = XO15_EBOOK_CLASS,
+        .ids = ebook_device_ids,
+        .ops = {
+                .add = ebook_switch_add,
+                .resume = ebook_switch_resume,
+                .remove = ebook_switch_remove,
+                .notify = ebook_switch_notify,
+        },
+};
+
+static int __init xo15_ebook_init(void)
+{
+        return acpi_bus_register_driver(&xo15_ebook_driver);
+}
+
+static void __exit xo15_ebook_exit(void)
+{
+        acpi_bus_unregister_driver(&xo15_ebook_driver);
+}
+
+module_init(xo15_ebook_init);
+module_exit(xo15_ebook_exit);
diff --git a/drivers/power/z2_battery.c b/drivers/power/z2_battery.c
index 2a9ab89f83b8..e5ced3a4c1ed 100644
--- a/drivers/power/z2_battery.c
+++ b/drivers/power/z2_battery.c
@@ -215,8 +215,8 @@ static int __devinit z2_batt_probe(struct i2c_client *client,
                 if (ret)
                         goto err2;
 
-                set_irq_type(gpio_to_irq(info->charge_gpio),
-                                IRQ_TYPE_EDGE_BOTH);
+                irq_set_irq_type(gpio_to_irq(info->charge_gpio),
+                                 IRQ_TYPE_EDGE_BOTH);
                 ret = request_irq(gpio_to_irq(info->charge_gpio),
                                 z2_charge_switch_irq, IRQF_DISABLED,
                                 "AC Detect", charger);
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index e55dc1ac83ab..6ac55fd48413 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -782,11 +782,11 @@ static void sh_rtc_set_irq_wake(struct device *dev, int enabled)
         struct platform_device *pdev = to_platform_device(dev);
         struct sh_rtc *rtc = platform_get_drvdata(pdev);
 
-        set_irq_wake(rtc->periodic_irq, enabled);
+        irq_set_irq_wake(rtc->periodic_irq, enabled);
 
         if (rtc->carry_irq > 0) {
-                set_irq_wake(rtc->carry_irq, enabled);
-                set_irq_wake(rtc->alarm_irq, enabled);
+                irq_set_irq_wake(rtc->carry_irq, enabled);
+                irq_set_irq_wake(rtc->alarm_irq, enabled);
         }
 }
 
diff --git a/drivers/sh/intc/core.c b/drivers/sh/intc/core.c
index 5833afbf08d7..c6ca115c71df 100644
--- a/drivers/sh/intc/core.c
+++ b/drivers/sh/intc/core.c
@@ -63,7 +63,7 @@ void intc_set_prio_level(unsigned int irq, unsigned int level)
 
 static void intc_redirect_irq(unsigned int irq, struct irq_desc *desc)
 {
-        generic_handle_irq((unsigned int)get_irq_data(irq));
+        generic_handle_irq((unsigned int)irq_get_handler_data(irq));
 }
 
 static void __init intc_register_irq(struct intc_desc *desc,
@@ -116,9 +116,9 @@ static void __init intc_register_irq(struct intc_desc *desc,
         irq_data = irq_get_irq_data(irq);
 
         disable_irq_nosync(irq);
-        set_irq_chip_and_handler_name(irq, &d->chip,
-                                      handle_level_irq, "level");
-        set_irq_chip_data(irq, (void *)data[primary]);
+        irq_set_chip_and_handler_name(irq, &d->chip, handle_level_irq,
+                                      "level");
+        irq_set_chip_data(irq, (void *)data[primary]);
 
         /*
          * set priority level
@@ -340,9 +340,9 @@ int __init register_intc_controller(struct intc_desc *desc)
                         vect2->enum_id = 0;
 
                         /* redirect this interrupts to the first one */
-                        set_irq_chip(irq2, &dummy_irq_chip);
-                        set_irq_chained_handler(irq2, intc_redirect_irq);
-                        set_irq_data(irq2, (void *)irq);
+                        irq_set_chip(irq2, &dummy_irq_chip);
+                        irq_set_chained_handler(irq2, intc_redirect_irq);
+                        irq_set_handler_data(irq2, (void *)irq);
                 }
         }
 
@@ -387,19 +387,16 @@ static int intc_suspend(void)
                 /* enable wakeup irqs belonging to this intc controller */
                 for_each_active_irq(irq) {
                         struct irq_data *data;
-                        struct irq_desc *desc;
                         struct irq_chip *chip;
 
                         data = irq_get_irq_data(irq);
                         chip = irq_data_get_irq_chip(data);
                         if (chip != &d->chip)
                                 continue;
-                        desc = irq_to_desc(irq);
-                        if ((desc->status & IRQ_WAKEUP))
+                        if (irqd_is_wakeup_set(data))
                                 chip->irq_enable(data);
                 }
         }
-
         return 0;
 }
 
@@ -412,7 +409,6 @@ static void intc_resume(void)
 
                 for_each_active_irq(irq) {
                         struct irq_data *data;
-                        struct irq_desc *desc;
                         struct irq_chip *chip;
 
                         data = irq_get_irq_data(irq);
@@ -423,8 +419,7 @@ static void intc_resume(void)
                          */
                         if (chip != &d->chip)
                                 continue;
-                        desc = irq_to_desc(irq);
-                        if (desc->status & IRQ_DISABLED)
+                        if (irqd_irq_disabled(data))
                                 chip->irq_disable(data);
                         else
                                 chip->irq_enable(data);
diff --git a/drivers/sh/intc/virq.c b/drivers/sh/intc/virq.c
index 4e0ff7181164..ce5f81d7cc6b 100644
--- a/drivers/sh/intc/virq.c
+++ b/drivers/sh/intc/virq.c
@@ -110,7 +110,7 @@ static void intc_virq_handler(unsigned int irq, struct irq_desc *desc)
 {
         struct irq_data *data = irq_get_irq_data(irq);
         struct irq_chip *chip = irq_data_get_irq_chip(data);
-        struct intc_virq_list *entry, *vlist = irq_data_get_irq_data(data);
+        struct intc_virq_list *entry, *vlist = irq_data_get_irq_handler_data(data);
         struct intc_desc_int *d = get_intc_desc(irq);
 
         chip->irq_mask_ack(data);
@@ -118,7 +118,7 @@ static void intc_virq_handler(unsigned int irq, struct irq_desc *desc)
         for_each_virq(entry, vlist) {
                 unsigned long addr, handle;
 
-                handle = (unsigned long)get_irq_data(entry->irq);
+                handle = (unsigned long)irq_get_handler_data(entry->irq);
                 addr = INTC_REG(d, _INTC_ADDR_E(handle), 0);
 
                 if (intc_reg_fns[_INTC_FN(handle)](addr, handle, 0))
@@ -229,13 +229,13 @@ restart:
 
                 intc_irq_xlate_set(irq, entry->enum_id, d);
 
-                set_irq_chip_and_handler_name(irq, get_irq_chip(entry->pirq),
+                irq_set_chip_and_handler_name(irq, irq_get_chip(entry->pirq),
                                               handle_simple_irq, "virq");
-                set_irq_chip_data(irq, get_irq_chip_data(entry->pirq));
+                irq_set_chip_data(irq, irq_get_chip_data(entry->pirq));
 
-                set_irq_data(irq, (void *)entry->handle);
+                irq_set_handler_data(irq, (void *)entry->handle);
 
-                set_irq_chained_handler(entry->pirq, intc_virq_handler);
+                irq_set_chained_handler(entry->pirq, intc_virq_handler);
                 add_virq_to_pirq(entry->pirq, irq);
 
                 radix_tree_tag_clear(&d->tree, entry->enum_id,
diff --git a/drivers/staging/brcm80211/brcmfmac/bcmsdh_linux.c b/drivers/staging/brcm80211/brcmfmac/bcmsdh_linux.c
index e3556ff43bb9..ac5bbc8722e5 100644
--- a/drivers/staging/brcm80211/brcmfmac/bcmsdh_linux.c
+++ b/drivers/staging/brcm80211/brcmfmac/bcmsdh_linux.c
@@ -341,7 +341,7 @@ int bcmsdh_register_oob_intr(void *dhdp)
                 if (error)
                         return -ENODEV;
 
-                set_irq_wake(sdhcinfo->oob_irq, 1);
+                irq_set_irq_wake(sdhcinfo->oob_irq, 1);
                 sdhcinfo->oob_irq_registered = true;
         }
 
@@ -352,7 +352,7 @@ void bcmsdh_unregister_oob_intr(void)
 {
         SDLX_MSG(("%s: Enter\n", __func__));
 
-        set_irq_wake(sdhcinfo->oob_irq, 0);
+        irq_set_irq_wake(sdhcinfo->oob_irq, 0);
         disable_irq(sdhcinfo->oob_irq); /* just in case.. */
         free_irq(sdhcinfo->oob_irq, NULL);
         sdhcinfo->oob_irq_registered = false;
diff --git a/drivers/staging/westbridge/astoria/arch/arm/mach-omap2/cyashalomap_kernel.c b/drivers/staging/westbridge/astoria/arch/arm/mach-omap2/cyashalomap_kernel.c
index ea9b733c3926..21cdb0637beb 100644
--- a/drivers/staging/westbridge/astoria/arch/arm/mach-omap2/cyashalomap_kernel.c
+++ b/drivers/staging/westbridge/astoria/arch/arm/mach-omap2/cyashalomap_kernel.c
@@ -597,7 +597,7 @@ static int cy_as_hal_configure_interrupts(void *dev_p)
         int result;
         int irq_pin  = AST_INT;
 
-        set_irq_type(OMAP_GPIO_IRQ(irq_pin), IRQ_TYPE_LEVEL_LOW);
+        irq_set_irq_type(OMAP_GPIO_IRQ(irq_pin), IRQ_TYPE_LEVEL_LOW);
 
         /*
          * for shared IRQS must provide non NULL device ptr
diff --git a/drivers/tty/hvc/hvc_xen.c b/drivers/tty/hvc/hvc_xen.c
index c35f1a73bc8b..52fdf60bdbe2 100644
--- a/drivers/tty/hvc/hvc_xen.c
+++ b/drivers/tty/hvc/hvc_xen.c
@@ -178,7 +178,7 @@ static int __init xen_hvc_init(void)
         if (xencons_irq < 0)
                 xencons_irq = 0; /* NO_IRQ */
         else
-                set_irq_noprobe(xencons_irq);
+                irq_set_noprobe(xencons_irq);
 
         hp = hvc_alloc(HVC_COOKIE, xencons_irq, ops, 256);
         if (IS_ERR(hp))
diff --git a/drivers/tty/serial/msm_serial_hs.c b/drivers/tty/serial/msm_serial_hs.c
index 2e7fc9cee9cc..b906f11f7c1a 100644
--- a/drivers/tty/serial/msm_serial_hs.c
+++ b/drivers/tty/serial/msm_serial_hs.c
@@ -1644,7 +1644,7 @@ static int __devinit msm_hs_probe(struct platform_device *pdev)
         if (unlikely(uport->irq < 0))
                 return -ENXIO;
 
-        if (unlikely(set_irq_wake(uport->irq, 1)))
+        if (unlikely(irq_set_irq_wake(uport->irq, 1)))
                 return -ENXIO;
 
         if (pdata == NULL || pdata->rx_wakeup_irq < 0)
@@ -1658,7 +1658,7 @@ static int __devinit msm_hs_probe(struct platform_device *pdev)
                 if (unlikely(msm_uport->rx_wakeup.irq < 0))
                         return -ENXIO;
 
-                if (unlikely(set_irq_wake(msm_uport->rx_wakeup.irq, 1)))
+                if (unlikely(irq_set_irq_wake(msm_uport->rx_wakeup.irq, 1)))
                         return -ENXIO;
         }
 
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 38193f4e980e..44e4deb362e1 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -3832,7 +3832,7 @@ static int oxu_drv_probe(struct platform_device *pdev)
                 return -EBUSY;
         }
 
-        ret = set_irq_type(irq, IRQF_TRIGGER_FALLING);
+        ret = irq_set_irq_type(irq, IRQF_TRIGGER_FALLING);
         if (ret) {
                 dev_err(&pdev->dev, "error setting irq type\n");
                 ret = -EFAULT;
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 2ba3b070ed0b..c47aac4a1f98 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -943,7 +943,7 @@ static void tusb_musb_enable(struct musb *musb)
         musb_writel(tbase, TUSB_INT_CTRL_CONF,
                         TUSB_INT_CTRL_CONF_INT_RELCYC(0));
 
-        set_irq_type(musb->nIrq, IRQ_TYPE_LEVEL_LOW);
+        irq_set_irq_type(musb->nIrq, IRQ_TYPE_LEVEL_LOW);
 
         /* maybe force into the Default-A OTG state machine */
         if (!(musb_readl(tbase, TUSB_DEV_OTG_STAT)
diff --git a/drivers/vlynq/vlynq.c b/drivers/vlynq/vlynq.c
index f885c868a04d..aa250cebecd2 100644
--- a/drivers/vlynq/vlynq.c
+++ b/drivers/vlynq/vlynq.c
@@ -135,40 +135,40 @@ static void vlynq_reset(struct vlynq_device *dev)
         msleep(5);
 }
 
-static void vlynq_irq_unmask(unsigned int irq)
+static void vlynq_irq_unmask(struct irq_data *d)
 {
-        u32 val;
-        struct vlynq_device *dev = get_irq_chip_data(irq);
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         int virq;
+        u32 val;
 
         BUG_ON(!dev);
-        virq = irq - dev->irq_start;
+        virq = d->irq - dev->irq_start;
         val = readl(&dev->remote->int_device[virq >> 2]);
         val |= (VINT_ENABLE | virq) << VINT_OFFSET(virq);
         writel(val, &dev->remote->int_device[virq >> 2]);
 }
 
-static void vlynq_irq_mask(unsigned int irq)
+static void vlynq_irq_mask(struct irq_data *d)
 {
-        u32 val;
-        struct vlynq_device *dev = get_irq_chip_data(irq);
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         int virq;
+        u32 val;
 
         BUG_ON(!dev);
-        virq = irq - dev->irq_start;
+        virq = d->irq - dev->irq_start;
         val = readl(&dev->remote->int_device[virq >> 2]);
         val &= ~(VINT_ENABLE << VINT_OFFSET(virq));
         writel(val, &dev->remote->int_device[virq >> 2]);
 }
 
-static int vlynq_irq_type(unsigned int irq, unsigned int flow_type)
+static int vlynq_irq_type(struct irq_data *d, unsigned int flow_type)
 {
-        u32 val;
-        struct vlynq_device *dev = get_irq_chip_data(irq);
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         int virq;
+        u32 val;
 
         BUG_ON(!dev);
-        virq = irq - dev->irq_start;
+        virq = d->irq - dev->irq_start;
         val = readl(&dev->remote->int_device[virq >> 2]);
         switch (flow_type & IRQ_TYPE_SENSE_MASK) {
         case IRQ_TYPE_EDGE_RISING:
@@ -192,10 +192,9 @@ static int vlynq_irq_type(unsigned int irq, unsigned int flow_type)
         return 0;
 }
 
-static void vlynq_local_ack(unsigned int irq)
+static void vlynq_local_ack(struct irq_data *d)
 {
-        struct vlynq_device *dev = get_irq_chip_data(irq);
-
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         u32 status = readl(&dev->local->status);
 
         pr_debug("%s: local status: 0x%08x\n",
@@ -203,10 +202,9 @@ static void vlynq_local_ack(unsigned int irq)
         writel(status, &dev->local->status);
 }
 
-static void vlynq_remote_ack(unsigned int irq)
+static void vlynq_remote_ack(struct irq_data *d)
 {
-        struct vlynq_device *dev = get_irq_chip_data(irq);
-
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         u32 status = readl(&dev->remote->status);
 
         pr_debug("%s: remote status: 0x%08x\n",
@@ -238,23 +236,23 @@ static irqreturn_t vlynq_irq(int irq, void *dev_id)
 
 static struct irq_chip vlynq_irq_chip = {
         .name = "vlynq",
-        .unmask = vlynq_irq_unmask,
-        .mask = vlynq_irq_mask,
-        .set_type = vlynq_irq_type,
+        .irq_unmask = vlynq_irq_unmask,
+        .irq_mask = vlynq_irq_mask,
+        .irq_set_type = vlynq_irq_type,
 };
 
 static struct irq_chip vlynq_local_chip = {
         .name = "vlynq local error",
-        .unmask = vlynq_irq_unmask,
-        .mask = vlynq_irq_mask,
-        .ack = vlynq_local_ack,
+        .irq_unmask = vlynq_irq_unmask,
+        .irq_mask = vlynq_irq_mask,
+        .irq_ack = vlynq_local_ack,
 };
 
 static struct irq_chip vlynq_remote_chip = {
         .name = "vlynq local error",
-        .unmask = vlynq_irq_unmask,
-        .mask = vlynq_irq_mask,
-        .ack = vlynq_remote_ack,
+        .irq_unmask = vlynq_irq_unmask,
+        .irq_mask = vlynq_irq_mask,
+        .irq_ack = vlynq_remote_ack,
 };
 
 static int vlynq_setup_irq(struct vlynq_device *dev)
@@ -291,17 +289,17 @@ static int vlynq_setup_irq(struct vlynq_device *dev)
         for (i = dev->irq_start; i <= dev->irq_end; i++) {
                 virq = i - dev->irq_start;
                 if (virq == dev->local_irq) {
-                        set_irq_chip_and_handler(i, &vlynq_local_chip,
+                        irq_set_chip_and_handler(i, &vlynq_local_chip,
                                                  handle_level_irq);
-                        set_irq_chip_data(i, dev);
+                        irq_set_chip_data(i, dev);
                 } else if (virq == dev->remote_irq) {
-                        set_irq_chip_and_handler(i, &vlynq_remote_chip,
+                        irq_set_chip_and_handler(i, &vlynq_remote_chip,
                                                  handle_level_irq);
-                        set_irq_chip_data(i, dev);
+                        irq_set_chip_data(i, dev);
                 } else {
-                        set_irq_chip_and_handler(i, &vlynq_irq_chip,
+                        irq_set_chip_and_handler(i, &vlynq_irq_chip,
                                                  handle_simple_irq);
-                        set_irq_chip_data(i, dev);
+                        irq_set_chip_data(i, dev);
                         writel(0, &dev->remote->int_device[virq >> 2]);
                 }
         }
diff --git a/drivers/w1/masters/ds1wm.c b/drivers/w1/masters/ds1wm.c
index 95921b77cf86..2f4fa02744a5 100644
--- a/drivers/w1/masters/ds1wm.c
+++ b/drivers/w1/masters/ds1wm.c
@@ -368,9 +368,9 @@ static int ds1wm_probe(struct platform_device *pdev)
         ds1wm_data->active_high = plat->active_high;
 
         if (res->flags & IORESOURCE_IRQ_HIGHEDGE)
-                set_irq_type(ds1wm_data->irq, IRQ_TYPE_EDGE_RISING);
+                irq_set_irq_type(ds1wm_data->irq, IRQ_TYPE_EDGE_RISING);
         if (res->flags & IORESOURCE_IRQ_LOWEDGE)
-                set_irq_type(ds1wm_data->irq, IRQ_TYPE_EDGE_FALLING);
+                irq_set_irq_type(ds1wm_data->irq, IRQ_TYPE_EDGE_FALLING);
 
         ret = request_irq(ds1wm_data->irq, ds1wm_isr, IRQF_DISABLED,
                           "ds1wm", ds1wm_data);
diff --git a/drivers/watchdog/davinci_wdt.c b/drivers/watchdog/davinci_wdt.c
index 596ba604e78d..51b5551b4e3f 100644
--- a/drivers/watchdog/davinci_wdt.c
+++ b/drivers/watchdog/davinci_wdt.c
@@ -202,7 +202,6 @@ static struct miscdevice davinci_wdt_miscdev = {
 static int __devinit davinci_wdt_probe(struct platform_device *pdev)
 {
         int ret = 0, size;
-        struct resource *res;
         struct device *dev = &pdev->dev;
 
         wdt_clk = clk_get(dev, NULL);
@@ -216,31 +215,31 @@ static int __devinit davinci_wdt_probe(struct platform_device *pdev)
 
         dev_info(dev, "heartbeat %d sec\n", heartbeat);
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
+        wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (wdt_mem == NULL) {
                 dev_err(dev, "failed to get memory region resource\n");
                 return -ENOENT;
         }
 
-        size = resource_size(res);
-        wdt_mem = request_mem_region(res->start, size, pdev->name);
-
-        if (wdt_mem == NULL) {
+        size = resource_size(wdt_mem);
+        if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
                 dev_err(dev, "failed to get memory region\n");
                 return -ENOENT;
         }
 
-        wdt_base = ioremap(res->start, size);
+        wdt_base = ioremap(wdt_mem->start, size);
         if (!wdt_base) {
                 dev_err(dev, "failed to map memory region\n");
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
                 return -ENOMEM;
         }
 
         ret = misc_register(&davinci_wdt_miscdev);
         if (ret < 0) {
                 dev_err(dev, "cannot register misc device\n");
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
         } else {
                 set_bit(WDT_DEVICE_INITED, &wdt_status);
         }
@@ -253,8 +252,7 @@ static int __devexit davinci_wdt_remove(struct platform_device *pdev)
 {
         misc_deregister(&davinci_wdt_miscdev);
         if (wdt_mem) {
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, resource_size(wdt_mem));
                 wdt_mem = NULL;
         }
 
diff --git a/drivers/watchdog/max63xx_wdt.c b/drivers/watchdog/max63xx_wdt.c
index 7a82ce5a6337..73ba2fd8e591 100644
--- a/drivers/watchdog/max63xx_wdt.c
+++ b/drivers/watchdog/max63xx_wdt.c
@@ -270,7 +270,6 @@ static int __devinit max63xx_wdt_probe(struct platform_device *pdev)
 {
         int ret = 0;
         int size;
-        struct resource *res;
         struct device *dev = &pdev->dev;
         struct max63xx_timeout *table;
 
@@ -294,21 +293,19 @@ static int __devinit max63xx_wdt_probe(struct platform_device *pdev)
 
         max63xx_pdev = pdev;
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
+        wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (wdt_mem == NULL) {
                 dev_err(dev, "failed to get memory region resource\n");
                 return -ENOENT;
         }
 
-        size = resource_size(res);
-        wdt_mem = request_mem_region(res->start, size, pdev->name);
-
-        if (wdt_mem == NULL) {
+        size = resource_size(wdt_mem);
+        if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
                 dev_err(dev, "failed to get memory region\n");
                 return -ENOENT;
         }
 
-        wdt_base = ioremap(res->start, size);
+        wdt_base = ioremap(wdt_mem->start, size);
         if (!wdt_base) {
                 dev_err(dev, "failed to map memory region\n");
                 ret = -ENOMEM;
@@ -326,8 +323,8 @@ static int __devinit max63xx_wdt_probe(struct platform_device *pdev)
 out_unmap:
         iounmap(wdt_base);
 out_request:
-        release_resource(wdt_mem);
-        kfree(wdt_mem);
+        release_mem_region(wdt_mem->start, size);
+        wdt_mem = NULL;
 
         return ret;
 }
@@ -336,8 +333,7 @@ static int __devexit max63xx_wdt_remove(struct platform_device *pdev)
 {
         misc_deregister(&max63xx_wdt_miscdev);
         if (wdt_mem) {
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, resource_size(wdt_mem));
                 wdt_mem = NULL;
         }
 
diff --git a/drivers/watchdog/nv_tco.c b/drivers/watchdog/nv_tco.c
index 267377a5a83e..afa78a54711e 100644
--- a/drivers/watchdog/nv_tco.c
+++ b/drivers/watchdog/nv_tco.c
@@ -302,7 +302,7 @@ MODULE_DEVICE_TABLE(pci, tco_pci_tbl);
  *      Init & exit routines
  */
 
-static unsigned char __init nv_tco_getdevice(void)
+static unsigned char __devinit nv_tco_getdevice(void)
 {
         struct pci_dev *dev = NULL;
         u32 val;
diff --git a/drivers/watchdog/pnx4008_wdt.c b/drivers/watchdog/pnx4008_wdt.c
index c7cf4cbf8ab3..614933225560 100644
--- a/drivers/watchdog/pnx4008_wdt.c
+++ b/drivers/watchdog/pnx4008_wdt.c
@@ -254,7 +254,6 @@ static struct miscdevice pnx4008_wdt_miscdev = {
 static int __devinit pnx4008_wdt_probe(struct platform_device *pdev)
 {
         int ret = 0, size;
-        struct resource *res;
 
         if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
                 heartbeat = DEFAULT_HEARTBEAT;
@@ -262,42 +261,42 @@ static int __devinit pnx4008_wdt_probe(struct platform_device *pdev)
         printk(KERN_INFO MODULE_NAME
                 "PNX4008 Watchdog Timer: heartbeat %d sec\n", heartbeat);
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
+        wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (wdt_mem == NULL) {
                 printk(KERN_INFO MODULE_NAME
                         "failed to get memory region resouce\n");
                 return -ENOENT;
         }
 
-        size = resource_size(res);
-        wdt_mem = request_mem_region(res->start, size, pdev->name);
+        size = resource_size(wdt_mem);
 
-        if (wdt_mem == NULL) {
+        if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
                 printk(KERN_INFO MODULE_NAME "failed to get memory region\n");
                 return -ENOENT;
         }
-        wdt_base = (void __iomem *)IO_ADDRESS(res->start);
+        wdt_base = (void __iomem *)IO_ADDRESS(wdt_mem->start);
 
         wdt_clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(wdt_clk)) {
                 ret = PTR_ERR(wdt_clk);
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
                 goto out;
         }
 
         ret = clk_enable(wdt_clk);
         if (ret) {
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
+                clk_put(wdt_clk);
                 goto out;
         }
 
         ret = misc_register(&pnx4008_wdt_miscdev);
         if (ret < 0) {
                 printk(KERN_ERR MODULE_NAME "cannot register misc device\n");
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, size);
+                wdt_mem = NULL;
                 clk_disable(wdt_clk);
                 clk_put(wdt_clk);
         } else {
@@ -320,8 +319,7 @@ static int __devexit pnx4008_wdt_remove(struct platform_device *pdev)
         clk_put(wdt_clk);
 
         if (wdt_mem) {
-                release_resource(wdt_mem);
-                kfree(wdt_mem);
+                release_mem_region(wdt_mem->start, resource_size(wdt_mem));
                 wdt_mem = NULL;
         }
         return 0;
diff --git a/drivers/watchdog/s3c2410_wdt.c b/drivers/watchdog/s3c2410_wdt.c
index 25b39bf35925..f7f5aa00df60 100644
--- a/drivers/watchdog/s3c2410_wdt.c
+++ b/drivers/watchdog/s3c2410_wdt.c
@@ -402,7 +402,6 @@ static inline void s3c2410wdt_cpufreq_deregister(void)
 
 static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
 {
-        struct resource *res;
         struct device *dev;
         unsigned int wtcon;
         int started = 0;
@@ -416,20 +415,19 @@ static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
 
         /* get the memory region for the watchdog timer */
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res == NULL) {
+        wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (wdt_mem == NULL) {
                 dev_err(dev, "no memory resource specified\n");
                 return -ENOENT;
         }
 
-        size = resource_size(res);
-        wdt_mem = request_mem_region(res->start, size, pdev->name);
-        if (wdt_mem == NULL) {
+        size = resource_size(wdt_mem);
+        if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
                 dev_err(dev, "failed to get memory region\n");
                 return -EBUSY;
         }
 
-        wdt_base = ioremap(res->start, size);
+        wdt_base = ioremap(wdt_mem->start, size);
         if (wdt_base == NULL) {
                 dev_err(dev, "failed to ioremap() region\n");
                 ret = -EINVAL;
@@ -524,8 +522,8 @@ static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
         iounmap(wdt_base);
 
  err_req:
-        release_resource(wdt_mem);
-        kfree(wdt_mem);
+        release_mem_region(wdt_mem->start, size);
+        wdt_mem = NULL;
 
         return ret;
 }
@@ -545,8 +543,7 @@ static int __devexit s3c2410wdt_remove(struct platform_device *dev)
 
         iounmap(wdt_base);
 
-        release_resource(wdt_mem);
-        kfree(wdt_mem);
+        release_mem_region(wdt_mem->start, resource_size(wdt_mem));
         wdt_mem = NULL;
         return 0;
 }
diff --git a/drivers/watchdog/softdog.c b/drivers/watchdog/softdog.c
index 100b114e3c3c..bf16ffb4d21e 100644
--- a/drivers/watchdog/softdog.c
+++ b/drivers/watchdog/softdog.c
@@ -48,6 +48,7 @@
 #include <linux/init.h>
 #include <linux/jiffies.h>
 #include <linux/uaccess.h>
+#include <linux/kernel.h>
 
 #define PFX "SoftDog: "
 
@@ -75,6 +76,11 @@ MODULE_PARM_DESC(soft_noboot,
         "Softdog action, set to 1 to ignore reboots, 0 to reboot "
                                         "(default depends on ONLY_TESTING)");
 
+static int soft_panic;
+module_param(soft_panic, int, 0);
+MODULE_PARM_DESC(soft_panic,
+        "Softdog action, set to 1 to panic, 0 to reboot (default=0)");
+
 /*
  *      Our timer
  */
@@ -98,7 +104,10 @@ static void watchdog_fire(unsigned long data)
 
         if (soft_noboot)
                 printk(KERN_CRIT PFX "Triggered - Reboot ignored.\n");
-        else {
+        else if (soft_panic) {
+                printk(KERN_CRIT PFX "Initiating panic.\n");
+                panic("Software Watchdog Timer expired.");
+        } else {
                 printk(KERN_CRIT PFX "Initiating system reboot.\n");
                 emergency_restart();
                 printk(KERN_CRIT PFX "Reboot didn't ?????\n");
@@ -267,7 +276,8 @@ static struct notifier_block softdog_notifier = {
 };
 
 static char banner[] __initdata = KERN_INFO "Software Watchdog Timer: 0.07 "
-        "initialized. soft_noboot=%d soft_margin=%d sec (nowayout= %d)\n";
+        "initialized. soft_noboot=%d soft_margin=%d sec soft_panic=%d "
+        "(nowayout= %d)\n";
 
 static int __init watchdog_init(void)
 {
@@ -298,7 +308,7 @@ static int __init watchdog_init(void)
                 return ret;
         }
 
-        printk(banner, soft_noboot, soft_margin, nowayout);
+        printk(banner, soft_noboot, soft_margin, soft_panic, nowayout);
 
         return 0;
 }
diff --git a/drivers/watchdog/sp5100_tco.c b/drivers/watchdog/sp5100_tco.c
index 1bc493848ed4..87e0527669d8 100644
--- a/drivers/watchdog/sp5100_tco.c
+++ b/drivers/watchdog/sp5100_tco.c
@@ -42,6 +42,7 @@
 #define PFX TCO_MODULE_NAME ": "
 
 /* internal variables */
+static u32 tcobase_phys;
 static void __iomem *tcobase;
 static unsigned int pm_iobase;
 static DEFINE_SPINLOCK(tco_lock);       /* Guards the hardware */
@@ -305,10 +306,18 @@ static unsigned char __devinit sp5100_tco_setupdevice(void)
         /* Low three bits of BASE0 are reserved. */
         val = val << 8 | (inb(SP5100_IO_PM_DATA_REG) & 0xf8);
 
+        if (!request_mem_region_exclusive(val, SP5100_WDT_MEM_MAP_SIZE,
+                                                                "SP5100 TCO")) {
+                printk(KERN_ERR PFX "mmio address 0x%04x already in use\n",
+                        val);
+                goto unreg_region;
+        }
+        tcobase_phys = val;
+
         tcobase = ioremap(val, SP5100_WDT_MEM_MAP_SIZE);
         if (tcobase == 0) {
                 printk(KERN_ERR PFX "failed to get tcobase address\n");
-                goto unreg_region;
+                goto unreg_mem_region;
         }
 
         /* Enable watchdog decode bit */
@@ -346,7 +355,8 @@ static unsigned char __devinit sp5100_tco_setupdevice(void)
         /* Done */
         return 1;
 
-        iounmap(tcobase);
+unreg_mem_region:
+        release_mem_region(tcobase_phys, SP5100_WDT_MEM_MAP_SIZE);
 unreg_region:
         release_region(pm_iobase, SP5100_PM_IOPORTS_SIZE);
 exit:
@@ -401,6 +411,7 @@ static int __devinit sp5100_tco_init(struct platform_device *dev)
 
 exit:
         iounmap(tcobase);
+        release_mem_region(tcobase_phys, SP5100_WDT_MEM_MAP_SIZE);
         release_region(pm_iobase, SP5100_PM_IOPORTS_SIZE);
         return ret;
 }
@@ -414,6 +425,7 @@ static void __devexit sp5100_tco_cleanup(void)
         /* Deregister */
         misc_deregister(&sp5100_tco_miscdev);
         iounmap(tcobase);
+        release_mem_region(tcobase_phys, SP5100_WDT_MEM_MAP_SIZE);
         release_region(pm_iobase, SP5100_PM_IOPORTS_SIZE);
 }
 
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index 02b5a9c05cfa..036343ba204e 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -122,7 +122,7 @@ static struct irq_chip xen_pirq_chip;
 /* Get info for IRQ */
 static struct irq_info *info_for_irq(unsigned irq)
 {
-        return get_irq_data(irq);
+        return irq_get_handler_data(irq);
 }
 
 /* Constructors for packed IRQ information. */
@@ -403,7 +403,7 @@ static void xen_irq_init(unsigned irq)
 
         info->type = IRQT_UNBOUND;
 
-        set_irq_data(irq, info);
+        irq_set_handler_data(irq, info);
 
         list_add_tail(&info->list, &xen_irq_list_head);
 }
@@ -458,11 +458,11 @@ static int __must_check xen_allocate_irq_gsi(unsigned gsi)
 
 static void xen_free_irq(unsigned irq)
 {
-        struct irq_info *info = get_irq_data(irq);
+        struct irq_info *info = irq_get_handler_data(irq);
 
         list_del(&info->list);
 
-        set_irq_data(irq, NULL);
+        irq_set_handler_data(irq, NULL);
 
         kfree(info);
 
@@ -585,7 +585,7 @@ static void ack_pirq(struct irq_data *data)
 {
         int evtchn = evtchn_from_irq(data->irq);
 
-        move_native_irq(data->irq);
+        irq_move_irq(data);
 
         if (VALID_EVTCHN(evtchn)) {
                 mask_evtchn(evtchn);
@@ -639,8 +639,8 @@ int xen_bind_pirq_gsi_to_irq(unsigned gsi,
         if (irq < 0)
                 goto out;
 
-        set_irq_chip_and_handler_name(irq, &xen_pirq_chip,
-                                      handle_level_irq, name);
+        irq_set_chip_and_handler_name(irq, &xen_pirq_chip, handle_level_irq,
+                                      name);
 
         irq_op.irq = irq;
         irq_op.vector = 0;
@@ -690,8 +690,8 @@ int xen_bind_pirq_msi_to_irq(struct pci_dev *dev, struct msi_desc *msidesc,
         if (irq == -1)
                 goto out;
 
-        set_irq_chip_and_handler_name(irq, &xen_pirq_chip,
-                                      handle_level_irq, name);
+        irq_set_chip_and_handler_name(irq, &xen_pirq_chip, handle_level_irq,
+                                      name);
 
         xen_irq_info_pirq_init(irq, 0, pirq, 0, vector, 0);
         ret = irq_set_msi_desc(irq, msidesc);
@@ -772,7 +772,7 @@ int bind_evtchn_to_irq(unsigned int evtchn)
                 if (irq == -1)
                         goto out;
 
-                set_irq_chip_and_handler_name(irq, &xen_dynamic_chip,
+                irq_set_chip_and_handler_name(irq, &xen_dynamic_chip,
                                               handle_fasteoi_irq, "event");
 
                 xen_irq_info_evtchn_init(irq, evtchn);
@@ -799,7 +799,7 @@ static int bind_ipi_to_irq(unsigned int ipi, unsigned int cpu)
                 if (irq < 0)
                         goto out;
 
-                set_irq_chip_and_handler_name(irq, &xen_percpu_chip,
+                irq_set_chip_and_handler_name(irq, &xen_percpu_chip,
                                               handle_percpu_irq, "ipi");
 
                 bind_ipi.vcpu = cpu;
@@ -848,7 +848,7 @@ int bind_virq_to_irq(unsigned int virq, unsigned int cpu)
                 if (irq == -1)
                         goto out;
 
-                set_irq_chip_and_handler_name(irq, &xen_percpu_chip,
+                irq_set_chip_and_handler_name(irq, &xen_percpu_chip,
                                               handle_percpu_irq, "virq");
 
                 bind_virq.virq = virq;
@@ -1339,7 +1339,7 @@ static void ack_dynirq(struct irq_data *data)
 {
         int evtchn = evtchn_from_irq(data->irq);
 
-        move_masked_irq(data->irq);
+        irq_move_masked_irq(data);
 
         if (VALID_EVTCHN(evtchn))
                 unmask_evtchn(evtchn);
diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c
index 017ce600fbc6..b0f9e8fb0052 100644
--- a/drivers/xen/gntdev.c
+++ b/drivers/xen/gntdev.c
@@ -273,7 +273,7 @@ static int __unmap_grant_pages(struct grant_map *map, int offset, int pages)
                                 map->vma->vm_start + map->notify.addr;
                         err = copy_to_user(tmp, &err, 1);
                         if (err)
-                                return err;
+                                return -EFAULT;
                         map->notify.flags &= ~UNMAP_NOTIFY_CLEAR_BYTE;
                 } else if (pgno >= offset && pgno < offset + pages) {
                         uint8_t *tmp = kmap(map->pages[pgno]);
@@ -662,7 +662,7 @@ static int gntdev_mmap(struct file *flip, struct vm_area_struct *vma)
         if (map->flags) {
                 if ((vma->vm_flags & VM_WRITE) &&
                                 (map->flags & GNTMAP_readonly))
-                        return -EINVAL;
+                        goto out_unlock_put;
         } else {
                 map->flags = GNTMAP_host_map;
                 if (!(vma->vm_flags & VM_WRITE))
@@ -700,6 +700,8 @@ unlock_out:
         spin_unlock(&priv->lock);
         return err;
 
+out_unlock_put:
+        spin_unlock(&priv->lock);
 out_put_map:
         if (use_ptemod)
                 map->vma = NULL;