224 files changed, 5307 insertions, 2142 deletions

diff --git a/drivers/Makefile b/drivers/Makefile
index 1b3142127bf5..c07be024b962 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -97,7 +97,7 @@ obj-$(CONFIG_EISA)		+= eisa/
 obj-y                           += lguest/
 obj-$(CONFIG_CPU_FREQ)          += cpufreq/
 obj-$(CONFIG_CPU_IDLE)          += cpuidle/
-obj-$(CONFIG_MMC)               += mmc/
+obj-y                           += mmc/
 obj-$(CONFIG_MEMSTICK)          += memstick/
 obj-y                           += leds/
 obj-$(CONFIG_INFINIBAND)        += infiniband/
diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index fcbec8ac134d..7be9f79018e9 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -179,7 +179,7 @@ config GENERIC_CPU_DEVICES
 source "drivers/base/regmap/Kconfig"
 
 config DMA_SHARED_BUFFER
-        bool "Buffer framework to be shared between drivers"
+        bool
         default n
         select ANON_INODES
         depends on EXPERIMENTAL
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index f17e3ea041c0..ed5de58c340f 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -295,11 +295,22 @@ static int memory_block_change_state(struct memory_block *mem,
 
         ret = memory_block_action(mem->start_section_nr, to_state);
 
-        if (ret)
+        if (ret) {
                 mem->state = from_state_req;
-        else
-                mem->state = to_state;
+                goto out;
+        }
 
+        mem->state = to_state;
+        switch (mem->state) {
+        case MEM_OFFLINE:
+                kobject_uevent(&mem->dev.kobj, KOBJ_OFFLINE);
+                break;
+        case MEM_ONLINE:
+                kobject_uevent(&mem->dev.kobj, KOBJ_ONLINE);
+                break;
+        default:
+                break;
+        }
 out:
         mutex_unlock(&mem->state_mutex);
         return ret;
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 148ab944378d..3fd31dec8c9c 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -2184,6 +2184,8 @@ static ssize_t rbd_add(struct bus_type *bus,
         INIT_LIST_HEAD(&rbd_dev->node);
         INIT_LIST_HEAD(&rbd_dev->snaps);
 
+        init_rwsem(&rbd_dev->header.snap_rwsem);
+
         /* generate unique id: find highest unique id, add one */
         mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
 
diff --git a/drivers/char/ramoops.c b/drivers/char/ramoops.c
index 7c7f42a1f880..9fec3232b736 100644
--- a/drivers/char/ramoops.c
+++ b/drivers/char/ramoops.c
@@ -83,8 +83,7 @@ static void ramoops_do_dump(struct kmsg_dumper *dumper,
         struct timeval timestamp;
 
         if (reason != KMSG_DUMP_OOPS &&
-            reason != KMSG_DUMP_PANIC &&
-            reason != KMSG_DUMP_KEXEC)
+            reason != KMSG_DUMP_PANIC)
                 return;
 
         /* Only dump oopses if dump_oops is set */
@@ -126,8 +125,8 @@ static int __init ramoops_probe(struct platform_device *pdev)
                 goto fail3;
         }
 
-        rounddown_pow_of_two(pdata->mem_size);
-        rounddown_pow_of_two(pdata->record_size);
+        pdata->mem_size = rounddown_pow_of_two(pdata->mem_size);
+        pdata->record_size = rounddown_pow_of_two(pdata->record_size);
 
         /* Check for the minimum memory size */
         if (pdata->mem_size < MIN_MEM_SIZE &&
@@ -148,14 +147,6 @@ static int __init ramoops_probe(struct platform_device *pdev)
         cxt->phys_addr = pdata->mem_address;
         cxt->record_size = pdata->record_size;
         cxt->dump_oops = pdata->dump_oops;
-        /*
-         * Update the module parameter variables as well so they are visible
-         * through /sys/module/ramoops/parameters/
-         */
-        mem_size = pdata->mem_size;
-        mem_address = pdata->mem_address;
-        record_size = pdata->record_size;
-        dump_oops = pdata->dump_oops;
 
         if (!request_mem_region(cxt->phys_addr, cxt->size, "ramoops")) {
                 pr_err("request mem region failed\n");
@@ -176,6 +167,15 @@ static int __init ramoops_probe(struct platform_device *pdev)
                 goto fail1;
         }
 
+        /*
+         * Update the module parameter variables as well so they are visible
+         * through /sys/module/ramoops/parameters/
+         */
+        mem_size = pdata->mem_size;
+        mem_address = pdata->mem_address;
+        record_size = pdata->record_size;
+        dump_oops = pdata->dump_oops;
+
         return 0;
 
 fail1:
diff --git a/drivers/gpio/gpio-stmpe.c b/drivers/gpio/gpio-stmpe.c
index 4c980b573328..87a68a896abf 100644
--- a/drivers/gpio/gpio-stmpe.c
+++ b/drivers/gpio/gpio-stmpe.c
@@ -65,7 +65,14 @@ static void stmpe_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
         u8 reg = stmpe->regs[which] - (offset / 8);
         u8 mask = 1 << (offset % 8);
 
-        stmpe_reg_write(stmpe, reg, mask);
+        /*
+         * Some variants have single register for gpio set/clear functionality.
+         * For them we need to write 0 to clear and 1 to set.
+         */
+        if (stmpe->regs[STMPE_IDX_GPSR_LSB] == stmpe->regs[STMPE_IDX_GPCR_LSB])
+                stmpe_set_bits(stmpe, reg, mask, val ? mask : 0);
+        else
+                stmpe_reg_write(stmpe, reg, mask);
 }
 
 static int stmpe_gpio_direction_output(struct gpio_chip *chip,
@@ -132,6 +139,10 @@ static int stmpe_gpio_irq_set_type(struct irq_data *d, unsigned int type)
         if (type == IRQ_TYPE_LEVEL_LOW || type == IRQ_TYPE_LEVEL_HIGH)
                 return -EINVAL;
 
+        /* STMPE801 doesn't have RE and FE registers */
+        if (stmpe_gpio->stmpe->partnum == STMPE801)
+                return 0;
+
         if (type == IRQ_TYPE_EDGE_RISING)
                 stmpe_gpio->regs[REG_RE][regoffset] |= mask;
         else
@@ -165,6 +176,11 @@ static void stmpe_gpio_irq_sync_unlock(struct irq_data *d)
         int i, j;
 
         for (i = 0; i < CACHE_NR_REGS; i++) {
+                /* STMPE801 doesn't have RE and FE registers */
+                if ((stmpe->partnum == STMPE801) &&
+                                (i != REG_IE))
+                        continue;
+
                 for (j = 0; j < num_banks; j++) {
                         u8 old = stmpe_gpio->oldregs[i][j];
                         u8 new = stmpe_gpio->regs[i][j];
@@ -241,8 +257,11 @@ static irqreturn_t stmpe_gpio_irq(int irq, void *dev)
                 }
 
                 stmpe_reg_write(stmpe, statmsbreg + i, status[i]);
-                stmpe_reg_write(stmpe, stmpe->regs[STMPE_IDX_GPEDR_MSB] + i,
-                                status[i]);
+
+                /* Edge detect register is not present on 801 */
+                if (stmpe->partnum != STMPE801)
+                        stmpe_reg_write(stmpe, stmpe->regs[STMPE_IDX_GPEDR_MSB]
+                                        + i, status[i]);
         }
 
         return IRQ_HANDLED;
diff --git a/drivers/gpu/drm/gma500/cdv_intel_crt.c b/drivers/gpu/drm/gma500/cdv_intel_crt.c
index 6d0f10b7569c..c100f3e9c920 100644
--- a/drivers/gpu/drm/gma500/cdv_intel_crt.c
+++ b/drivers/gpu/drm/gma500/cdv_intel_crt.c
@@ -66,6 +66,7 @@ static void cdv_intel_crt_dpms(struct drm_encoder *encoder, int mode)
 static int cdv_intel_crt_mode_valid(struct drm_connector *connector,
                                 struct drm_display_mode *mode)
 {
+        struct drm_psb_private *dev_priv = connector->dev->dev_private;
         int max_clock = 0;
         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
                 return MODE_NO_DBLESCAN;
@@ -82,6 +83,11 @@ static int cdv_intel_crt_mode_valid(struct drm_connector *connector,
         if (mode->hdisplay > 1680 || mode->vdisplay > 1050)
                 return MODE_PANEL;
 
+        /* We assume worst case scenario of 32 bpp here, since we don't know */
+        if ((ALIGN(mode->hdisplay * 4, 64) * mode->vdisplay) >
+            dev_priv->vram_stolen_size)
+                return MODE_MEM;
+
         return MODE_OK;
 }
 
diff --git a/drivers/gpu/drm/gma500/cdv_intel_hdmi.c b/drivers/gpu/drm/gma500/cdv_intel_hdmi.c
index 50d7cfb51662..de25560e629d 100644
--- a/drivers/gpu/drm/gma500/cdv_intel_hdmi.c
+++ b/drivers/gpu/drm/gma500/cdv_intel_hdmi.c
@@ -241,6 +241,7 @@ static int cdv_hdmi_get_modes(struct drm_connector *connector)
 static int cdv_hdmi_mode_valid(struct drm_connector *connector,
                                  struct drm_display_mode *mode)
 {
+        struct drm_psb_private *dev_priv = connector->dev->dev_private;
 
         if (mode->clock > 165000)
                 return MODE_CLOCK_HIGH;
@@ -255,14 +256,11 @@ static int cdv_hdmi_mode_valid(struct drm_connector *connector,
         if (mode->flags & DRM_MODE_FLAG_INTERLACE)
                 return MODE_NO_INTERLACE;
 
-        /*
-         * FIXME: for now we limit the size to 1680x1050 on CDV, otherwise it
-         * will go beyond the stolen memory size allocated to the framebuffer
-         */
-        if (mode->hdisplay > 1680)
-                return MODE_PANEL;
-        if (mode->vdisplay > 1050)
-                return MODE_PANEL;
+        /* We assume worst case scenario of 32 bpp here, since we don't know */
+        if ((ALIGN(mode->hdisplay * 4, 64) * mode->vdisplay) >
+            dev_priv->vram_stolen_size)
+                return MODE_MEM;
+
         return MODE_OK;
 }
 
diff --git a/drivers/gpu/drm/gma500/oaktrail_hdmi.c b/drivers/gpu/drm/gma500/oaktrail_hdmi.c
index 36878a60080d..025d30970cc0 100644
--- a/drivers/gpu/drm/gma500/oaktrail_hdmi.c
+++ b/drivers/gpu/drm/gma500/oaktrail_hdmi.c
@@ -506,6 +506,7 @@ int oaktrail_crtc_hdmi_mode_set(struct drm_crtc *crtc,
 static int oaktrail_hdmi_mode_valid(struct drm_connector *connector,
                                 struct drm_display_mode *mode)
 {
+        struct drm_psb_private *dev_priv = connector->dev->dev_private;
         if (mode->clock > 165000)
                 return MODE_CLOCK_HIGH;
         if (mode->clock < 20000)
@@ -514,6 +515,11 @@ static int oaktrail_hdmi_mode_valid(struct drm_connector *connector,
         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
                 return MODE_NO_DBLESCAN;
 
+        /* We assume worst case scenario of 32 bpp here, since we don't know */
+        if ((ALIGN(mode->hdisplay * 4, 64) * mode->vdisplay) >
+            dev_priv->vram_stolen_size)
+                return MODE_MEM;
+
         return MODE_OK;
 }
 
diff --git a/drivers/gpu/drm/gma500/psb_intel_sdvo.c b/drivers/gpu/drm/gma500/psb_intel_sdvo.c
index 4882b29119e0..88b42971c0fd 100644
--- a/drivers/gpu/drm/gma500/psb_intel_sdvo.c
+++ b/drivers/gpu/drm/gma500/psb_intel_sdvo.c
@@ -1141,6 +1141,7 @@ static void psb_intel_sdvo_dpms(struct drm_encoder *encoder, int mode)
 static int psb_intel_sdvo_mode_valid(struct drm_connector *connector,
                                  struct drm_display_mode *mode)
 {
+        struct drm_psb_private *dev_priv = connector->dev->dev_private;
         struct psb_intel_sdvo *psb_intel_sdvo = intel_attached_sdvo(connector);
 
         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
@@ -1160,6 +1161,11 @@ static int psb_intel_sdvo_mode_valid(struct drm_connector *connector,
                         return MODE_PANEL;
         }
 
+        /* We assume worst case scenario of 32 bpp here, since we don't know */
+        if ((ALIGN(mode->hdisplay * 4, 64) * mode->vdisplay) >
+            dev_priv->vram_stolen_size)
+                return MODE_MEM;
+
         return MODE_OK;
 }
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_acpi.c b/drivers/gpu/drm/nouveau/nouveau_acpi.c
index 525744d593c1..7814a760c164 100644
--- a/drivers/gpu/drm/nouveau/nouveau_acpi.c
+++ b/drivers/gpu/drm/nouveau/nouveau_acpi.c
@@ -18,12 +18,6 @@
 
 #include <linux/vga_switcheroo.h>
 
-#define NOUVEAU_DSM_SUPPORTED 0x00
-#define NOUVEAU_DSM_SUPPORTED_FUNCTIONS 0x00
-
-#define NOUVEAU_DSM_ACTIVE 0x01
-#define NOUVEAU_DSM_ACTIVE_QUERY 0x00
-
 #define NOUVEAU_DSM_LED 0x02
 #define NOUVEAU_DSM_LED_STATE 0x00
 #define NOUVEAU_DSM_LED_OFF 0x10
@@ -35,6 +29,9 @@
 #define NOUVEAU_DSM_POWER_SPEED 0x01
 #define NOUVEAU_DSM_POWER_STAMINA 0x02
 
+#define NOUVEAU_DSM_OPTIMUS_FN 0x1A
+#define NOUVEAU_DSM_OPTIMUS_ARGS 0x03000001
+
 static struct nouveau_dsm_priv {
         bool dsm_detected;
         bool optimus_detected;
@@ -61,7 +58,8 @@ static int nouveau_optimus_dsm(acpi_handle handle, int func, int arg, uint32_t *
         struct acpi_object_list input;
         union acpi_object params[4];
         union acpi_object *obj;
-        int err;
+        int i, err;
+        char args_buff[4];
 
         input.count = 4;
         input.pointer = params;
@@ -73,7 +71,11 @@ static int nouveau_optimus_dsm(acpi_handle handle, int func, int arg, uint32_t *
         params[2].type = ACPI_TYPE_INTEGER;
         params[2].integer.value = func;
         params[3].type = ACPI_TYPE_BUFFER;
-        params[3].buffer.length = 0;
+        params[3].buffer.length = 4;
+        /* ACPI is little endian, AABBCCDD becomes {DD,CC,BB,AA} */
+        for (i = 0; i < 4; i++)
+                args_buff[i] = (arg >> i * 8) & 0xFF;
+        params[3].buffer.pointer = args_buff;
 
         err = acpi_evaluate_object(handle, "_DSM", &input, &output);
         if (err) {
@@ -148,6 +150,23 @@ static int nouveau_dsm(acpi_handle handle, int func, int arg, uint32_t *result)
         return 0;
 }
 
+/* Returns 1 if a DSM function is usable and 0 otherwise */
+static int nouveau_test_dsm(acpi_handle test_handle,
+        int (*dsm_func)(acpi_handle, int, int, uint32_t *),
+        int sfnc)
+{
+        u32 result = 0;
+
+        /* Function 0 returns a Buffer containing available functions. The args
+         * parameter is ignored for function 0, so just put 0 in it */
+        if (dsm_func(test_handle, 0, 0, &result))
+                return 0;
+
+        /* ACPI Spec v4 9.14.1: if bit 0 is zero, no function is supported. If
+         * the n-th bit is enabled, function n is supported */
+        return result & 1 && result & (1 << sfnc);
+}
+
 static int nouveau_dsm_switch_mux(acpi_handle handle, int mux_id)
 {
         mxm_wmi_call_mxmx(mux_id == NOUVEAU_DSM_LED_STAMINA ? MXM_MXDS_ADAPTER_IGD : MXM_MXDS_ADAPTER_0);
@@ -168,6 +187,10 @@ static int nouveau_dsm_set_discrete_state(acpi_handle handle, enum vga_switchero
 
 static int nouveau_dsm_switchto(enum vga_switcheroo_client_id id)
 {
+        /* perhaps the _DSM functions are mutually exclusive, but prepare for
+         * the future */
+        if (!nouveau_dsm_priv.dsm_detected && nouveau_dsm_priv.optimus_detected)
+                return 0;
         if (id == VGA_SWITCHEROO_IGD)
                 return nouveau_dsm_switch_mux(nouveau_dsm_priv.dhandle, NOUVEAU_DSM_LED_STAMINA);
         else
@@ -180,6 +203,11 @@ static int nouveau_dsm_power_state(enum vga_switcheroo_client_id id,
         if (id == VGA_SWITCHEROO_IGD)
                 return 0;
 
+        /* Optimus laptops have the card already disabled in
+         * nouveau_switcheroo_set_state */
+        if (!nouveau_dsm_priv.dsm_detected && nouveau_dsm_priv.optimus_detected)
+                return 0;
+
         return nouveau_dsm_set_discrete_state(nouveau_dsm_priv.dhandle, state);
 }
 
@@ -212,8 +240,7 @@ static int nouveau_dsm_pci_probe(struct pci_dev *pdev)
 {
         acpi_handle dhandle, nvidia_handle;
         acpi_status status;
-        int ret, retval = 0;
-        uint32_t result;
+        int retval = 0;
 
         dhandle = DEVICE_ACPI_HANDLE(&pdev->dev);
         if (!dhandle)
@@ -224,13 +251,11 @@ static int nouveau_dsm_pci_probe(struct pci_dev *pdev)
                 return false;
         }
 
-        ret = nouveau_dsm(dhandle, NOUVEAU_DSM_SUPPORTED,
-                          NOUVEAU_DSM_SUPPORTED_FUNCTIONS, &result);
-        if (ret == 0)
+        if (nouveau_test_dsm(dhandle, nouveau_dsm, NOUVEAU_DSM_POWER))
                 retval |= NOUVEAU_DSM_HAS_MUX;
 
-        ret = nouveau_optimus_dsm(dhandle, 0, 0, &result);
-        if (ret == 0)
+        if (nouveau_test_dsm(dhandle, nouveau_optimus_dsm,
+                NOUVEAU_DSM_OPTIMUS_FN))
                 retval |= NOUVEAU_DSM_HAS_OPT;
 
         if (retval)
@@ -269,15 +294,22 @@ static bool nouveau_dsm_detect(void)
         }
 
         if (vga_count == 2 && has_dsm && guid_valid) {
-                acpi_get_name(nouveau_dsm_priv.dhandle, ACPI_FULL_PATHNAME, &buffer);
+                acpi_get_name(nouveau_dsm_priv.dhandle, ACPI_FULL_PATHNAME,
+                        &buffer);
                 printk(KERN_INFO "VGA switcheroo: detected DSM switching method %s handle\n",
-                       acpi_method_name);
+                        acpi_method_name);
                 nouveau_dsm_priv.dsm_detected = true;
                 ret = true;
         }
 
-        if (has_optimus == 1)
+        if (has_optimus == 1) {
+                acpi_get_name(nouveau_dsm_priv.dhandle, ACPI_FULL_PATHNAME,
+                        &buffer);
+                printk(KERN_INFO "VGA switcheroo: detected Optimus DSM method %s handle\n",
+                        acpi_method_name);
                 nouveau_dsm_priv.optimus_detected = true;
+                ret = true;
+        }
 
         return ret;
 }
@@ -293,6 +325,17 @@ void nouveau_register_dsm_handler(void)
         vga_switcheroo_register_handler(&nouveau_dsm_handler);
 }
 
+/* Must be called for Optimus models before the card can be turned off */
+void nouveau_switcheroo_optimus_dsm(void)
+{
+        u32 result = 0;
+        if (!nouveau_dsm_priv.optimus_detected)
+                return;
+
+        nouveau_optimus_dsm(nouveau_dsm_priv.dhandle, NOUVEAU_DSM_OPTIMUS_FN,
+                NOUVEAU_DSM_OPTIMUS_ARGS, &result);
+}
+
 void nouveau_unregister_dsm_handler(void)
 {
         vga_switcheroo_unregister_handler();
diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.h b/drivers/gpu/drm/nouveau/nouveau_drv.h
index 38134a9c7578..b82709828931 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drv.h
+++ b/drivers/gpu/drm/nouveau/nouveau_drv.h
@@ -1055,12 +1055,14 @@ extern int  nouveau_dma_wait(struct nouveau_channel *, int slots, int size);
 #if defined(CONFIG_ACPI)
 void nouveau_register_dsm_handler(void);
 void nouveau_unregister_dsm_handler(void);
+void nouveau_switcheroo_optimus_dsm(void);
 int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len);
 bool nouveau_acpi_rom_supported(struct pci_dev *pdev);
 int nouveau_acpi_edid(struct drm_device *, struct drm_connector *);
 #else
 static inline void nouveau_register_dsm_handler(void) {}
 static inline void nouveau_unregister_dsm_handler(void) {}
+static inline void nouveau_switcheroo_optimus_dsm(void) {}
 static inline bool nouveau_acpi_rom_supported(struct pci_dev *pdev) { return false; }
 static inline int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len) { return -EINVAL; }
 static inline int nouveau_acpi_edid(struct drm_device *dev, struct drm_connector *connector) { return -EINVAL; }
diff --git a/drivers/gpu/drm/nouveau/nouveau_state.c b/drivers/gpu/drm/nouveau/nouveau_state.c
index f5e98910d17f..f80c5e0762ff 100644
--- a/drivers/gpu/drm/nouveau/nouveau_state.c
+++ b/drivers/gpu/drm/nouveau/nouveau_state.c
@@ -525,6 +525,7 @@ static void nouveau_switcheroo_set_state(struct pci_dev *pdev,
                 printk(KERN_ERR "VGA switcheroo: switched nouveau off\n");
                 dev->switch_power_state = DRM_SWITCH_POWER_CHANGING;
                 drm_kms_helper_poll_disable(dev);
+                nouveau_switcheroo_optimus_dsm();
                 nouveau_pci_suspend(pdev, pmm);
                 dev->switch_power_state = DRM_SWITCH_POWER_OFF;
         }
diff --git a/drivers/gpu/drm/radeon/evergreen_cs.c b/drivers/gpu/drm/radeon/evergreen_cs.c
index f7442e62c03f..8e8cd85e5c00 100644
--- a/drivers/gpu/drm/radeon/evergreen_cs.c
+++ b/drivers/gpu/drm/radeon/evergreen_cs.c
@@ -1793,10 +1793,12 @@ int evergreen_ib_parse(struct radeon_device *rdev, struct radeon_ib *ib)
                         ret = -EINVAL;
                         break;
                 case PACKET_TYPE2:
+                        idx += 1;
                         break;
                 case PACKET_TYPE3:
                         pkt.opcode = CP_PACKET3_GET_OPCODE(ib->ptr[idx]);
                         ret = evergreen_vm_packet3_check(rdev, ib->ptr, &pkt);
+                        idx += pkt.count + 2;
                         break;
                 default:
                         dev_err(rdev->dev, "Unknown packet type %d !\n", pkt.type);
@@ -1805,7 +1807,6 @@ int evergreen_ib_parse(struct radeon_device *rdev, struct radeon_ib *ib)
                 }
                 if (ret)
                         break;
-                idx += pkt.count + 2;
         } while (idx < ib->length_dw);
 
         return ret;
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c
index 3ec81c3d5108..bfd36ab643a6 100644
--- a/drivers/gpu/drm/radeon/r100.c
+++ b/drivers/gpu/drm/radeon/r100.c
@@ -2186,7 +2186,6 @@ bool r100_gpu_is_lockup(struct radeon_device *rdev, struct radeon_ring *ring)
 void r100_bm_disable(struct radeon_device *rdev)
 {
         u32 tmp;
-        u16 tmp16;
 
         /* disable bus mastering */
         tmp = RREG32(R_000030_BUS_CNTL);
@@ -2197,8 +2196,7 @@ void r100_bm_disable(struct radeon_device *rdev)
         WREG32(R_000030_BUS_CNTL, (tmp & 0xFFFFFFFF) | 0x00000040);
         tmp = RREG32(RADEON_BUS_CNTL);
         mdelay(1);
-        pci_read_config_word(rdev->pdev, 0x4, &tmp16);
-        pci_write_config_word(rdev->pdev, 0x4, tmp16 & 0xFFFB);
+        pci_clear_master(rdev->pdev);
         mdelay(1);
 }
 
diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c
index 31da622eef63..8032f1fedb11 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.c
+++ b/drivers/gpu/drm/radeon/radeon_drv.c
@@ -145,7 +145,7 @@ module_param_named(vramlimit, radeon_vram_limit, int, 0600);
 MODULE_PARM_DESC(agpmode, "AGP Mode (-1 == PCI)");
 module_param_named(agpmode, radeon_agpmode, int, 0444);
 
-MODULE_PARM_DESC(gartsize, "Size of PCIE/IGP gart to setup in megabytes (32,64, etc)\n");
+MODULE_PARM_DESC(gartsize, "Size of PCIE/IGP gart to setup in megabytes (32, 64, etc)");
 module_param_named(gartsize, radeon_gart_size, int, 0600);
 
 MODULE_PARM_DESC(benchmark, "Run benchmark");
diff --git a/drivers/gpu/drm/radeon/rs600.c b/drivers/gpu/drm/radeon/rs600.c
index 803e0d3c1773..ec46eb45e34c 100644
--- a/drivers/gpu/drm/radeon/rs600.c
+++ b/drivers/gpu/drm/radeon/rs600.c
@@ -322,16 +322,6 @@ void rs600_hpd_fini(struct radeon_device *rdev)
         }
 }
 
-void rs600_bm_disable(struct radeon_device *rdev)
-{
-        u16 tmp;
-
-        /* disable bus mastering */
-        pci_read_config_word(rdev->pdev, 0x4, &tmp);
-        pci_write_config_word(rdev->pdev, 0x4, tmp & 0xFFFB);
-        mdelay(1);
-}
-
 int rs600_asic_reset(struct radeon_device *rdev)
 {
         struct rv515_mc_save save;
@@ -355,7 +345,8 @@ int rs600_asic_reset(struct radeon_device *rdev)
         WREG32(RADEON_CP_RB_CNTL, tmp);
         pci_save_state(rdev->pdev);
         /* disable bus mastering */
-        rs600_bm_disable(rdev);
+        pci_clear_master(rdev->pdev);
+        mdelay(1);
         /* reset GA+VAP */
         WREG32(R_0000F0_RBBM_SOFT_RESET, S_0000F0_SOFT_RESET_VAP(1) |
                                         S_0000F0_SOFT_RESET_GA(1));
diff --git a/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c b/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c
index 37ead6995c87..0c46d8cdc6ea 100644
--- a/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c
+++ b/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c
@@ -952,10 +952,9 @@ void ttm_dma_unpopulate(struct ttm_dma_tt *ttm_dma, struct device *dev)
 
         type = ttm_to_type(ttm->page_flags, ttm->caching_state);
         pool = ttm_dma_find_pool(dev, type);
-        if (!pool) {
-                WARN_ON(!pool);
+        if (!pool)
                 return;
-        }
+
         is_cached = (ttm_dma_find_pool(pool->dev,
                      ttm_to_type(ttm->page_flags, tt_cached)) == pool);
 
diff --git a/drivers/i2c/busses/i2c-ali1535.c b/drivers/i2c/busses/i2c-ali1535.c
index b6807db7b36f..e66d248fc126 100644
--- a/drivers/i2c/busses/i2c-ali1535.c
+++ b/drivers/i2c/busses/i2c-ali1535.c
@@ -132,7 +132,8 @@
 #define ALI1535_SMBIO_EN        0x04    /* SMB I/O Space enable         */
 
 static struct pci_driver ali1535_driver;
-static unsigned short ali1535_smba;
+static unsigned long ali1535_smba;
+static unsigned short ali1535_offset;
 
 /* Detect whether a ALI1535 can be found, and initialize it, where necessary.
    Note the differences between kernels with the old PCI BIOS interface and
@@ -140,7 +141,7 @@ static unsigned short ali1535_smba;
    defined to make the transition easier. */
 static int __devinit ali1535_setup(struct pci_dev *dev)
 {
-        int retval = -ENODEV;
+        int retval;
         unsigned char temp;
 
         /* Check the following things:
@@ -149,15 +150,28 @@ static int __devinit ali1535_setup(struct pci_dev *dev)
                 - We can use the addresses
         */
 
+        retval = pci_enable_device(dev);
+        if (retval) {
+                dev_err(&dev->dev, "ALI1535_smb can't enable device\n");
+                goto exit;
+        }
+
         /* Determine the address of the SMBus area */
-        pci_read_config_word(dev, SMBBA, &ali1535_smba);
-        ali1535_smba &= (0xffff & ~(ALI1535_SMB_IOSIZE - 1));
-        if (ali1535_smba == 0) {
+        pci_read_config_word(dev, SMBBA, &ali1535_offset);
+        dev_dbg(&dev->dev, "ALI1535_smb is at offset 0x%04x\n", ali1535_offset);
+        ali1535_offset &= (0xffff & ~(ALI1535_SMB_IOSIZE - 1));
+        if (ali1535_offset == 0) {
                 dev_warn(&dev->dev,
                         "ALI1535_smb region uninitialized - upgrade BIOS?\n");
+                retval = -ENODEV;
                 goto exit;
         }
 
+        if (pci_resource_flags(dev, 0) & IORESOURCE_IO)
+                ali1535_smba = pci_resource_start(dev, 0) + ali1535_offset;
+        else
+                ali1535_smba = ali1535_offset;
+
         retval = acpi_check_region(ali1535_smba, ALI1535_SMB_IOSIZE,
                                    ali1535_driver.name);
         if (retval)
@@ -165,8 +179,9 @@ static int __devinit ali1535_setup(struct pci_dev *dev)
 
         if (!request_region(ali1535_smba, ALI1535_SMB_IOSIZE,
                             ali1535_driver.name)) {
-                dev_err(&dev->dev, "ALI1535_smb region 0x%x already in use!\n",
+                dev_err(&dev->dev, "ALI1535_smb region 0x%lx already in use!\n",
                         ali1535_smba);
+                retval = -EBUSY;
                 goto exit;
         }
 
@@ -174,6 +189,7 @@ static int __devinit ali1535_setup(struct pci_dev *dev)
         pci_read_config_byte(dev, SMBCFG, &temp);
         if ((temp & ALI1535_SMBIO_EN) == 0) {
                 dev_err(&dev->dev, "SMB device not enabled - upgrade BIOS?\n");
+                retval = -ENODEV;
                 goto exit_free;
         }
 
@@ -181,6 +197,7 @@ static int __devinit ali1535_setup(struct pci_dev *dev)
         pci_read_config_byte(dev, SMBHSTCFG, &temp);
         if ((temp & 1) == 0) {
                 dev_err(&dev->dev, "SMBus controller not enabled - upgrade BIOS?\n");
+                retval = -ENODEV;
                 goto exit_free;
         }
 
@@ -196,14 +213,13 @@ static int __devinit ali1535_setup(struct pci_dev *dev)
         */
         pci_read_config_byte(dev, SMBREV, &temp);
         dev_dbg(&dev->dev, "SMBREV = 0x%X\n", temp);
-        dev_dbg(&dev->dev, "ALI1535_smba = 0x%X\n", ali1535_smba);
+        dev_dbg(&dev->dev, "ALI1535_smba = 0x%lx\n", ali1535_smba);
 
-        retval = 0;
-exit:
-        return retval;
+        return 0;
 
 exit_free:
         release_region(ali1535_smba, ALI1535_SMB_IOSIZE);
+exit:
         return retval;
 }
 
@@ -498,7 +514,7 @@ static int __devinit ali1535_probe(struct pci_dev *dev, const struct pci_device_
         ali1535_adapter.dev.parent = &dev->dev;
 
         snprintf(ali1535_adapter.name, sizeof(ali1535_adapter.name),
-                "SMBus ALI1535 adapter at %04x", ali1535_smba);
+                "SMBus ALI1535 adapter at %04x", ali1535_offset);
         return i2c_add_adapter(&ali1535_adapter);
 }
 
diff --git a/drivers/i2c/busses/i2c-ali1563.c b/drivers/i2c/busses/i2c-ali1563.c
index a409cfcf0629..47ae0091e027 100644
--- a/drivers/i2c/busses/i2c-ali1563.c
+++ b/drivers/i2c/busses/i2c-ali1563.c
@@ -417,7 +417,7 @@ static void __devexit ali1563_remove(struct pci_dev * dev)
         ali1563_shutdown(dev);
 }
 
-static const struct pci_device_id ali1563_id_table[] __devinitconst = {
+static DEFINE_PCI_DEVICE_TABLE(ali1563_id_table) = {
         { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1563) },
         {},
 };
diff --git a/drivers/i2c/busses/i2c-ali15x3.c b/drivers/i2c/busses/i2c-ali15x3.c
index 83e8a60cdc86..087ea9caa74d 100644
--- a/drivers/i2c/busses/i2c-ali15x3.c
+++ b/drivers/i2c/busses/i2c-ali15x3.c
@@ -477,7 +477,7 @@ static struct i2c_adapter ali15x3_adapter = {
         .algo           = &smbus_algorithm,
 };
 
-static const struct pci_device_id ali15x3_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(ali15x3_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101) },
         { 0, }
 };
diff --git a/drivers/i2c/busses/i2c-amd756.c b/drivers/i2c/busses/i2c-amd756.c
index 03bcd07c4697..eb778bf15c18 100644
--- a/drivers/i2c/busses/i2c-amd756.c
+++ b/drivers/i2c/busses/i2c-amd756.c
@@ -308,7 +308,7 @@ static const char* chipname[] = {
         "nVidia nForce", "AMD8111",
 };
 
-static const struct pci_device_id amd756_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(amd756_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_VIPER_740B),
           .driver_data = AMD756 },
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_VIPER_7413),
diff --git a/drivers/i2c/busses/i2c-amd8111.c b/drivers/i2c/busses/i2c-amd8111.c
index 6b6a6b1d7025..e5ac53b99b04 100644
--- a/drivers/i2c/busses/i2c-amd8111.c
+++ b/drivers/i2c/busses/i2c-amd8111.c
@@ -415,7 +415,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 };
 
 
-static const struct pci_device_id amd8111_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(amd8111_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_SMBUS2) },
         { 0, }
 };
diff --git a/drivers/i2c/busses/i2c-at91.c b/drivers/i2c/busses/i2c-at91.c
index 305c07504f7e..1679deef9c89 100644
--- a/drivers/i2c/busses/i2c-at91.c
+++ b/drivers/i2c/busses/i2c-at91.c
@@ -295,9 +295,6 @@ static int at91_i2c_resume(struct platform_device *pdev)
 #define at91_i2c_resume         NULL
 #endif
 
-/* work with "modprobe at91_i2c" from hotplugging or coldplugging */
-MODULE_ALIAS("platform:at91_i2c");
-
 static struct platform_driver at91_i2c_driver = {
         .probe          = at91_i2c_probe,
         .remove         = __devexit_p(at91_i2c_remove),
@@ -309,19 +306,9 @@ static struct platform_driver at91_i2c_driver = {
         },
 };
 
-static int __init at91_i2c_init(void)
-{
-        return platform_driver_register(&at91_i2c_driver);
-}
-
-static void __exit at91_i2c_exit(void)
-{
-        platform_driver_unregister(&at91_i2c_driver);
-}
-
-module_init(at91_i2c_init);
-module_exit(at91_i2c_exit);
+module_platform_driver(at91_i2c_driver);
 
 MODULE_AUTHOR("Rick Bronson");
 MODULE_DESCRIPTION("I2C (TWI) driver for Atmel AT91");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:at91_i2c");
diff --git a/drivers/i2c/busses/i2c-au1550.c b/drivers/i2c/busses/i2c-au1550.c
index f314d7f433d3..582d616db346 100644
--- a/drivers/i2c/busses/i2c-au1550.c
+++ b/drivers/i2c/busses/i2c-au1550.c
@@ -426,20 +426,9 @@ static struct platform_driver au1xpsc_smbus_driver = {
         .remove         = __devexit_p(i2c_au1550_remove),
 };
 
-static int __init i2c_au1550_init(void)
-{
-        return platform_driver_register(&au1xpsc_smbus_driver);
-}
-
-static void __exit i2c_au1550_exit(void)
-{
-        platform_driver_unregister(&au1xpsc_smbus_driver);
-}
+module_platform_driver(au1xpsc_smbus_driver);
 
 MODULE_AUTHOR("Dan Malek, Embedded Edge, LLC.");
 MODULE_DESCRIPTION("SMBus adapter Alchemy pb1550");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:au1xpsc_smbus");
-
-module_init (i2c_au1550_init);
-module_exit (i2c_au1550_exit);
diff --git a/drivers/i2c/busses/i2c-cpm.c b/drivers/i2c/busses/i2c-cpm.c
index b1d9cd28d8da..c1e1096ba069 100644
--- a/drivers/i2c/busses/i2c-cpm.c
+++ b/drivers/i2c/busses/i2c-cpm.c
@@ -724,18 +724,7 @@ static struct platform_driver cpm_i2c_driver = {
         },
 };
 
-static int __init cpm_i2c_init(void)
-{
-        return platform_driver_register(&cpm_i2c_driver);
-}
-
-static void __exit cpm_i2c_exit(void)
-{
-        platform_driver_unregister(&cpm_i2c_driver);
-}
-
-module_init(cpm_i2c_init);
-module_exit(cpm_i2c_exit);
+module_platform_driver(cpm_i2c_driver);
 
 MODULE_AUTHOR("Jochen Friedrich <jochen@scram.de>");
 MODULE_DESCRIPTION("I2C-Bus adapter routines for CPM boards");
diff --git a/drivers/i2c/busses/i2c-designware-pcidrv.c b/drivers/i2c/busses/i2c-designware-pcidrv.c
index 9e89e7313d62..37f42113af31 100644
--- a/drivers/i2c/busses/i2c-designware-pcidrv.c
+++ b/drivers/i2c/busses/i2c-designware-pcidrv.c
@@ -349,7 +349,7 @@ static void __devexit i2c_dw_pci_remove(struct pci_dev *pdev)
 /* work with hotplug and coldplug */
 MODULE_ALIAS("i2c_designware-pci");
 
-DEFINE_PCI_DEVICE_TABLE(i2_designware_pci_ids) = {
+static DEFINE_PCI_DEVICE_TABLE(i2_designware_pci_ids) = {
         /* Moorestown */
         { PCI_VDEVICE(INTEL, 0x0802), moorestown_0 },
         { PCI_VDEVICE(INTEL, 0x0803), moorestown_1 },
diff --git a/drivers/i2c/busses/i2c-eg20t.c b/drivers/i2c/busses/i2c-eg20t.c
index 18936ac9d51c..3ef3557b6e32 100644
--- a/drivers/i2c/busses/i2c-eg20t.c
+++ b/drivers/i2c/busses/i2c-eg20t.c
@@ -185,7 +185,7 @@ static DEFINE_MUTEX(pch_mutex);
 #define PCI_DEVICE_ID_ML7213_I2C        0x802D
 #define PCI_DEVICE_ID_ML7223_I2C        0x8010
 
-static struct pci_device_id __devinitdata pch_pcidev_id[] = {
+static DEFINE_PCI_DEVICE_TABLE(pch_pcidev_id) = {
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_PCH_I2C),   1, },
         { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7213_I2C), 2, },
         { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7223_I2C), 1, },
diff --git a/drivers/i2c/busses/i2c-highlander.c b/drivers/i2c/busses/i2c-highlander.c
index fa88868cb556..19515df61021 100644
--- a/drivers/i2c/busses/i2c-highlander.c
+++ b/drivers/i2c/busses/i2c-highlander.c
@@ -468,18 +468,7 @@ static struct platform_driver highlander_i2c_driver = {
         .remove         = __devexit_p(highlander_i2c_remove),
 };
 
-static int __init highlander_i2c_init(void)
-{
-        return platform_driver_register(&highlander_i2c_driver);
-}
-
-static void __exit highlander_i2c_exit(void)
-{
-        platform_driver_unregister(&highlander_i2c_driver);
-}
-
-module_init(highlander_i2c_init);
-module_exit(highlander_i2c_exit);
+module_platform_driver(highlander_i2c_driver);
 
 MODULE_AUTHOR("Paul Mundt");
 MODULE_DESCRIPTION("Renesas Highlander FPGA I2C/SMBus adapter");
diff --git a/drivers/i2c/busses/i2c-hydra.c b/drivers/i2c/busses/i2c-hydra.c
index 9ff1695d8458..c527de17db4f 100644
--- a/drivers/i2c/busses/i2c-hydra.c
+++ b/drivers/i2c/busses/i2c-hydra.c
@@ -105,7 +105,7 @@ static struct i2c_adapter hydra_adap = {
         .algo_data      = &hydra_bit_data,
 };
 
-static const struct pci_device_id hydra_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(hydra_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_HYDRA) },
         { 0, }
 };
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
index ab26840d0c70..5d2e2816831f 100644
--- a/drivers/i2c/busses/i2c-i801.c
+++ b/drivers/i2c/busses/i2c-i801.c
@@ -609,7 +609,7 @@ static const struct i2c_algorithm smbus_algorithm = {
         .functionality  = i801_func,
 };
 
-static const struct pci_device_id i801_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(i801_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_3) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_3) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_2) },
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index c08ceb957aa7..806e225f3de7 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -815,15 +815,4 @@ static struct platform_driver ibm_iic_driver = {
         .remove = __devexit_p(iic_remove),
 };
 
-static int __init iic_init(void)
-{
-        return platform_driver_register(&ibm_iic_driver);
-}
-
-static void __exit iic_exit(void)
-{
-        platform_driver_unregister(&ibm_iic_driver);
-}
-
-module_init(iic_init);
-module_exit(iic_exit);
+module_platform_driver(ibm_iic_driver);
diff --git a/drivers/i2c/busses/i2c-intel-mid.c b/drivers/i2c/busses/i2c-intel-mid.c
index e828ac85cfa7..365bad5b890b 100644
--- a/drivers/i2c/busses/i2c-intel-mid.c
+++ b/drivers/i2c/busses/i2c-intel-mid.c
@@ -1093,7 +1093,7 @@ static void __devexit intel_mid_i2c_remove(struct pci_dev *dev)
         pci_release_region(dev, 0);
 }
 
-static struct pci_device_id intel_mid_i2c_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(intel_mid_i2c_ids) = {
         /* Moorestown */
         { PCI_VDEVICE(INTEL, 0x0802), 0 },
         { PCI_VDEVICE(INTEL, 0x0803), 1 },
diff --git a/drivers/i2c/busses/i2c-iop3xx.c b/drivers/i2c/busses/i2c-iop3xx.c
index f09c9319a2ba..93f147a96b62 100644
--- a/drivers/i2c/busses/i2c-iop3xx.c
+++ b/drivers/i2c/busses/i2c-iop3xx.c
@@ -523,21 +523,7 @@ static struct platform_driver iop3xx_i2c_driver = {
         },
 };
 
-static int __init 
-i2c_iop3xx_init (void)
-{
-        return platform_driver_register(&iop3xx_i2c_driver);
-}
-
-static void __exit 
-i2c_iop3xx_exit (void)
-{
-        platform_driver_unregister(&iop3xx_i2c_driver);
-        return;
-}
-
-module_init (i2c_iop3xx_init);
-module_exit (i2c_iop3xx_exit);
+module_platform_driver(iop3xx_i2c_driver);
 
 MODULE_AUTHOR("D-TACQ Solutions Ltd <www.d-tacq.com>");
 MODULE_DESCRIPTION("IOP3xx iic algorithm and driver");
diff --git a/drivers/i2c/busses/i2c-isch.c b/drivers/i2c/busses/i2c-isch.c
index 0682f8f277b0..6561d275b8cf 100644
--- a/drivers/i2c/busses/i2c-isch.c
+++ b/drivers/i2c/busses/i2c-isch.c
@@ -306,20 +306,9 @@ static struct platform_driver smbus_sch_driver = {
         .remove         = __devexit_p(smbus_sch_remove),
 };
 
-static int __init i2c_sch_init(void)
-{
-        return platform_driver_register(&smbus_sch_driver);
-}
-
-static void __exit i2c_sch_exit(void)
-{
-        platform_driver_unregister(&smbus_sch_driver);
-}
+module_platform_driver(smbus_sch_driver);
 
 MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@intel.com>");
 MODULE_DESCRIPTION("Intel SCH SMBus driver");
 MODULE_LICENSE("GPL");
-
-module_init(i2c_sch_init);
-module_exit(i2c_sch_exit);
 MODULE_ALIAS("platform:isch_smbus");
diff --git a/drivers/i2c/busses/i2c-ixp2000.c b/drivers/i2c/busses/i2c-ixp2000.c
index c01e9519f6c1..5d263f9014d6 100644
--- a/drivers/i2c/busses/i2c-ixp2000.c
+++ b/drivers/i2c/busses/i2c-ixp2000.c
@@ -148,18 +148,7 @@ static struct platform_driver ixp2000_i2c_driver = {
         },
 };
 
-static int __init ixp2000_i2c_init(void)
-{
-        return platform_driver_register(&ixp2000_i2c_driver);
-}
-
-static void __exit ixp2000_i2c_exit(void)
-{
-        platform_driver_unregister(&ixp2000_i2c_driver);
-}
-
-module_init(ixp2000_i2c_init);
-module_exit(ixp2000_i2c_exit);
+module_platform_driver(ixp2000_i2c_driver);
 
 MODULE_AUTHOR ("Deepak Saxena <dsaxena@plexity.net>");
 MODULE_DESCRIPTION("IXP2000 GPIO-based I2C bus driver");
diff --git a/drivers/i2c/busses/i2c-mpc.c b/drivers/i2c/busses/i2c-mpc.c
index 107397a606b4..a8ebb84e23f9 100644
--- a/drivers/i2c/busses/i2c-mpc.c
+++ b/drivers/i2c/busses/i2c-mpc.c
@@ -715,18 +715,7 @@ static struct platform_driver mpc_i2c_driver = {
         },
 };
 
-static int __init fsl_i2c_init(void)
-{
-        return platform_driver_register(&mpc_i2c_driver);
-}
-
-static void __exit fsl_i2c_exit(void)
-{
-        platform_driver_unregister(&mpc_i2c_driver);
-}
-
-module_init(fsl_i2c_init);
-module_exit(fsl_i2c_exit);
+module_platform_driver(mpc_i2c_driver);
 
 MODULE_AUTHOR("Adrian Cox <adrian@humboldt.co.uk>");
 MODULE_DESCRIPTION("I2C-Bus adapter for MPC107 bridge and "
diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index a9941c65f226..4f44a33017b0 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -611,20 +611,7 @@ static struct platform_driver mv64xxx_i2c_driver = {
         },
 };
 
-static int __init
-mv64xxx_i2c_init(void)
-{
-        return platform_driver_register(&mv64xxx_i2c_driver);
-}
-
-static void __exit
-mv64xxx_i2c_exit(void)
-{
-        platform_driver_unregister(&mv64xxx_i2c_driver);
-}
-
-module_init(mv64xxx_i2c_init);
-module_exit(mv64xxx_i2c_exit);
+module_platform_driver(mv64xxx_i2c_driver);
 
 MODULE_AUTHOR("Mark A. Greer <mgreer@mvista.com>");
 MODULE_DESCRIPTION("Marvell mv64xxx host bridge i2c ctlr driver");
diff --git a/drivers/i2c/busses/i2c-nforce2.c b/drivers/i2c/busses/i2c-nforce2.c
index ff1e127dfea8..43a96a123920 100644
--- a/drivers/i2c/busses/i2c-nforce2.c
+++ b/drivers/i2c/busses/i2c-nforce2.c
@@ -309,7 +309,7 @@ static struct i2c_algorithm smbus_algorithm = {
 };
 
 
-static const struct pci_device_id nforce2_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(nforce2_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2_SMBUS) },
         { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_SMBUS) },
         { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3_SMBUS) },
@@ -356,7 +356,7 @@ static int __devinit nforce2_probe_smb (struct pci_dev *dev, int bar,
         error = acpi_check_region(smbus->base, smbus->size,
                                   nforce2_driver.name);
         if (error)
-                return -1;
+                return error;
 
         if (!request_region(smbus->base, smbus->size, nforce2_driver.name)) {
                 dev_err(&smbus->adapter.dev, "Error requesting region %02x .. %02X for %s\n",
diff --git a/drivers/i2c/busses/i2c-ocores.c b/drivers/i2c/busses/i2c-ocores.c
index 1b46a9d9f907..18068dee48f1 100644
--- a/drivers/i2c/busses/i2c-ocores.c
+++ b/drivers/i2c/busses/i2c-ocores.c
@@ -394,9 +394,6 @@ static struct of_device_id ocores_i2c_match[] = {
 };
 MODULE_DEVICE_TABLE(of, ocores_i2c_match);
 
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:ocores-i2c");
-
 static struct platform_driver ocores_i2c_driver = {
         .probe   = ocores_i2c_probe,
         .remove  = __devexit_p(ocores_i2c_remove),
@@ -409,19 +406,9 @@ static struct platform_driver ocores_i2c_driver = {
         },
 };
 
-static int __init ocores_i2c_init(void)
-{
-        return platform_driver_register(&ocores_i2c_driver);
-}
-
-static void __exit ocores_i2c_exit(void)
-{
-        platform_driver_unregister(&ocores_i2c_driver);
-}
-
-module_init(ocores_i2c_init);
-module_exit(ocores_i2c_exit);
+module_platform_driver(ocores_i2c_driver);
 
 MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>");
 MODULE_DESCRIPTION("OpenCores I2C bus driver");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ocores-i2c");
diff --git a/drivers/i2c/busses/i2c-octeon.c b/drivers/i2c/busses/i2c-octeon.c
index 56dbe54e8811..ee139a598814 100644
--- a/drivers/i2c/busses/i2c-octeon.c
+++ b/drivers/i2c/busses/i2c-octeon.c
@@ -629,24 +629,10 @@ static struct platform_driver octeon_i2c_driver = {
         },
 };
 
-static int __init octeon_i2c_init(void)
-{
-        int rv;
-
-        rv = platform_driver_register(&octeon_i2c_driver);
-        return rv;
-}
-
-static void __exit octeon_i2c_exit(void)
-{
-        platform_driver_unregister(&octeon_i2c_driver);
-}
+module_platform_driver(octeon_i2c_driver);
 
 MODULE_AUTHOR("Michael Lawnick <michael.lawnick.ext@nsn.com>");
 MODULE_DESCRIPTION("I2C-Bus adapter for Cavium OCTEON processors");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 MODULE_ALIAS("platform:" DRV_NAME);
-
-module_init(octeon_i2c_init);
-module_exit(octeon_i2c_exit);
diff --git a/drivers/i2c/busses/i2c-pasemi.c b/drivers/i2c/busses/i2c-pasemi.c
index 837b8c1aa02a..eaaea73209c5 100644
--- a/drivers/i2c/busses/i2c-pasemi.c
+++ b/drivers/i2c/busses/i2c-pasemi.c
@@ -401,7 +401,7 @@ static void __devexit pasemi_smb_remove(struct pci_dev *dev)
         kfree(smbus);
 }
 
-static const struct pci_device_id pasemi_smb_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(pasemi_smb_ids) = {
         { PCI_DEVICE(0x1959, 0xa003) },
         { 0, }
 };
diff --git a/drivers/i2c/busses/i2c-pca-platform.c b/drivers/i2c/busses/i2c-pca-platform.c
index ace67995d7de..2adbf1a8fdea 100644
--- a/drivers/i2c/busses/i2c-pca-platform.c
+++ b/drivers/i2c/busses/i2c-pca-platform.c
@@ -286,20 +286,8 @@ static struct platform_driver i2c_pca_pf_driver = {
         },
 };
 
-static int __init i2c_pca_pf_init(void)
-{
-        return platform_driver_register(&i2c_pca_pf_driver);
-}
-
-static void __exit i2c_pca_pf_exit(void)
-{
-        platform_driver_unregister(&i2c_pca_pf_driver);
-}
+module_platform_driver(i2c_pca_pf_driver);
 
 MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
 MODULE_DESCRIPTION("I2C-PCA9564/PCA9665 platform driver");
 MODULE_LICENSE("GPL");
-
-module_init(i2c_pca_pf_init);
-module_exit(i2c_pca_pf_exit);
-
diff --git a/drivers/i2c/busses/i2c-piix4.c b/drivers/i2c/busses/i2c-piix4.c
index 6d14ac2e3c41..c14d48dd601a 100644
--- a/drivers/i2c/busses/i2c-piix4.c
+++ b/drivers/i2c/busses/i2c-piix4.c
@@ -472,7 +472,7 @@ static struct i2c_adapter piix4_adapter = {
         .algo           = &smbus_algorithm,
 };
 
-static const struct pci_device_id piix4_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(piix4_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443MX_3) },
         { PCI_DEVICE(PCI_VENDOR_ID_EFAR, PCI_DEVICE_ID_EFAR_SLC90E66_3) },
diff --git a/drivers/i2c/busses/i2c-pmcmsp.c b/drivers/i2c/busses/i2c-pmcmsp.c
index 127051b06921..07b7447ecbc9 100644
--- a/drivers/i2c/busses/i2c-pmcmsp.c
+++ b/drivers/i2c/busses/i2c-pmcmsp.c
@@ -627,9 +627,6 @@ static struct i2c_adapter pmcmsptwi_adapter = {
         .name           = DRV_NAME,
 };
 
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:" DRV_NAME);
-
 static struct platform_driver pmcmsptwi_driver = {
         .probe  = pmcmsptwi_probe,
         .remove = __devexit_p(pmcmsptwi_remove),
@@ -639,18 +636,8 @@ static struct platform_driver pmcmsptwi_driver = {
         },
 };
 
-static int __init pmcmsptwi_init(void)
-{
-        return platform_driver_register(&pmcmsptwi_driver);
-}
-
-static void __exit pmcmsptwi_exit(void)
-{
-        platform_driver_unregister(&pmcmsptwi_driver);
-}
+module_platform_driver(pmcmsptwi_driver);
 
 MODULE_DESCRIPTION("PMC MSP TWI/SMBus/I2C driver");
 MODULE_LICENSE("GPL");
-
-module_init(pmcmsptwi_init);
-module_exit(pmcmsptwi_exit);
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/i2c/busses/i2c-powermac.c b/drivers/i2c/busses/i2c-powermac.c
index b289ec99eeba..7b397c6f607e 100644
--- a/drivers/i2c/busses/i2c-powermac.c
+++ b/drivers/i2c/busses/i2c-powermac.c
@@ -312,10 +312,6 @@ static int __devinit i2c_powermac_probe(struct platform_device *dev)
         return rc;
 }
 
-
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:i2c-powermac");
-
 static struct platform_driver i2c_powermac_driver = {
         .probe = i2c_powermac_probe,
         .remove = __devexit_p(i2c_powermac_remove),
@@ -325,17 +321,6 @@ static struct platform_driver i2c_powermac_driver = {
         },
 };
 
-static int __init i2c_powermac_init(void)
-{
-        platform_driver_register(&i2c_powermac_driver);
-        return 0;
-}
+module_platform_driver(i2c_powermac_driver);
 
-
-static void __exit i2c_powermac_cleanup(void)
-{
-        platform_driver_unregister(&i2c_powermac_driver);
-}
-
-module_init(i2c_powermac_init);
-module_exit(i2c_powermac_cleanup);
+MODULE_ALIAS("platform:i2c-powermac");
diff --git a/drivers/i2c/busses/i2c-pxa-pci.c b/drivers/i2c/busses/i2c-pxa-pci.c
index 632e088760a3..a05817980556 100644
--- a/drivers/i2c/busses/i2c-pxa-pci.c
+++ b/drivers/i2c/busses/i2c-pxa-pci.c
@@ -150,7 +150,7 @@ static void __devexit ce4100_i2c_remove(struct pci_dev *dev)
         kfree(sds);
 }
 
-static struct pci_device_id ce4100_i2c_devices[] __devinitdata = {
+static DEFINE_PCI_DEVICE_TABLE(ce4100_i2c_devices) = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2e68)},
         { },
 };
diff --git a/drivers/i2c/busses/i2c-sh7760.c b/drivers/i2c/busses/i2c-sh7760.c
index a67132b2e092..c0c9dffbdb12 100644
--- a/drivers/i2c/busses/i2c-sh7760.c
+++ b/drivers/i2c/busses/i2c-sh7760.c
@@ -560,18 +560,7 @@ static struct platform_driver sh7760_i2c_drv = {
         .remove         = __devexit_p(sh7760_i2c_remove),
 };
 
-static int __init sh7760_i2c_init(void)
-{
-        return platform_driver_register(&sh7760_i2c_drv);
-}
-
-static void __exit sh7760_i2c_exit(void)
-{
-        platform_driver_unregister(&sh7760_i2c_drv);
-}
-
-module_init(sh7760_i2c_init);
-module_exit(sh7760_i2c_exit);
+module_platform_driver(sh7760_i2c_drv);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("SH7760 I2C bus driver");
diff --git a/drivers/i2c/busses/i2c-simtec.c b/drivers/i2c/busses/i2c-simtec.c
index 2fc08fbf67a2..4fc87e7c94c9 100644
--- a/drivers/i2c/busses/i2c-simtec.c
+++ b/drivers/i2c/busses/i2c-simtec.c
@@ -156,12 +156,8 @@ static int simtec_i2c_remove(struct platform_device *dev)
         return 0;
 }
 
-
 /* device driver */
 
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:simtec-i2c");
-
 static struct platform_driver simtec_i2c_driver = {
         .driver         = {
                 .name           = "simtec-i2c",
@@ -171,19 +167,9 @@ static struct platform_driver simtec_i2c_driver = {
         .remove         = simtec_i2c_remove,
 };
 
-static int __init i2c_adap_simtec_init(void)
-{
-        return platform_driver_register(&simtec_i2c_driver);
-}
-
-static void __exit i2c_adap_simtec_exit(void)
-{
-        platform_driver_unregister(&simtec_i2c_driver);
-}
-
-module_init(i2c_adap_simtec_init);
-module_exit(i2c_adap_simtec_exit);
+module_platform_driver(simtec_i2c_driver);
 
 MODULE_DESCRIPTION("Simtec Generic I2C Bus driver");
 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:simtec-i2c");
diff --git a/drivers/i2c/busses/i2c-sis5595.c b/drivers/i2c/busses/i2c-sis5595.c
index 437586611d4a..87e5126d449c 100644
--- a/drivers/i2c/busses/i2c-sis5595.c
+++ b/drivers/i2c/busses/i2c-sis5595.c
@@ -147,7 +147,7 @@ static int __devinit sis5595_setup(struct pci_dev *SIS5595_dev)
         u16 a;
         u8 val;
         int *i;
-        int retval = -ENODEV;
+        int retval;
 
         /* Look for imposters */
         for (i = blacklist; *i != 0; i++) {
@@ -223,7 +223,7 @@ static int __devinit sis5595_setup(struct pci_dev *SIS5595_dev)
 
 error:
         release_region(sis5595_base + SMB_INDEX, 2);
-        return retval;
+        return -ENODEV;
 }
 
 static int sis5595_transaction(struct i2c_adapter *adap)
@@ -369,7 +369,7 @@ static struct i2c_adapter sis5595_adapter = {
         .algo           = &smbus_algorithm,
 };
 
-static const struct pci_device_id sis5595_ids[] __devinitconst = {
+static DEFINE_PCI_DEVICE_TABLE(sis5595_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) }, 
         { 0, }
 };
diff --git a/drivers/i2c/busses/i2c-sis630.c b/drivers/i2c/busses/i2c-sis630.c
index 58893772c3d8..15cf78f65ce0 100644
--- a/drivers/i2c/busses/i2c-sis630.c
+++ b/drivers/i2c/busses/i2c-sis630.c
@@ -393,7 +393,7 @@ static int __devinit sis630_setup(struct pci_dev *sis630_dev)
 {
         unsigned char b;
         struct pci_dev *dummy = NULL;
-        int retval = -ENODEV, i;
+        int retval, i;
 
         /* check for supported SiS devices */
         for (i=0; supported[i] > 0 ; i++) {
@@ -418,18 +418,21 @@ static int __devinit sis630_setup(struct pci_dev *sis630_dev)
         */
         if (pci_read_config_byte(sis630_dev, SIS630_BIOS_CTL_REG,&b)) {
                 dev_err(&sis630_dev->dev, "Error: Can't read bios ctl reg\n");
+                retval = -ENODEV;
                 goto exit;
         }
         /* if ACPI already enabled , do nothing */
         if (!(b & 0x80) &&
             pci_write_config_byte(sis630_dev, SIS630_BIOS_CTL_REG, b | 0x80)) {
                 dev_err(&sis630_dev->dev, "Error: Can't enable ACPI\n");
+                retval = -ENODEV;
                 goto exit;
         }
 
         /* Determine the ACPI base address */
         if (pci_read_config_word(sis630_dev,SIS630_ACPI_BASE_REG,&acpi_base)) {
                 dev_err(&sis630_dev->dev, "Error: Can't determine ACPI base address\n");
+                retval = -ENODEV;
                 goto exit;
         }
 
@@ -445,6 +448,7 @@ static int __devinit sis630_setup(struct pci_dev *sis630_dev)
                             sis630_driver.name)) {
                 dev_err(&sis630_dev->dev, "SMBus registers 0x%04x-0x%04x already "
                         "in use!\n", acpi_base + SMB_STS, acpi_base + SMB_SAA);
+                retval = -EBUSY;
                 goto exit;
         }
 
@@ -468,7 +472,7 @@ static struct i2c_adapter sis630_adapter = {
         .algo           = &smbus_algorithm,
 };
 
-static const struct pci_device_id sis630_ids[] __devinitconst = {
+static DEFINE_PCI_DEVICE_TABLE(sis630_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_LPC) },
         { 0, }
diff --git a/drivers/i2c/busses/i2c-sis96x.c b/drivers/i2c/busses/i2c-sis96x.c
index 86837f0c4cb9..cc5d149413f7 100644
--- a/drivers/i2c/busses/i2c-sis96x.c
+++ b/drivers/i2c/busses/i2c-sis96x.c
@@ -245,7 +245,7 @@ static struct i2c_adapter sis96x_adapter = {
         .algo           = &smbus_algorithm,
 };
 
-static const struct pci_device_id sis96x_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(sis96x_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_SMBUS) },
         { 0, }
 };
diff --git a/drivers/i2c/busses/i2c-via.c b/drivers/i2c/busses/i2c-via.c
index 7799fe5bda88..713d31ade26b 100644
--- a/drivers/i2c/busses/i2c-via.c
+++ b/drivers/i2c/busses/i2c-via.c
@@ -89,7 +89,7 @@ static struct i2c_adapter vt586b_adapter = {
 };
 
 
-static const struct pci_device_id vt586b_ids[] __devinitconst = {
+static DEFINE_PCI_DEVICE_TABLE(vt586b_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_3) },
         { 0, }
 };
diff --git a/drivers/i2c/busses/i2c-viapro.c b/drivers/i2c/busses/i2c-viapro.c
index 2a62c998044a..333011c83d52 100644
--- a/drivers/i2c/busses/i2c-viapro.c
+++ b/drivers/i2c/busses/i2c-viapro.c
@@ -324,7 +324,7 @@ static int __devinit vt596_probe(struct pci_dev *pdev,
                                  const struct pci_device_id *id)
 {
         unsigned char temp;
-        int error = -ENODEV;
+        int error;
 
         /* Determine the address of the SMBus areas */
         if (force_addr) {
@@ -390,6 +390,7 @@ found:
                         dev_err(&pdev->dev, "SMBUS: Error: Host SMBus "
                                 "controller not enabled! - upgrade BIOS or "
                                 "use force=1\n");
+                        error = -ENODEV;
                         goto release_region;
                 }
         }
@@ -422,9 +423,11 @@ found:
                  "SMBus Via Pro adapter at %04x", vt596_smba);
 
         vt596_pdev = pci_dev_get(pdev);
-        if (i2c_add_adapter(&vt596_adapter)) {
+        error = i2c_add_adapter(&vt596_adapter);
+        if (error) {
                 pci_dev_put(vt596_pdev);
                 vt596_pdev = NULL;
+                goto release_region;
         }
 
         /* Always return failure here.  This is to allow other drivers to bind
@@ -438,7 +441,7 @@ release_region:
         return error;
 }
 
-static const struct pci_device_id vt596_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(vt596_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596_3),
           .driver_data = SMBBA1 },
         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596B_3),
diff --git a/drivers/i2c/busses/i2c-xiic.c b/drivers/i2c/busses/i2c-xiic.c
index ac083a28ae08..2bded7647ef2 100644
--- a/drivers/i2c/busses/i2c-xiic.c
+++ b/drivers/i2c/busses/i2c-xiic.c
@@ -795,10 +795,6 @@ static int __devexit xiic_i2c_remove(struct platform_device* pdev)
         return 0;
 }
 
-
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:"DRIVER_NAME);
-
 static struct platform_driver xiic_i2c_driver = {
         .probe   = xiic_i2c_probe,
         .remove  = __devexit_p(xiic_i2c_remove),
@@ -808,19 +804,9 @@ static struct platform_driver xiic_i2c_driver = {
         },
 };
 
-static int __init xiic_i2c_init(void)
-{
-        return platform_driver_register(&xiic_i2c_driver);
-}
-
-static void __exit xiic_i2c_exit(void)
-{
-        platform_driver_unregister(&xiic_i2c_driver);
-}
-
-module_init(xiic_i2c_init);
-module_exit(xiic_i2c_exit);
+module_platform_driver(xiic_i2c_driver);
 
 MODULE_AUTHOR("info@mocean-labs.com");
 MODULE_DESCRIPTION("Xilinx I2C bus driver");
 MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:"DRIVER_NAME);
diff --git a/drivers/i2c/busses/scx200_acb.c b/drivers/i2c/busses/scx200_acb.c
index 91e349c884c5..2eacb7784d56 100644
--- a/drivers/i2c/busses/scx200_acb.c
+++ b/drivers/i2c/busses/scx200_acb.c
@@ -559,7 +559,7 @@ static struct platform_driver scx200_pci_driver = {
         .remove = __devexit_p(scx200_remove),
 };
 
-static const struct pci_device_id scx200_isa[] __initconst = {
+static DEFINE_PCI_DEVICE_TABLE(scx200_isa) = {
         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },
         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },
         { 0, }
diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c
index 57a45ce84b2d..10e7f1e76586 100644
--- a/drivers/i2c/i2c-dev.c
+++ b/drivers/i2c/i2c-dev.c
@@ -251,15 +251,10 @@ static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
         if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
                 return -EINVAL;
 
-        rdwr_pa = kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), GFP_KERNEL);
-        if (!rdwr_pa)
-                return -ENOMEM;
-
-        if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
-                           rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
-                kfree(rdwr_pa);
-                return -EFAULT;
-        }
+        rdwr_pa = memdup_user(rdwr_arg.msgs,
+                              rdwr_arg.nmsgs * sizeof(struct i2c_msg));
+        if (IS_ERR(rdwr_pa))
+                return PTR_ERR(rdwr_pa);
 
         data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
         if (data_ptrs == NULL) {
diff --git a/drivers/i2c/muxes/gpio-i2cmux.c b/drivers/i2c/muxes/gpio-i2cmux.c
index 7b6ce624cd6e..e5fa695eb0fa 100644
--- a/drivers/i2c/muxes/gpio-i2cmux.c
+++ b/drivers/i2c/muxes/gpio-i2cmux.c
@@ -165,18 +165,7 @@ static struct platform_driver gpiomux_driver = {
         },
 };
 
-static int __init gpiomux_init(void)
-{
-        return platform_driver_register(&gpiomux_driver);
-}
-
-static void __exit gpiomux_exit(void)
-{
-        platform_driver_unregister(&gpiomux_driver);
-}
-
-module_init(gpiomux_init);
-module_exit(gpiomux_exit);
+module_platform_driver(gpiomux_driver);
 
 MODULE_DESCRIPTION("GPIO-based I2C multiplexer driver");
 MODULE_AUTHOR("Peter Korsgaard <peter.korsgaard@barco.com>");
diff --git a/drivers/input/misc/ab8500-ponkey.c b/drivers/input/misc/ab8500-ponkey.c
index 79d901633635..350fd0c385d2 100644
--- a/drivers/input/misc/ab8500-ponkey.c
+++ b/drivers/input/misc/ab8500-ponkey.c
@@ -12,7 +12,7 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
-#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500/ab8500.h>
 #include <linux/slab.h>
 
 /**
diff --git a/drivers/isdn/i4l/Kconfig b/drivers/isdn/i4l/Kconfig
index 9c6650ea848e..2302fbe70ac6 100644
--- a/drivers/isdn/i4l/Kconfig
+++ b/drivers/isdn/i4l/Kconfig
@@ -6,7 +6,7 @@ if ISDN_I4L
 
 config ISDN_PPP
         bool "Support synchronous PPP"
-        depends on INET
+        depends on INET && NETDEVICES
         select SLHC
         help
           Over digital connections such as ISDN, there is no need to
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index 897a77dfa9d7..c957c344233f 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -396,6 +396,13 @@ config LEDS_TCA6507
           LED driver chips accessed via the I2C bus.
           Driver support brightness control and hardware-assisted blinking.
 
+config LEDS_MAX8997
+        tristate "LED support for MAX8997 PMIC"
+        depends on LEDS_CLASS && MFD_MAX8997
+        help
+          This option enables support for on-chip LED drivers on
+          MAXIM MAX8997 PMIC.
+
 config LEDS_TRIGGERS
         bool "LED Trigger support"
         depends on LEDS_CLASS
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index 5c9dc4b000d5..b8a9723477f0 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -44,6 +44,7 @@ obj-$(CONFIG_LEDS_NS2)			+= leds-ns2.o
 obj-$(CONFIG_LEDS_NETXBIG)              += leds-netxbig.o
 obj-$(CONFIG_LEDS_ASIC3)                += leds-asic3.o
 obj-$(CONFIG_LEDS_RENESAS_TPU)          += leds-renesas-tpu.o
+obj-$(CONFIG_LEDS_MAX8997)              += leds-max8997.o
 
 # LED SPI Drivers
 obj-$(CONFIG_LEDS_DAC124S085)           += leds-dac124s085.o
diff --git a/drivers/leds/leds-max8997.c b/drivers/leds/leds-max8997.c
new file mode 100644
index 000000000000..f4c0e37fad1e
--- /dev/null
+++ b/drivers/leds/leds-max8997.c
@@ -0,0 +1,372 @@
+/*
+ * leds-max8997.c - LED class driver for MAX8997 LEDs.
+ *
+ * Copyright (C) 2011 Samsung Electronics
+ * Donggeun Kim <dg77.kim@samsung.com>
+ *
+ * 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/module.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <linux/leds.h>
+#include <linux/mfd/max8997.h>
+#include <linux/mfd/max8997-private.h>
+#include <linux/platform_device.h>
+
+#define MAX8997_LED_FLASH_SHIFT                 3
+#define MAX8997_LED_FLASH_CUR_MASK              0xf8
+#define MAX8997_LED_MOVIE_SHIFT                 4
+#define MAX8997_LED_MOVIE_CUR_MASK              0xf0
+
+#define MAX8997_LED_FLASH_MAX_BRIGHTNESS        0x1f
+#define MAX8997_LED_MOVIE_MAX_BRIGHTNESS        0xf
+#define MAX8997_LED_NONE_MAX_BRIGHTNESS         0
+
+#define MAX8997_LED0_FLASH_MASK                 0x1
+#define MAX8997_LED0_FLASH_PIN_MASK             0x5
+#define MAX8997_LED0_MOVIE_MASK                 0x8
+#define MAX8997_LED0_MOVIE_PIN_MASK             0x28
+
+#define MAX8997_LED1_FLASH_MASK                 0x2
+#define MAX8997_LED1_FLASH_PIN_MASK             0x6
+#define MAX8997_LED1_MOVIE_MASK                 0x10
+#define MAX8997_LED1_MOVIE_PIN_MASK             0x30
+
+#define MAX8997_LED_BOOST_ENABLE_MASK           (1 << 6)
+
+struct max8997_led {
+        struct max8997_dev *iodev;
+        struct led_classdev cdev;
+        bool enabled;
+        int id;
+        enum max8997_led_mode led_mode;
+        struct mutex mutex;
+};
+
+static void max8997_led_clear_mode(struct max8997_led *led,
+                        enum max8997_led_mode mode)
+{
+        struct i2c_client *client = led->iodev->i2c;
+        u8 val = 0, mask = 0;
+        int ret;
+
+        switch (mode) {
+        case MAX8997_FLASH_MODE:
+                mask = led->id ?
+                      MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
+                break;
+        case MAX8997_MOVIE_MODE:
+                mask = led->id ?
+                      MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
+                break;
+        case MAX8997_FLASH_PIN_CONTROL_MODE:
+                mask = led->id ?
+                      MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
+                break;
+        case MAX8997_MOVIE_PIN_CONTROL_MODE:
+                mask = led->id ?
+                      MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
+                break;
+        default:
+                break;
+        }
+
+        if (mask) {
+                ret = max8997_update_reg(client,
+                                MAX8997_REG_LEN_CNTL, val, mask);
+                if (ret)
+                        dev_err(led->iodev->dev,
+                                "failed to update register(%d)\n", ret);
+        }
+}
+
+static void max8997_led_set_mode(struct max8997_led *led,
+                        enum max8997_led_mode mode)
+{
+        int ret;
+        struct i2c_client *client = led->iodev->i2c;
+        u8 mask = 0;
+
+        /* First, clear the previous mode */
+        max8997_led_clear_mode(led, led->led_mode);
+
+        switch (mode) {
+        case MAX8997_FLASH_MODE:
+                mask = led->id ?
+                      MAX8997_LED1_FLASH_MASK : MAX8997_LED0_FLASH_MASK;
+                led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
+                break;
+        case MAX8997_MOVIE_MODE:
+                mask = led->id ?
+                      MAX8997_LED1_MOVIE_MASK : MAX8997_LED0_MOVIE_MASK;
+                led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
+                break;
+        case MAX8997_FLASH_PIN_CONTROL_MODE:
+                mask = led->id ?
+                      MAX8997_LED1_FLASH_PIN_MASK : MAX8997_LED0_FLASH_PIN_MASK;
+                led->cdev.max_brightness = MAX8997_LED_FLASH_MAX_BRIGHTNESS;
+                break;
+        case MAX8997_MOVIE_PIN_CONTROL_MODE:
+                mask = led->id ?
+                      MAX8997_LED1_MOVIE_PIN_MASK : MAX8997_LED0_MOVIE_PIN_MASK;
+                led->cdev.max_brightness = MAX8997_LED_MOVIE_MAX_BRIGHTNESS;
+                break;
+        default:
+                led->cdev.max_brightness = MAX8997_LED_NONE_MAX_BRIGHTNESS;
+                break;
+        }
+
+        if (mask) {
+                ret = max8997_update_reg(client,
+                                MAX8997_REG_LEN_CNTL, mask, mask);
+                if (ret)
+                        dev_err(led->iodev->dev,
+                                "failed to update register(%d)\n", ret);
+        }
+
+        led->led_mode = mode;
+}
+
+static void max8997_led_enable(struct max8997_led *led, bool enable)
+{
+        int ret;
+        struct i2c_client *client = led->iodev->i2c;
+        u8 val = 0, mask = MAX8997_LED_BOOST_ENABLE_MASK;
+
+        if (led->enabled == enable)
+                return;
+
+        val = enable ? MAX8997_LED_BOOST_ENABLE_MASK : 0;
+
+        ret = max8997_update_reg(client, MAX8997_REG_BOOST_CNTL, val, mask);
+        if (ret)
+                dev_err(led->iodev->dev,
+                        "failed to update register(%d)\n", ret);
+
+        led->enabled = enable;
+}
+
+static void max8997_led_set_current(struct max8997_led *led,
+                                enum led_brightness value)
+{
+        int ret;
+        struct i2c_client *client = led->iodev->i2c;
+        u8 val = 0, mask = 0, reg = 0;
+
+        switch (led->led_mode) {
+        case MAX8997_FLASH_MODE:
+        case MAX8997_FLASH_PIN_CONTROL_MODE:
+                val = value << MAX8997_LED_FLASH_SHIFT;
+                mask = MAX8997_LED_FLASH_CUR_MASK;
+                reg = led->id ? MAX8997_REG_FLASH2_CUR : MAX8997_REG_FLASH1_CUR;
+                break;
+        case MAX8997_MOVIE_MODE:
+        case MAX8997_MOVIE_PIN_CONTROL_MODE:
+                val = value << MAX8997_LED_MOVIE_SHIFT;
+                mask = MAX8997_LED_MOVIE_CUR_MASK;
+                reg = MAX8997_REG_MOVIE_CUR;
+                break;
+        default:
+                break;
+        }
+
+        if (mask) {
+                ret = max8997_update_reg(client, reg, val, mask);
+                if (ret)
+                        dev_err(led->iodev->dev,
+                                "failed to update register(%d)\n", ret);
+        }
+}
+
+static void max8997_led_brightness_set(struct led_classdev *led_cdev,
+                                enum led_brightness value)
+{
+        struct max8997_led *led =
+                        container_of(led_cdev, struct max8997_led, cdev);
+
+        if (value) {
+                max8997_led_set_current(led, value);
+                max8997_led_enable(led, true);
+        } else {
+                max8997_led_set_current(led, value);
+                max8997_led_enable(led, false);
+        }
+}
+
+static ssize_t max8997_led_show_mode(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct led_classdev *led_cdev = dev_get_drvdata(dev);
+        struct max8997_led *led =
+                        container_of(led_cdev, struct max8997_led, cdev);
+        ssize_t ret = 0;
+
+        mutex_lock(&led->mutex);
+
+        switch (led->led_mode) {
+        case MAX8997_FLASH_MODE:
+                ret += sprintf(buf, "FLASH\n");
+                break;
+        case MAX8997_MOVIE_MODE:
+                ret += sprintf(buf, "MOVIE\n");
+                break;
+        case MAX8997_FLASH_PIN_CONTROL_MODE:
+                ret += sprintf(buf, "FLASH_PIN_CONTROL\n");
+                break;
+        case MAX8997_MOVIE_PIN_CONTROL_MODE:
+                ret += sprintf(buf, "MOVIE_PIN_CONTROL\n");
+                break;
+        default:
+                ret += sprintf(buf, "NONE\n");
+                break;
+        }
+
+        mutex_unlock(&led->mutex);
+
+        return ret;
+}
+
+static ssize_t max8997_led_store_mode(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t size)
+{
+        struct led_classdev *led_cdev = dev_get_drvdata(dev);
+        struct max8997_led *led =
+                        container_of(led_cdev, struct max8997_led, cdev);
+        enum max8997_led_mode mode;
+
+        mutex_lock(&led->mutex);
+
+        if (!strncmp(buf, "FLASH_PIN_CONTROL", 17))
+                mode = MAX8997_FLASH_PIN_CONTROL_MODE;
+        else if (!strncmp(buf, "MOVIE_PIN_CONTROL", 17))
+                mode = MAX8997_MOVIE_PIN_CONTROL_MODE;
+        else if (!strncmp(buf, "FLASH", 5))
+                mode = MAX8997_FLASH_MODE;
+        else if (!strncmp(buf, "MOVIE", 5))
+                mode = MAX8997_MOVIE_MODE;
+        else
+                mode = MAX8997_NONE;
+
+        max8997_led_set_mode(led, mode);
+
+        mutex_unlock(&led->mutex);
+
+        return size;
+}
+
+static DEVICE_ATTR(mode, 0644, max8997_led_show_mode, max8997_led_store_mode);
+
+static int __devinit max8997_led_probe(struct platform_device *pdev)
+{
+        struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct max8997_led *led;
+        char name[20];
+        int ret = 0;
+
+        if (pdata == NULL) {
+                dev_err(&pdev->dev, "no platform data\n");
+                return -ENODEV;
+        }
+
+        led = kzalloc(sizeof(*led), GFP_KERNEL);
+        if (led == NULL) {
+                ret = -ENOMEM;
+                goto err_mem;
+        }
+
+        led->id = pdev->id;
+        snprintf(name, sizeof(name), "max8997-led%d", pdev->id);
+
+        led->cdev.name = name;
+        led->cdev.brightness_set = max8997_led_brightness_set;
+        led->cdev.flags |= LED_CORE_SUSPENDRESUME;
+        led->cdev.brightness = 0;
+        led->iodev = iodev;
+
+        /* initialize mode and brightness according to platform_data */
+        if (pdata->led_pdata) {
+                u8 mode = 0, brightness = 0;
+
+                mode = pdata->led_pdata->mode[led->id];
+                brightness = pdata->led_pdata->brightness[led->id];
+
+                max8997_led_set_mode(led, pdata->led_pdata->mode[led->id]);
+
+                if (brightness > led->cdev.max_brightness)
+                        brightness = led->cdev.max_brightness;
+                max8997_led_set_current(led, brightness);
+                led->cdev.brightness = brightness;
+        } else {
+                max8997_led_set_mode(led, MAX8997_NONE);
+                max8997_led_set_current(led, 0);
+        }
+
+        mutex_init(&led->mutex);
+
+        platform_set_drvdata(pdev, led);
+
+        ret = led_classdev_register(&pdev->dev, &led->cdev);
+        if (ret < 0)
+                goto err_led;
+
+        ret = device_create_file(led->cdev.dev, &dev_attr_mode);
+        if (ret != 0) {
+                dev_err(&pdev->dev,
+                        "failed to create file: %d\n", ret);
+                goto err_file;
+        }
+
+        return 0;
+
+err_file:
+        led_classdev_unregister(&led->cdev);
+err_led:
+        kfree(led);
+err_mem:
+        return ret;
+}
+
+static int __devexit max8997_led_remove(struct platform_device *pdev)
+{
+        struct max8997_led *led = platform_get_drvdata(pdev);
+
+        device_remove_file(led->cdev.dev, &dev_attr_mode);
+        led_classdev_unregister(&led->cdev);
+        kfree(led);
+
+        return 0;
+}
+
+static struct platform_driver max8997_led_driver = {
+        .driver = {
+                .name  = "max8997-led",
+                .owner = THIS_MODULE,
+        },
+        .probe  = max8997_led_probe,
+        .remove = __devexit_p(max8997_led_remove),
+};
+
+static int __init max8997_led_init(void)
+{
+        return platform_driver_register(&max8997_led_driver);
+}
+module_init(max8997_led_init);
+
+static void __exit max8997_led_exit(void)
+{
+        platform_driver_unregister(&max8997_led_driver);
+}
+module_exit(max8997_led_exit);
+
+MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
+MODULE_DESCRIPTION("MAX8997 LED driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:max8997-led");
diff --git a/drivers/mfd/88pm860x-i2c.c b/drivers/mfd/88pm860x-i2c.c
index e017dc88622a..f93dd9571c3c 100644
--- a/drivers/mfd/88pm860x-i2c.c
+++ b/drivers/mfd/88pm860x-i2c.c
@@ -12,51 +12,20 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/regmap.h>
 #include <linux/mfd/88pm860x.h>
 #include <linux/slab.h>
 
-static inline int pm860x_read_device(struct i2c_client *i2c,
-                                     int reg, int bytes, void *dest)
-{
-        unsigned char data;
-        int ret;
-
-        data = (unsigned char)reg;
-        ret = i2c_master_send(i2c, &data, 1);
-        if (ret < 0)
-                return ret;
-
-        ret = i2c_master_recv(i2c, dest, bytes);
-        if (ret < 0)
-                return ret;
-        return 0;
-}
-
-static inline int pm860x_write_device(struct i2c_client *i2c,
-                                      int reg, int bytes, void *src)
-{
-        unsigned char buf[bytes + 1];
-        int ret;
-
-        buf[0] = (unsigned char)reg;
-        memcpy(&buf[1], src, bytes);
-
-        ret = i2c_master_send(i2c, buf, bytes + 1);
-        if (ret < 0)
-                return ret;
-        return 0;
-}
-
 int pm860x_reg_read(struct i2c_client *i2c, int reg)
 {
         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
-        unsigned char data;
+        struct regmap *map = (i2c == chip->client) ? chip->regmap
+                                : chip->regmap_companion;
+        unsigned int data;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        ret = pm860x_read_device(i2c, reg, 1, &data);
-        mutex_unlock(&chip->io_lock);
-
+        ret = regmap_read(map, reg, &data);
         if (ret < 0)
                 return ret;
         else
@@ -68,12 +37,11 @@ int pm860x_reg_write(struct i2c_client *i2c, int reg,
                      unsigned char data)
 {
         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
+        struct regmap *map = (i2c == chip->client) ? chip->regmap
+                                : chip->regmap_companion;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        ret = pm860x_write_device(i2c, reg, 1, &data);
-        mutex_unlock(&chip->io_lock);
-
+        ret = regmap_write(map, reg, data);
         return ret;
 }
 EXPORT_SYMBOL(pm860x_reg_write);
@@ -82,12 +50,11 @@ int pm860x_bulk_read(struct i2c_client *i2c, int reg,
                      int count, unsigned char *buf)
 {
         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
+        struct regmap *map = (i2c == chip->client) ? chip->regmap
+                                : chip->regmap_companion;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        ret = pm860x_read_device(i2c, reg, count, buf);
-        mutex_unlock(&chip->io_lock);
-
+        ret = regmap_raw_read(map, reg, buf, count);
         return ret;
 }
 EXPORT_SYMBOL(pm860x_bulk_read);
@@ -96,12 +63,11 @@ int pm860x_bulk_write(struct i2c_client *i2c, int reg,
                       int count, unsigned char *buf)
 {
         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
+        struct regmap *map = (i2c == chip->client) ? chip->regmap
+                                : chip->regmap_companion;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        ret = pm860x_write_device(i2c, reg, count, buf);
-        mutex_unlock(&chip->io_lock);
-
+        ret = regmap_raw_write(map, reg, buf, count);
         return ret;
 }
 EXPORT_SYMBOL(pm860x_bulk_write);
@@ -110,39 +76,78 @@ int pm860x_set_bits(struct i2c_client *i2c, int reg,
                     unsigned char mask, unsigned char data)
 {
         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
-        unsigned char value;
+        struct regmap *map = (i2c == chip->client) ? chip->regmap
+                                : chip->regmap_companion;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        ret = pm860x_read_device(i2c, reg, 1, &value);
-        if (ret < 0)
-                goto out;
-        value &= ~mask;
-        value |= data;
-        ret = pm860x_write_device(i2c, reg, 1, &value);
-out:
-        mutex_unlock(&chip->io_lock);
+        ret = regmap_update_bits(map, reg, mask, data);
         return ret;
 }
 EXPORT_SYMBOL(pm860x_set_bits);
 
+static int read_device(struct i2c_client *i2c, int reg,
+                       int bytes, void *dest)
+{
+        unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX + 3];
+        unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX + 2];
+        struct i2c_adapter *adap = i2c->adapter;
+        struct i2c_msg msg[2] = {{i2c->addr, 0, 1, msgbuf0},
+                                 {i2c->addr, I2C_M_RD, 0, msgbuf1},
+                                };
+        int num = 1, ret = 0;
+
+        if (dest == NULL)
+                return -EINVAL;
+        msgbuf0[0] = (unsigned char)reg;        /* command */
+        msg[1].len = bytes;
+
+        /* if data needs to read back, num should be 2 */
+        if (bytes > 0)
+                num = 2;
+        ret = adap->algo->master_xfer(adap, msg, num);
+        memcpy(dest, msgbuf1, bytes);
+        if (ret < 0)
+                return ret;
+        return 0;
+}
+
+static int write_device(struct i2c_client *i2c, int reg,
+                        int bytes, void *src)
+{
+        unsigned char buf[bytes + 1];
+        struct i2c_adapter *adap = i2c->adapter;
+        struct i2c_msg msg;
+        int ret;
+
+        buf[0] = (unsigned char)reg;
+        memcpy(&buf[1], src, bytes);
+        msg.addr = i2c->addr;
+        msg.flags = 0;
+        msg.len = bytes + 1;
+        msg.buf = buf;
+
+        ret = adap->algo->master_xfer(adap, &msg, 1);
+        if (ret < 0)
+                return ret;
+        return 0;
+}
+
 int pm860x_page_reg_read(struct i2c_client *i2c, int reg)
 {
-        struct pm860x_chip *chip = i2c_get_clientdata(i2c);
         unsigned char zero = 0;
         unsigned char data;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        pm860x_write_device(i2c, 0xFA, 0, &zero);
-        pm860x_write_device(i2c, 0xFB, 0, &zero);
-        pm860x_write_device(i2c, 0xFF, 0, &zero);
-        ret = pm860x_read_device(i2c, reg, 1, &data);
+        i2c_lock_adapter(i2c->adapter);
+        read_device(i2c, 0xFA, 0, &zero);
+        read_device(i2c, 0xFB, 0, &zero);
+        read_device(i2c, 0xFF, 0, &zero);
+        ret = read_device(i2c, reg, 1, &data);
         if (ret >= 0)
                 ret = (int)data;
-        pm860x_write_device(i2c, 0xFE, 0, &zero);
-        pm860x_write_device(i2c, 0xFC, 0, &zero);
-        mutex_unlock(&chip->io_lock);
+        read_device(i2c, 0xFE, 0, &zero);
+        read_device(i2c, 0xFC, 0, &zero);
+        i2c_unlock_adapter(i2c->adapter);
         return ret;
 }
 EXPORT_SYMBOL(pm860x_page_reg_read);
@@ -150,18 +155,17 @@ EXPORT_SYMBOL(pm860x_page_reg_read);
 int pm860x_page_reg_write(struct i2c_client *i2c, int reg,
                           unsigned char data)
 {
-        struct pm860x_chip *chip = i2c_get_clientdata(i2c);
         unsigned char zero;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        pm860x_write_device(i2c, 0xFA, 0, &zero);
-        pm860x_write_device(i2c, 0xFB, 0, &zero);
-        pm860x_write_device(i2c, 0xFF, 0, &zero);
-        ret = pm860x_write_device(i2c, reg, 1, &data);
-        pm860x_write_device(i2c, 0xFE, 0, &zero);
-        pm860x_write_device(i2c, 0xFC, 0, &zero);
-        mutex_unlock(&chip->io_lock);
+        i2c_lock_adapter(i2c->adapter);
+        read_device(i2c, 0xFA, 0, &zero);
+        read_device(i2c, 0xFB, 0, &zero);
+        read_device(i2c, 0xFF, 0, &zero);
+        ret = write_device(i2c, reg, 1, &data);
+        read_device(i2c, 0xFE, 0, &zero);
+        read_device(i2c, 0xFC, 0, &zero);
+        i2c_unlock_adapter(i2c->adapter);
         return ret;
 }
 EXPORT_SYMBOL(pm860x_page_reg_write);
@@ -169,18 +173,17 @@ EXPORT_SYMBOL(pm860x_page_reg_write);
 int pm860x_page_bulk_read(struct i2c_client *i2c, int reg,
                           int count, unsigned char *buf)
 {
-        struct pm860x_chip *chip = i2c_get_clientdata(i2c);
         unsigned char zero = 0;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        pm860x_write_device(i2c, 0xFA, 0, &zero);
-        pm860x_write_device(i2c, 0xFB, 0, &zero);
-        pm860x_write_device(i2c, 0xFF, 0, &zero);
-        ret = pm860x_read_device(i2c, reg, count, buf);
-        pm860x_write_device(i2c, 0xFE, 0, &zero);
-        pm860x_write_device(i2c, 0xFC, 0, &zero);
-        mutex_unlock(&chip->io_lock);
+        i2c_lock_adapter(i2c->adapter);
+        read_device(i2c, 0xfa, 0, &zero);
+        read_device(i2c, 0xfb, 0, &zero);
+        read_device(i2c, 0xff, 0, &zero);
+        ret = read_device(i2c, reg, count, buf);
+        read_device(i2c, 0xFE, 0, &zero);
+        read_device(i2c, 0xFC, 0, &zero);
+        i2c_unlock_adapter(i2c->adapter);
         return ret;
 }
 EXPORT_SYMBOL(pm860x_page_bulk_read);
@@ -188,18 +191,18 @@ EXPORT_SYMBOL(pm860x_page_bulk_read);
 int pm860x_page_bulk_write(struct i2c_client *i2c, int reg,
                            int count, unsigned char *buf)
 {
-        struct pm860x_chip *chip = i2c_get_clientdata(i2c);
         unsigned char zero = 0;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        pm860x_write_device(i2c, 0xFA, 0, &zero);
-        pm860x_write_device(i2c, 0xFB, 0, &zero);
-        pm860x_write_device(i2c, 0xFF, 0, &zero);
-        ret = pm860x_write_device(i2c, reg, count, buf);
-        pm860x_write_device(i2c, 0xFE, 0, &zero);
-        pm860x_write_device(i2c, 0xFC, 0, &zero);
-        mutex_unlock(&chip->io_lock);
+        i2c_lock_adapter(i2c->adapter);
+        read_device(i2c, 0xFA, 0, &zero);
+        read_device(i2c, 0xFB, 0, &zero);
+        read_device(i2c, 0xFF, 0, &zero);
+        ret = write_device(i2c, reg, count, buf);
+        read_device(i2c, 0xFE, 0, &zero);
+        read_device(i2c, 0xFC, 0, &zero);
+        i2c_unlock_adapter(i2c->adapter);
+        i2c_unlock_adapter(i2c->adapter);
         return ret;
 }
 EXPORT_SYMBOL(pm860x_page_bulk_write);
@@ -207,25 +210,24 @@ EXPORT_SYMBOL(pm860x_page_bulk_write);
 int pm860x_page_set_bits(struct i2c_client *i2c, int reg,
                          unsigned char mask, unsigned char data)
 {
-        struct pm860x_chip *chip = i2c_get_clientdata(i2c);
         unsigned char zero;
         unsigned char value;
         int ret;
 
-        mutex_lock(&chip->io_lock);
-        pm860x_write_device(i2c, 0xFA, 0, &zero);
-        pm860x_write_device(i2c, 0xFB, 0, &zero);
-        pm860x_write_device(i2c, 0xFF, 0, &zero);
-        ret = pm860x_read_device(i2c, reg, 1, &value);
+        i2c_lock_adapter(i2c->adapter);
+        read_device(i2c, 0xFA, 0, &zero);
+        read_device(i2c, 0xFB, 0, &zero);
+        read_device(i2c, 0xFF, 0, &zero);
+        ret = read_device(i2c, reg, 1, &value);
         if (ret < 0)
                 goto out;
         value &= ~mask;
         value |= data;
-        ret = pm860x_write_device(i2c, reg, 1, &value);
+        ret = write_device(i2c, reg, 1, &value);
 out:
-        pm860x_write_device(i2c, 0xFE, 0, &zero);
-        pm860x_write_device(i2c, 0xFC, 0, &zero);
-        mutex_unlock(&chip->io_lock);
+        read_device(i2c, 0xFE, 0, &zero);
+        read_device(i2c, 0xFC, 0, &zero);
+        i2c_unlock_adapter(i2c->adapter);
         return ret;
 }
 EXPORT_SYMBOL(pm860x_page_set_bits);
@@ -257,11 +259,17 @@ static int verify_addr(struct i2c_client *i2c)
         return 0;
 }
 
+static struct regmap_config pm860x_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+};
+
 static int __devinit pm860x_probe(struct i2c_client *client,
                                   const struct i2c_device_id *id)
 {
         struct pm860x_platform_data *pdata = client->dev.platform_data;
         struct pm860x_chip *chip;
+        int ret;
 
         if (!pdata) {
                 pr_info("No platform data in %s!\n", __func__);
@@ -273,10 +281,17 @@ static int __devinit pm860x_probe(struct i2c_client *client,
                 return -ENOMEM;
 
         chip->id = verify_addr(client);
+        chip->regmap = regmap_init_i2c(client, &pm860x_regmap_config);
+        if (IS_ERR(chip->regmap)) {
+                ret = PTR_ERR(chip->regmap);
+                dev_err(&client->dev, "Failed to allocate register map: %d\n",
+                                ret);
+                kfree(chip);
+                return ret;
+        }
         chip->client = client;
         i2c_set_clientdata(client, chip);
         chip->dev = &client->dev;
-        mutex_init(&chip->io_lock);
         dev_set_drvdata(chip->dev, chip);
 
         /*
@@ -290,6 +305,14 @@ static int __devinit pm860x_probe(struct i2c_client *client,
                 chip->companion_addr = pdata->companion_addr;
                 chip->companion = i2c_new_dummy(chip->client->adapter,
                                                 chip->companion_addr);
+                chip->regmap_companion = regmap_init_i2c(chip->companion,
+                                                        &pm860x_regmap_config);
+                if (IS_ERR(chip->regmap_companion)) {
+                        ret = PTR_ERR(chip->regmap_companion);
+                        dev_err(&chip->companion->dev,
+                                "Failed to allocate register map: %d\n", ret);
+                        return ret;
+                }
                 i2c_set_clientdata(chip->companion, chip);
         }
 
@@ -302,7 +325,11 @@ static int __devexit pm860x_remove(struct i2c_client *client)
         struct pm860x_chip *chip = i2c_get_clientdata(client);
 
         pm860x_device_exit(chip);
-        i2c_unregister_device(chip->companion);
+        if (chip->companion) {
+                regmap_exit(chip->regmap_companion);
+                i2c_unregister_device(chip->companion);
+        }
+        regmap_exit(chip->regmap);
         kfree(chip);
         return 0;
 }
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 053208d31fb9..cd13e9f2f5e6 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -12,6 +12,7 @@ config MFD_CORE
 config MFD_88PM860X
         bool "Support Marvell 88PM8606/88PM8607"
         depends on I2C=y && GENERIC_HARDIRQS
+        select REGMAP_I2C
         select MFD_CORE
         help
           This supports for Marvell 88PM8606/88PM8607 Power Management IC.
@@ -199,7 +200,7 @@ config MENELAUS
 
 config TWL4030_CORE
         bool "Texas Instruments TWL4030/TWL5030/TWL6030/TPS659x0 Support"
-        depends on I2C=y && GENERIC_HARDIRQS
+        depends on I2C=y && GENERIC_HARDIRQS && IRQ_DOMAIN
         help
           Say yes here if you have TWL4030 / TWL6030 family chip on your board.
           This core driver provides register access and IRQ handling
@@ -257,7 +258,7 @@ config TWL6040_CORE
 
 config MFD_STMPE
         bool "Support STMicroelectronics STMPE"
-        depends on I2C=y && GENERIC_HARDIRQS
+        depends on (I2C=y || SPI_MASTER=y) && GENERIC_HARDIRQS
         select MFD_CORE
         help
           Support for the STMPE family of I/O Expanders from
@@ -278,6 +279,23 @@ config MFD_STMPE
                 Keypad: stmpe-keypad
                 Touchscreen: stmpe-ts
 
+menu "STMPE Interface Drivers"
+depends on MFD_STMPE
+
+config STMPE_I2C
+        bool "STMPE I2C Inteface"
+        depends on I2C=y
+        default y
+        help
+          This is used to enable I2C interface of STMPE
+
+config STMPE_SPI
+        bool "STMPE SPI Inteface"
+        depends on SPI_MASTER
+        help
+          This is used to enable SPI interface of STMPE
+endmenu
+
 config MFD_TC3589X
         bool "Support Toshiba TC35892 and variants"
         depends on I2C=y && GENERIC_HARDIRQS
@@ -311,7 +329,7 @@ config MFD_TC6387XB
 
 config MFD_TC6393XB
         bool "Support Toshiba TC6393XB"
-        depends on GPIOLIB && ARM
+        depends on GPIOLIB && ARM && HAVE_CLK
         select MFD_CORE
         select MFD_TMIO
         help
@@ -399,6 +417,17 @@ config MFD_MAX8998
           additional drivers must be enabled in order to use the functionality
           of the device.
 
+config MFD_S5M_CORE
+        bool "SAMSUNG S5M Series Support"
+        depends on I2C=y && GENERIC_HARDIRQS
+        select MFD_CORE
+        select REGMAP_I2C
+        help
+         Support for the Samsung Electronics S5M MFD series.
+         This driver provies common support for accessing the device,
+         additional drivers must be enabled in order to use the functionality
+         of the device
+
 config MFD_WM8400
         tristate "Support Wolfson Microelectronics WM8400"
         select MFD_CORE
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 47591fc7d0d2..b953bab934f7 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -16,6 +16,8 @@ obj-$(CONFIG_MFD_DM355EVM_MSP)	+= dm355evm_msp.o
 obj-$(CONFIG_MFD_TI_SSP)        += ti-ssp.o
 
 obj-$(CONFIG_MFD_STMPE)         += stmpe.o
+obj-$(CONFIG_STMPE_I2C)         += stmpe-i2c.o
+obj-$(CONFIG_STMPE_SPI)         += stmpe-spi.o
 obj-$(CONFIG_MFD_TC3589X)       += tc3589x.o
 obj-$(CONFIG_MFD_T7L66XB)       += t7l66xb.o tmio_core.o
 obj-$(CONFIG_MFD_TC6387XB)      += tc6387xb.o tmio_core.o
@@ -109,3 +111,4 @@ obj-$(CONFIG_MFD_PM8XXX_IRQ) 	+= pm8xxx-irq.o
 obj-$(CONFIG_TPS65911_COMPARATOR)       += tps65911-comparator.o
 obj-$(CONFIG_MFD_AAT2870_CORE)  += aat2870-core.o
 obj-$(CONFIG_MFD_INTEL_MSIC)    += intel_msic.o
+obj-$(CONFIG_MFD_S5M_CORE)      += s5m-core.o s5m-irq.o
diff --git a/drivers/mfd/aat2870-core.c b/drivers/mfd/aat2870-core.c
index 02c42015ba51..3aa36eb5c79b 100644
--- a/drivers/mfd/aat2870-core.c
+++ b/drivers/mfd/aat2870-core.c
@@ -407,13 +407,13 @@ static int aat2870_i2c_probe(struct i2c_client *client,
                 aat2870->init(aat2870);
 
         if (aat2870->en_pin >= 0) {
-                ret = gpio_request(aat2870->en_pin, "aat2870-en");
+                ret = gpio_request_one(aat2870->en_pin, GPIOF_OUT_INIT_HIGH,
+                                       "aat2870-en");
                 if (ret < 0) {
                         dev_err(&client->dev,
                                 "Failed to request GPIO %d\n", aat2870->en_pin);
                         goto out_kfree;
                 }
-                gpio_direction_output(aat2870->en_pin, 1);
         }
 
         aat2870_enable(aat2870);
@@ -468,9 +468,10 @@ static int aat2870_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int aat2870_i2c_suspend(struct i2c_client *client, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int aat2870_i2c_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct aat2870_data *aat2870 = i2c_get_clientdata(client);
 
         aat2870_disable(aat2870);
@@ -478,8 +479,9 @@ static int aat2870_i2c_suspend(struct i2c_client *client, pm_message_t state)
         return 0;
 }
 
-static int aat2870_i2c_resume(struct i2c_client *client)
+static int aat2870_i2c_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct aat2870_data *aat2870 = i2c_get_clientdata(client);
         struct aat2870_register *reg = NULL;
         int i;
@@ -495,12 +497,12 @@ static int aat2870_i2c_resume(struct i2c_client *client)
 
         return 0;
 }
-#else
-#define aat2870_i2c_suspend     NULL
-#define aat2870_i2c_resume      NULL
-#endif /* CONFIG_PM */
+#endif /* CONFIG_PM_SLEEP */
+
+static SIMPLE_DEV_PM_OPS(aat2870_pm_ops, aat2870_i2c_suspend,
+                         aat2870_i2c_resume);
 
-static struct i2c_device_id aat2870_i2c_id_table[] = {
+static const struct i2c_device_id aat2870_i2c_id_table[] = {
         { "aat2870", 0 },
         { }
 };
@@ -510,11 +512,10 @@ static struct i2c_driver aat2870_i2c_driver = {
         .driver = {
                 .name   = "aat2870",
                 .owner  = THIS_MODULE,
+                .pm     = &aat2870_pm_ops,
         },
         .probe          = aat2870_i2c_probe,
         .remove         = aat2870_i2c_remove,
-        .suspend        = aat2870_i2c_suspend,
-        .resume         = aat2870_i2c_resume,
         .id_table       = aat2870_i2c_id_table,
 };
 
diff --git a/drivers/mfd/ab5500-core.c b/drivers/mfd/ab5500-core.c
index ec10629a0b0b..bd56a764dea1 100644
--- a/drivers/mfd/ab5500-core.c
+++ b/drivers/mfd/ab5500-core.c
@@ -22,8 +22,8 @@
 #include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/random.h>
-#include <linux/mfd/ab5500/ab5500.h>
 #include <linux/mfd/abx500.h>
+#include <linux/mfd/abx500/ab5500.h>
 #include <linux/list.h>
 #include <linux/bitops.h>
 #include <linux/spinlock.h>
diff --git a/drivers/mfd/ab5500-debugfs.c b/drivers/mfd/ab5500-debugfs.c
index b7b2d3483fd4..72006940937a 100644
--- a/drivers/mfd/ab5500-debugfs.c
+++ b/drivers/mfd/ab5500-debugfs.c
@@ -7,8 +7,8 @@
 #include <linux/module.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
-#include <linux/mfd/ab5500/ab5500.h>
 #include <linux/mfd/abx500.h>
+#include <linux/mfd/abx500/ab5500.h>
 #include <linux/uaccess.h>
 
 #include "ab5500-core.h"
diff --git a/drivers/mfd/ab8500-core.c b/drivers/mfd/ab8500-core.c
index d3d572b2317b..53e2a80f42fa 100644
--- a/drivers/mfd/ab8500-core.c
+++ b/drivers/mfd/ab8500-core.c
@@ -17,7 +17,7 @@
 #include <linux/platform_device.h>
 #include <linux/mfd/core.h>
 #include <linux/mfd/abx500.h>
-#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500/ab8500.h>
 #include <linux/regulator/ab8500.h>
 
 /*
diff --git a/drivers/mfd/ab8500-debugfs.c b/drivers/mfd/ab8500-debugfs.c
index dedb7f65cea6..9a0211aa8897 100644
--- a/drivers/mfd/ab8500-debugfs.c
+++ b/drivers/mfd/ab8500-debugfs.c
@@ -13,7 +13,7 @@
 #include <linux/platform_device.h>
 
 #include <linux/mfd/abx500.h>
-#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500/ab8500.h>
 
 static u32 debug_bank;
 static u32 debug_address;
diff --git a/drivers/mfd/ab8500-gpadc.c b/drivers/mfd/ab8500-gpadc.c
index e985d1701a83..c39fc716e1dc 100644
--- a/drivers/mfd/ab8500-gpadc.c
+++ b/drivers/mfd/ab8500-gpadc.c
@@ -18,9 +18,9 @@
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/list.h>
-#include <linux/mfd/ab8500.h>
 #include <linux/mfd/abx500.h>
-#include <linux/mfd/ab8500/gpadc.h>
+#include <linux/mfd/abx500/ab8500.h>
+#include <linux/mfd/abx500/ab8500-gpadc.h>
 
 /*
  * GPADC register offsets
diff --git a/drivers/mfd/ab8500-i2c.c b/drivers/mfd/ab8500-i2c.c
index 9be541c6b004..087fecd71ce0 100644
--- a/drivers/mfd/ab8500-i2c.c
+++ b/drivers/mfd/ab8500-i2c.c
@@ -10,7 +10,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
-#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500/ab8500.h>
 #include <linux/mfd/db8500-prcmu.h>
 
 static int ab8500_i2c_write(struct ab8500 *ab8500, u16 addr, u8 data)
diff --git a/drivers/mfd/ab8500-sysctrl.c b/drivers/mfd/ab8500-sysctrl.c
index f20feefac190..c28d4eb1eff0 100644
--- a/drivers/mfd/ab8500-sysctrl.c
+++ b/drivers/mfd/ab8500-sysctrl.c
@@ -7,9 +7,9 @@
 #include <linux/err.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
-#include <linux/mfd/ab8500.h>
 #include <linux/mfd/abx500.h>
-#include <linux/mfd/ab8500/sysctrl.h>
+#include <linux/mfd/abx500/ab8500.h>
+#include <linux/mfd/abx500/ab8500-sysctrl.h>
 
 static struct device *sysctrl_dev;
 
diff --git a/drivers/mfd/cs5535-mfd.c b/drivers/mfd/cs5535-mfd.c
index 155fa0407882..315fef5d466a 100644
--- a/drivers/mfd/cs5535-mfd.c
+++ b/drivers/mfd/cs5535-mfd.c
@@ -172,14 +172,14 @@ static void __devexit cs5535_mfd_remove(struct pci_dev *pdev)
         pci_disable_device(pdev);
 }
 
-static struct pci_device_id cs5535_mfd_pci_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(cs5535_mfd_pci_tbl) = {
         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_ISA) },
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA) },
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, cs5535_mfd_pci_tbl);
 
-static struct pci_driver cs5535_mfd_drv = {
+static struct pci_driver cs5535_mfd_driver = {
         .name = DRV_NAME,
         .id_table = cs5535_mfd_pci_tbl,
         .probe = cs5535_mfd_probe,
@@ -188,12 +188,12 @@ static struct pci_driver cs5535_mfd_drv = {
 
 static int __init cs5535_mfd_init(void)
 {
-        return pci_register_driver(&cs5535_mfd_drv);
+        return pci_register_driver(&cs5535_mfd_driver);
 }
 
 static void __exit cs5535_mfd_exit(void)
 {
-        pci_unregister_driver(&cs5535_mfd_drv);
+        pci_unregister_driver(&cs5535_mfd_driver);
 }
 
 module_init(cs5535_mfd_init);
diff --git a/drivers/mfd/dm355evm_msp.c b/drivers/mfd/dm355evm_msp.c
index 8ad88da647b9..7710227d284e 100644
--- a/drivers/mfd/dm355evm_msp.c
+++ b/drivers/mfd/dm355evm_msp.c
@@ -308,8 +308,7 @@ static int add_children(struct i2c_client *client)
         for (i = 0; i < ARRAY_SIZE(config_inputs); i++) {
                 int gpio = dm355evm_msp_gpio.base + config_inputs[i].offset;
 
-                gpio_request(gpio, config_inputs[i].label);
-                gpio_direction_input(gpio);
+                gpio_request_one(gpio, GPIOF_IN, config_inputs[i].label);
 
                 /* make it easy for userspace to see these */
                 gpio_export(gpio, false);
diff --git a/drivers/mfd/intel_msic.c b/drivers/mfd/intel_msic.c
index 97c27762174f..b76657eb0c51 100644
--- a/drivers/mfd/intel_msic.c
+++ b/drivers/mfd/intel_msic.c
@@ -485,17 +485,7 @@ static struct platform_driver intel_msic_driver = {
         },
 };
 
-static int __init intel_msic_init(void)
-{
-        return platform_driver_register(&intel_msic_driver);
-}
-module_init(intel_msic_init);
-
-static void __exit intel_msic_exit(void)
-{
-        platform_driver_unregister(&intel_msic_driver);
-}
-module_exit(intel_msic_exit);
+module_platform_driver(intel_msic_driver);
 
 MODULE_DESCRIPTION("Driver for Intel MSIC");
 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
diff --git a/drivers/mfd/jz4740-adc.c b/drivers/mfd/jz4740-adc.c
index ef39528088f2..87662a17dec6 100644
--- a/drivers/mfd/jz4740-adc.c
+++ b/drivers/mfd/jz4740-adc.c
@@ -181,7 +181,7 @@ static struct resource jz4740_battery_resources[] = {
         },
 };
 
-const struct mfd_cell jz4740_adc_cells[] = {
+static struct mfd_cell jz4740_adc_cells[] = {
         {
                 .id = 0,
                 .name = "jz4740-hwmon",
@@ -338,17 +338,7 @@ static struct platform_driver jz4740_adc_driver = {
         },
 };
 
-static int __init jz4740_adc_init(void)
-{
-        return platform_driver_register(&jz4740_adc_driver);
-}
-module_init(jz4740_adc_init);
-
-static void __exit jz4740_adc_exit(void)
-{
-        platform_driver_unregister(&jz4740_adc_driver);
-}
-module_exit(jz4740_adc_exit);
+module_platform_driver(jz4740_adc_driver);
 
 MODULE_DESCRIPTION("JZ4740 SoC ADC driver");
 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
diff --git a/drivers/mfd/lpc_sch.c b/drivers/mfd/lpc_sch.c
index ea1169b04779..abc421364a45 100644
--- a/drivers/mfd/lpc_sch.c
+++ b/drivers/mfd/lpc_sch.c
@@ -74,7 +74,7 @@ static struct mfd_cell tunnelcreek_cells[] = {
         },
 };
 
-static struct pci_device_id lpc_sch_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(lpc_sch_ids) = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SCH_LPC) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ITC_LPC) },
         { 0, }
diff --git a/drivers/mfd/max8925-i2c.c b/drivers/mfd/max8925-i2c.c
index 0219115e00c7..d9e4b36edee9 100644
--- a/drivers/mfd/max8925-i2c.c
+++ b/drivers/mfd/max8925-i2c.c
@@ -161,6 +161,8 @@ static int __devinit max8925_probe(struct i2c_client *client,
         chip->adc = i2c_new_dummy(chip->i2c->adapter, ADC_I2C_ADDR);
         i2c_set_clientdata(chip->adc, chip);
 
+        device_init_wakeup(&client->dev, 1);
+
         max8925_device_init(chip, pdata);
 
         return 0;
@@ -177,10 +179,35 @@ static int __devexit max8925_remove(struct i2c_client *client)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
+static int max8925_suspend(struct device *dev)
+{
+        struct i2c_client *client = container_of(dev, struct i2c_client, dev);
+        struct max8925_chip *chip = i2c_get_clientdata(client);
+
+        if (device_may_wakeup(dev) && chip->wakeup_flag)
+                enable_irq_wake(chip->core_irq);
+        return 0;
+}
+
+static int max8925_resume(struct device *dev)
+{
+        struct i2c_client *client = container_of(dev, struct i2c_client, dev);
+        struct max8925_chip *chip = i2c_get_clientdata(client);
+
+        if (device_may_wakeup(dev) && chip->wakeup_flag)
+                disable_irq_wake(chip->core_irq);
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(max8925_pm_ops, max8925_suspend, max8925_resume);
+
 static struct i2c_driver max8925_driver = {
         .driver = {
                 .name   = "max8925",
                 .owner  = THIS_MODULE,
+                .pm     = &max8925_pm_ops,
         },
         .probe          = max8925_probe,
         .remove         = __devexit_p(max8925_remove),
diff --git a/drivers/mfd/max8997.c b/drivers/mfd/max8997.c
index 5be53ae9b61c..cb83a7ab53e7 100644
--- a/drivers/mfd/max8997.c
+++ b/drivers/mfd/max8997.c
@@ -43,7 +43,8 @@ static struct mfd_cell max8997_devs[] = {
         { .name = "max8997-battery", },
         { .name = "max8997-haptic", },
         { .name = "max8997-muic", },
-        { .name = "max8997-flash", },
+        { .name = "max8997-led", .id = 1 },
+        { .name = "max8997-led", .id = 2 },
 };
 
 int max8997_read_reg(struct i2c_client *i2c, u8 reg, u8 *dest)
diff --git a/drivers/mfd/max8998.c b/drivers/mfd/max8998.c
index de4096aee248..6ef56d28c056 100644
--- a/drivers/mfd/max8998.c
+++ b/drivers/mfd/max8998.c
@@ -176,6 +176,8 @@ static int max8998_i2c_probe(struct i2c_client *i2c,
         if (ret < 0)
                 goto err;
 
+        device_init_wakeup(max8998->dev, max8998->wakeup);
+
         return ret;
 
 err:
@@ -210,7 +212,7 @@ static int max8998_suspend(struct device *dev)
         struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
         struct max8998_dev *max8998 = i2c_get_clientdata(i2c);
 
-        if (max8998->wakeup)
+        if (device_may_wakeup(dev))
                 irq_set_irq_wake(max8998->irq, 1);
         return 0;
 }
@@ -220,7 +222,7 @@ static int max8998_resume(struct device *dev)
         struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
         struct max8998_dev *max8998 = i2c_get_clientdata(i2c);
 
-        if (max8998->wakeup)
+        if (device_may_wakeup(dev))
                 irq_set_irq_wake(max8998->irq, 0);
         /*
          * In LP3974, if IRQ registers are not "read & clear"
diff --git a/drivers/mfd/mc13xxx-core.c b/drivers/mfd/mc13xxx-core.c
index e9619acc0237..7122386b4e3c 100644
--- a/drivers/mfd/mc13xxx-core.c
+++ b/drivers/mfd/mc13xxx-core.c
@@ -18,11 +18,15 @@
 #include <linux/spi/spi.h>
 #include <linux/mfd/core.h>
 #include <linux/mfd/mc13xxx.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
 
 struct mc13xxx {
         struct spi_device *spidev;
         struct mutex lock;
         int irq;
+        int flags;
 
         irq_handler_t irqhandler[MC13XXX_NUM_IRQ];
         void *irqdata[MC13XXX_NUM_IRQ];
@@ -550,10 +554,7 @@ static const char *mc13xxx_get_chipname(struct mc13xxx *mc13xxx)
 
 int mc13xxx_get_flags(struct mc13xxx *mc13xxx)
 {
-        struct mc13xxx_platform_data *pdata =
-                dev_get_platdata(&mc13xxx->spidev->dev);
-
-        return pdata->flags;
+        return mc13xxx->flags;
 }
 EXPORT_SYMBOL(mc13xxx_get_flags);
 
@@ -615,13 +616,13 @@ int mc13xxx_adc_do_conversion(struct mc13xxx *mc13xxx, unsigned int mode,
                 break;
 
         case MC13XXX_ADC_MODE_SINGLE_CHAN:
-                adc0 |= old_adc0 & MC13XXX_ADC0_TSMOD_MASK;
+                adc0 |= old_adc0 & MC13XXX_ADC0_CONFIG_MASK;
                 adc1 |= (channel & 0x7) << MC13XXX_ADC1_CHAN0_SHIFT;
                 adc1 |= MC13XXX_ADC1_RAND;
                 break;
 
         case MC13XXX_ADC_MODE_MULT_CHAN:
-                adc0 |= old_adc0 & MC13XXX_ADC0_TSMOD_MASK;
+                adc0 |= old_adc0 & MC13XXX_ADC0_CONFIG_MASK;
                 adc1 |= 4 << MC13XXX_ADC1_CHAN1_SHIFT;
                 break;
 
@@ -696,17 +697,67 @@ static int mc13xxx_add_subdevice(struct mc13xxx *mc13xxx, const char *format)
         return mc13xxx_add_subdevice_pdata(mc13xxx, format, NULL, 0);
 }
 
+#ifdef CONFIG_OF
+static int mc13xxx_probe_flags_dt(struct mc13xxx *mc13xxx)
+{
+        struct device_node *np = mc13xxx->spidev->dev.of_node;
+
+        if (!np)
+                return -ENODEV;
+
+        if (of_get_property(np, "fsl,mc13xxx-uses-adc", NULL))
+                mc13xxx->flags |= MC13XXX_USE_ADC;
+
+        if (of_get_property(np, "fsl,mc13xxx-uses-codec", NULL))
+                mc13xxx->flags |= MC13XXX_USE_CODEC;
+
+        if (of_get_property(np, "fsl,mc13xxx-uses-rtc", NULL))
+                mc13xxx->flags |= MC13XXX_USE_RTC;
+
+        if (of_get_property(np, "fsl,mc13xxx-uses-touch", NULL))
+                mc13xxx->flags |= MC13XXX_USE_TOUCHSCREEN;
+
+        return 0;
+}
+#else
+static inline int mc13xxx_probe_flags_dt(struct mc13xxx *mc13xxx)
+{
+        return -ENODEV;
+}
+#endif
+
+static const struct spi_device_id mc13xxx_device_id[] = {
+        {
+                .name = "mc13783",
+                .driver_data = MC13XXX_ID_MC13783,
+        }, {
+                .name = "mc13892",
+                .driver_data = MC13XXX_ID_MC13892,
+        }, {
+                /* sentinel */
+        }
+};
+MODULE_DEVICE_TABLE(spi, mc13xxx_device_id);
+
+static const struct of_device_id mc13xxx_dt_ids[] = {
+        { .compatible = "fsl,mc13783", .data = (void *) MC13XXX_ID_MC13783, },
+        { .compatible = "fsl,mc13892", .data = (void *) MC13XXX_ID_MC13892, },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mc13xxx_dt_ids);
+
 static int mc13xxx_probe(struct spi_device *spi)
 {
+        const struct of_device_id *of_id;
+        struct spi_driver *sdrv = to_spi_driver(spi->dev.driver);
         struct mc13xxx *mc13xxx;
         struct mc13xxx_platform_data *pdata = dev_get_platdata(&spi->dev);
         enum mc13xxx_id id;
         int ret;
 
-        if (!pdata) {
-                dev_err(&spi->dev, "invalid platform data\n");
-                return -EINVAL;
-        }
+        of_id = of_match_device(mc13xxx_dt_ids, &spi->dev);
+        if (of_id)
+                sdrv->id_table = &mc13xxx_device_id[(enum mc13xxx_id) of_id->data];
 
         mc13xxx = kzalloc(sizeof(*mc13xxx), GFP_KERNEL);
         if (!mc13xxx)
@@ -749,28 +800,33 @@ err_revision:
 
         mc13xxx_unlock(mc13xxx);
 
-        if (pdata->flags & MC13XXX_USE_ADC)
+        if (mc13xxx_probe_flags_dt(mc13xxx) < 0 && pdata)
+                mc13xxx->flags = pdata->flags;
+
+        if (mc13xxx->flags & MC13XXX_USE_ADC)
                 mc13xxx_add_subdevice(mc13xxx, "%s-adc");
 
-        if (pdata->flags & MC13XXX_USE_CODEC)
+        if (mc13xxx->flags & MC13XXX_USE_CODEC)
                 mc13xxx_add_subdevice(mc13xxx, "%s-codec");
 
-        mc13xxx_add_subdevice_pdata(mc13xxx, "%s-regulator",
-                &pdata->regulators, sizeof(pdata->regulators));
-
-        if (pdata->flags & MC13XXX_USE_RTC)
+        if (mc13xxx->flags & MC13XXX_USE_RTC)
                 mc13xxx_add_subdevice(mc13xxx, "%s-rtc");
 
-        if (pdata->flags & MC13XXX_USE_TOUCHSCREEN)
+        if (mc13xxx->flags & MC13XXX_USE_TOUCHSCREEN)
                 mc13xxx_add_subdevice(mc13xxx, "%s-ts");
 
-        if (pdata->leds)
+        if (pdata) {
+                mc13xxx_add_subdevice_pdata(mc13xxx, "%s-regulator",
+                        &pdata->regulators, sizeof(pdata->regulators));
                 mc13xxx_add_subdevice_pdata(mc13xxx, "%s-led",
                                 pdata->leds, sizeof(*pdata->leds));
-
-        if (pdata->buttons)
                 mc13xxx_add_subdevice_pdata(mc13xxx, "%s-pwrbutton",
                                 pdata->buttons, sizeof(*pdata->buttons));
+        } else {
+                mc13xxx_add_subdevice(mc13xxx, "%s-regulator");
+                mc13xxx_add_subdevice(mc13xxx, "%s-led");
+                mc13xxx_add_subdevice(mc13xxx, "%s-pwrbutton");
+        }
 
         return 0;
 }
@@ -788,25 +844,12 @@ static int __devexit mc13xxx_remove(struct spi_device *spi)
         return 0;
 }
 
-static const struct spi_device_id mc13xxx_device_id[] = {
-        {
-                .name = "mc13783",
-                .driver_data = MC13XXX_ID_MC13783,
-        }, {
-                .name = "mc13892",
-                .driver_data = MC13XXX_ID_MC13892,
-        }, {
-                /* sentinel */
-        }
-};
-MODULE_DEVICE_TABLE(spi, mc13xxx_device_id);
-
 static struct spi_driver mc13xxx_driver = {
         .id_table = mc13xxx_device_id,
         .driver = {
                 .name = "mc13xxx",
-                .bus = &spi_bus_type,
                 .owner = THIS_MODULE,
+                .of_match_table = mc13xxx_dt_ids,
         },
         .probe = mc13xxx_probe,
         .remove = __devexit_p(mc13xxx_remove),
diff --git a/drivers/mfd/mcp-core.c b/drivers/mfd/mcp-core.c
index 84815f9ef636..63be60bc3455 100644
--- a/drivers/mfd/mcp-core.c
+++ b/drivers/mfd/mcp-core.c
@@ -26,9 +26,35 @@
 #define to_mcp(d)               container_of(d, struct mcp, attached_device)
 #define to_mcp_driver(d)        container_of(d, struct mcp_driver, drv)
 
+static const struct mcp_device_id *mcp_match_id(const struct mcp_device_id *id,
+                                                const char *codec)
+{
+        while (id->name[0]) {
+                if (strcmp(codec, id->name) == 0)
+                        return id;
+                id++;
+        }
+        return NULL;
+}
+
+const struct mcp_device_id *mcp_get_device_id(const struct mcp *mcp)
+{
+        const struct mcp_driver *driver =
+                to_mcp_driver(mcp->attached_device.driver);
+
+        return mcp_match_id(driver->id_table, mcp->codec);
+}
+EXPORT_SYMBOL(mcp_get_device_id);
+
 static int mcp_bus_match(struct device *dev, struct device_driver *drv)
 {
-        return 1;
+        const struct mcp *mcp = to_mcp(dev);
+        const struct mcp_driver *driver = to_mcp_driver(drv);
+
+        if (driver->id_table)
+                return !!mcp_match_id(driver->id_table, mcp->codec);
+
+        return 0;
 }
 
 static int mcp_bus_probe(struct device *dev)
@@ -74,9 +100,18 @@ static int mcp_bus_resume(struct device *dev)
         return ret;
 }
 
+static int mcp_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+        struct mcp *mcp = to_mcp(dev);
+
+        add_uevent_var(env, "MODALIAS=%s%s", MCP_MODULE_PREFIX, mcp->codec);
+        return 0;
+}
+
 static struct bus_type mcp_bus_type = {
         .name           = "mcp",
         .match          = mcp_bus_match,
+        .uevent         = mcp_bus_uevent,
         .probe          = mcp_bus_probe,
         .remove         = mcp_bus_remove,
         .suspend        = mcp_bus_suspend,
@@ -212,9 +247,14 @@ struct mcp *mcp_host_alloc(struct device *parent, size_t size)
 }
 EXPORT_SYMBOL(mcp_host_alloc);
 
-int mcp_host_register(struct mcp *mcp)
+int mcp_host_register(struct mcp *mcp, void *pdata)
 {
+        if (!mcp->codec)
+                return -EINVAL;
+
+        mcp->attached_device.platform_data = pdata;
         dev_set_name(&mcp->attached_device, "mcp0");
+        request_module("%s%s", MCP_MODULE_PREFIX, mcp->codec);
         return device_register(&mcp->attached_device);
 }
 EXPORT_SYMBOL(mcp_host_register);
diff --git a/drivers/mfd/mcp-sa11x0.c b/drivers/mfd/mcp-sa11x0.c
index 2dab02d9ac8b..9adc2eb69492 100644
--- a/drivers/mfd/mcp-sa11x0.c
+++ b/drivers/mfd/mcp-sa11x0.c
@@ -19,6 +19,7 @@
 #include <linux/spinlock.h>
 #include <linux/platform_device.h>
 #include <linux/mfd/mcp.h>
+#include <linux/io.h>
 
 #include <mach/dma.h>
 #include <mach/hardware.h>
@@ -26,12 +27,19 @@
 #include <asm/system.h>
 #include <mach/mcp.h>
 
-#include <mach/assabet.h>
-
+/* Register offsets */
+#define MCCR0   0x00
+#define MCDR0   0x08
+#define MCDR1   0x0C
+#define MCDR2   0x10
+#define MCSR    0x18
+#define MCCR1   0x00
 
 struct mcp_sa11x0 {
-        u32     mccr0;
-        u32     mccr1;
+        u32             mccr0;
+        u32             mccr1;
+        unsigned char   *mccr0_base;
+        unsigned char   *mccr1_base;
 };
 
 #define priv(mcp)       ((struct mcp_sa11x0 *)mcp_priv(mcp))
@@ -39,25 +47,25 @@ struct mcp_sa11x0 {
 static void
 mcp_sa11x0_set_telecom_divisor(struct mcp *mcp, unsigned int divisor)
 {
-        unsigned int mccr0;
+        struct mcp_sa11x0 *priv = priv(mcp);
 
         divisor /= 32;
 
-        mccr0 = Ser4MCCR0 & ~0x00007f00;
-        mccr0 |= divisor << 8;
-        Ser4MCCR0 = mccr0;
+        priv->mccr0 &= ~0x00007f00;
+        priv->mccr0 |= divisor << 8;
+        __raw_writel(priv->mccr0, priv->mccr0_base + MCCR0);
 }
 
 static void
 mcp_sa11x0_set_audio_divisor(struct mcp *mcp, unsigned int divisor)
 {
-        unsigned int mccr0;
+        struct mcp_sa11x0 *priv = priv(mcp);
 
         divisor /= 32;
 
-        mccr0 = Ser4MCCR0 & ~0x0000007f;
-        mccr0 |= divisor;
-        Ser4MCCR0 = mccr0;
+        priv->mccr0 &= ~0x0000007f;
+        priv->mccr0 |= divisor;
+        __raw_writel(priv->mccr0, priv->mccr0_base + MCCR0);
 }
 
 /*
@@ -71,12 +79,16 @@ mcp_sa11x0_write(struct mcp *mcp, unsigned int reg, unsigned int val)
 {
         int ret = -ETIME;
         int i;
+        u32 mcpreg;
+        struct mcp_sa11x0 *priv = priv(mcp);
 
-        Ser4MCDR2 = reg << 17 | MCDR2_Wr | (val & 0xffff);
+        mcpreg = reg << 17 | MCDR2_Wr | (val & 0xffff);
+        __raw_writel(mcpreg, priv->mccr0_base + MCDR2);
 
         for (i = 0; i < 2; i++) {
                 udelay(mcp->rw_timeout);
-                if (Ser4MCSR & MCSR_CWC) {
+                mcpreg = __raw_readl(priv->mccr0_base + MCSR);
+                if (mcpreg & MCSR_CWC) {
                         ret = 0;
                         break;
                 }
@@ -97,13 +109,18 @@ mcp_sa11x0_read(struct mcp *mcp, unsigned int reg)
 {
         int ret = -ETIME;
         int i;
+        u32 mcpreg;
+        struct mcp_sa11x0 *priv = priv(mcp);
 
-        Ser4MCDR2 = reg << 17 | MCDR2_Rd;
+        mcpreg = reg << 17 | MCDR2_Rd;
+        __raw_writel(mcpreg, priv->mccr0_base + MCDR2);
 
         for (i = 0; i < 2; i++) {
                 udelay(mcp->rw_timeout);
-                if (Ser4MCSR & MCSR_CRC) {
-                        ret = Ser4MCDR2 & 0xffff;
+                mcpreg = __raw_readl(priv->mccr0_base + MCSR);
+                if (mcpreg & MCSR_CRC) {
+                        ret = __raw_readl(priv->mccr0_base + MCDR2)
+                                & 0xffff;
                         break;
                 }
         }
@@ -116,13 +133,19 @@ mcp_sa11x0_read(struct mcp *mcp, unsigned int reg)
 
 static void mcp_sa11x0_enable(struct mcp *mcp)
 {
-        Ser4MCSR = -1;
-        Ser4MCCR0 |= MCCR0_MCE;
+        struct mcp_sa11x0 *priv = priv(mcp);
+
+        __raw_writel(-1, priv->mccr0_base + MCSR);
+        priv->mccr0 |= MCCR0_MCE;
+        __raw_writel(priv->mccr0, priv->mccr0_base + MCCR0);
 }
 
 static void mcp_sa11x0_disable(struct mcp *mcp)
 {
-        Ser4MCCR0 &= ~MCCR0_MCE;
+        struct mcp_sa11x0 *priv = priv(mcp);
+
+        priv->mccr0 &= ~MCCR0_MCE;
+        __raw_writel(priv->mccr0, priv->mccr0_base + MCCR0);
 }
 
 /*
@@ -142,50 +165,69 @@ static int mcp_sa11x0_probe(struct platform_device *pdev)
         struct mcp_plat_data *data = pdev->dev.platform_data;
         struct mcp *mcp;
         int ret;
+        struct mcp_sa11x0 *priv;
+        struct resource *res_mem0, *res_mem1;
+        u32 size0, size1;
 
         if (!data)
                 return -ENODEV;
 
-        if (!request_mem_region(0x80060000, 0x60, "sa11x0-mcp"))
+        if (!data->codec)
+                return -ENODEV;
+
+        res_mem0 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res_mem0)
+                return -ENODEV;
+        size0 = res_mem0->end - res_mem0->start + 1;
+
+        res_mem1 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!res_mem1)
+                return -ENODEV;
+        size1 = res_mem1->end - res_mem1->start + 1;
+
+        if (!request_mem_region(res_mem0->start, size0, "sa11x0-mcp"))
                 return -EBUSY;
 
+        if (!request_mem_region(res_mem1->start, size1, "sa11x0-mcp")) {
+                ret = -EBUSY;
+                goto release;
+        }
+
         mcp = mcp_host_alloc(&pdev->dev, sizeof(struct mcp_sa11x0));
         if (!mcp) {
                 ret = -ENOMEM;
-                goto release;
+                goto release2;
         }
 
+        priv = priv(mcp);
+
         mcp->owner              = THIS_MODULE;
         mcp->ops                = &mcp_sa11x0;
         mcp->sclk_rate          = data->sclk_rate;
-        mcp->dma_audio_rd       = DMA_Ser4MCP0Rd;
-        mcp->dma_audio_wr       = DMA_Ser4MCP0Wr;
-        mcp->dma_telco_rd       = DMA_Ser4MCP1Rd;
-        mcp->dma_telco_wr       = DMA_Ser4MCP1Wr;
-        mcp->gpio_base          = data->gpio_base;
+        mcp->dma_audio_rd       = DDAR_DevAdd(res_mem0->start + MCDR0)
+                                + DDAR_DevRd + DDAR_Brst4 + DDAR_8BitDev;
+        mcp->dma_audio_wr       = DDAR_DevAdd(res_mem0->start + MCDR0)
+                                + DDAR_DevWr + DDAR_Brst4 + DDAR_8BitDev;
+        mcp->dma_telco_rd       = DDAR_DevAdd(res_mem0->start + MCDR1)
+                                + DDAR_DevRd + DDAR_Brst4 + DDAR_8BitDev;
+        mcp->dma_telco_wr       = DDAR_DevAdd(res_mem0->start + MCDR1)
+                                + DDAR_DevWr + DDAR_Brst4 + DDAR_8BitDev;
+        mcp->codec              = data->codec;
 
         platform_set_drvdata(pdev, mcp);
 
-        if (machine_is_assabet()) {
-                ASSABET_BCR_set(ASSABET_BCR_CODEC_RST);
-        }
-
-        /*
-         * Setup the PPC unit correctly.
-         */
-        PPDR &= ~PPC_RXD4;
-        PPDR |= PPC_TXD4 | PPC_SCLK | PPC_SFRM;
-        PSDR |= PPC_RXD4;
-        PSDR &= ~(PPC_TXD4 | PPC_SCLK | PPC_SFRM);
-        PPSR &= ~(PPC_TXD4 | PPC_SCLK | PPC_SFRM);
-
         /*
          * Initialise device.  Note that we initially
          * set the sampling rate to minimum.
          */
-        Ser4MCSR = -1;
-        Ser4MCCR1 = data->mccr1;
-        Ser4MCCR0 = data->mccr0 | 0x7f7f;
+        priv->mccr0_base = ioremap(res_mem0->start, size0);
+        priv->mccr1_base = ioremap(res_mem1->start, size1);
+
+        __raw_writel(-1, priv->mccr0_base + MCSR);
+        priv->mccr1 = data->mccr1;
+        priv->mccr0 = data->mccr0 | 0x7f7f;
+        __raw_writel(priv->mccr0, priv->mccr0_base + MCCR0);
+        __raw_writel(priv->mccr1, priv->mccr1_base + MCCR1);
 
         /*
          * Calculate the read/write timeout (us) from the bit clock
@@ -195,36 +237,53 @@ static int mcp_sa11x0_probe(struct platform_device *pdev)
         mcp->rw_timeout = (64 * 3 * 1000000 + mcp->sclk_rate - 1) /
                           mcp->sclk_rate;
 
-        ret = mcp_host_register(mcp);
+        ret = mcp_host_register(mcp, data->codec_pdata);
         if (ret == 0)
                 goto out;
 
+ release2:
+        release_mem_region(res_mem1->start, size1);
  release:
-        release_mem_region(0x80060000, 0x60);
+        release_mem_region(res_mem0->start, size0);
         platform_set_drvdata(pdev, NULL);
 
  out:
         return ret;
 }
 
-static int mcp_sa11x0_remove(struct platform_device *dev)
+static int mcp_sa11x0_remove(struct platform_device *pdev)
 {
-        struct mcp *mcp = platform_get_drvdata(dev);
+        struct mcp *mcp = platform_get_drvdata(pdev);
+        struct mcp_sa11x0 *priv = priv(mcp);
+        struct resource *res_mem;
+        u32 size;
 
-        platform_set_drvdata(dev, NULL);
+        platform_set_drvdata(pdev, NULL);
         mcp_host_unregister(mcp);
-        release_mem_region(0x80060000, 0x60);
 
+        res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res_mem) {
+                size = res_mem->end - res_mem->start + 1;
+                release_mem_region(res_mem->start, size);
+        }
+        res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (res_mem) {
+                size = res_mem->end - res_mem->start + 1;
+                release_mem_region(res_mem->start, size);
+        }
+        iounmap(priv->mccr0_base);
+        iounmap(priv->mccr1_base);
         return 0;
 }
 
 static int mcp_sa11x0_suspend(struct platform_device *dev, pm_message_t state)
 {
         struct mcp *mcp = platform_get_drvdata(dev);
+        struct mcp_sa11x0 *priv = priv(mcp);
+        u32 mccr0;
 
-        priv(mcp)->mccr0 = Ser4MCCR0;
-        priv(mcp)->mccr1 = Ser4MCCR1;
-        Ser4MCCR0 &= ~MCCR0_MCE;
+        mccr0 = priv->mccr0 & ~MCCR0_MCE;
+        __raw_writel(mccr0, priv->mccr0_base + MCCR0);
 
         return 0;
 }
@@ -232,9 +291,10 @@ static int mcp_sa11x0_suspend(struct platform_device *dev, pm_message_t state)
 static int mcp_sa11x0_resume(struct platform_device *dev)
 {
         struct mcp *mcp = platform_get_drvdata(dev);
+        struct mcp_sa11x0 *priv = priv(mcp);
 
-        Ser4MCCR1 = priv(mcp)->mccr1;
-        Ser4MCCR0 = priv(mcp)->mccr0;
+        __raw_writel(priv->mccr0, priv->mccr0_base + MCCR0);
+        __raw_writel(priv->mccr1, priv->mccr1_base + MCCR1);
 
         return 0;
 }
@@ -251,24 +311,14 @@ static struct platform_driver mcp_sa11x0_driver = {
         .resume         = mcp_sa11x0_resume,
         .driver         = {
                 .name   = "sa11x0-mcp",
+                .owner  = THIS_MODULE,
         },
 };
 
 /*
  * This needs re-working
  */
-static int __init mcp_sa11x0_init(void)
-{
-        return platform_driver_register(&mcp_sa11x0_driver);
-}
-
-static void __exit mcp_sa11x0_exit(void)
-{
-        platform_driver_unregister(&mcp_sa11x0_driver);
-}
-
-module_init(mcp_sa11x0_init);
-module_exit(mcp_sa11x0_exit);
+module_platform_driver(mcp_sa11x0_driver);
 
 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
 MODULE_DESCRIPTION("SA11x0 multimedia communications port driver");
diff --git a/drivers/mfd/omap-usb-host.c b/drivers/mfd/omap-usb-host.c
index 3f565ef3e149..68ac2c55d5ae 100644
--- a/drivers/mfd/omap-usb-host.c
+++ b/drivers/mfd/omap-usb-host.c
@@ -503,19 +503,13 @@ static void omap_usbhs_init(struct device *dev)
         spin_lock_irqsave(&omap->lock, flags);
 
         if (pdata->ehci_data->phy_reset) {
-                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[0])) {
-                        gpio_request(pdata->ehci_data->reset_gpio_port[0],
-                                                "USB1 PHY reset");
-                        gpio_direction_output
-                                (pdata->ehci_data->reset_gpio_port[0], 0);
-                }
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[0]))
+                        gpio_request_one(pdata->ehci_data->reset_gpio_port[0],
+                                         GPIOF_OUT_INIT_LOW, "USB1 PHY reset");
 
-                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[1])) {
-                        gpio_request(pdata->ehci_data->reset_gpio_port[1],
-                                                "USB2 PHY reset");
-                        gpio_direction_output
-                                (pdata->ehci_data->reset_gpio_port[1], 0);
-                }
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[1]))
+                        gpio_request_one(pdata->ehci_data->reset_gpio_port[1],
+                                         GPIOF_OUT_INIT_LOW, "USB2 PHY reset");
 
                 /* Hold the PHY in RESET for enough time till DIR is high */
                 udelay(10);
diff --git a/drivers/mfd/pcf50633-adc.c b/drivers/mfd/pcf50633-adc.c
index aed0d2a9b032..3927c17e4175 100644
--- a/drivers/mfd/pcf50633-adc.c
+++ b/drivers/mfd/pcf50633-adc.c
@@ -249,17 +249,7 @@ static struct platform_driver pcf50633_adc_driver = {
         .remove = __devexit_p(pcf50633_adc_remove),
 };
 
-static int __init pcf50633_adc_init(void)
-{
-        return platform_driver_register(&pcf50633_adc_driver);
-}
-module_init(pcf50633_adc_init);
-
-static void __exit pcf50633_adc_exit(void)
-{
-        platform_driver_unregister(&pcf50633_adc_driver);
-}
-module_exit(pcf50633_adc_exit);
+module_platform_driver(pcf50633_adc_driver);
 
 MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
 MODULE_DESCRIPTION("PCF50633 adc driver");
diff --git a/drivers/mfd/s5m-core.c b/drivers/mfd/s5m-core.c
new file mode 100644
index 000000000000..e075c113eec6
--- /dev/null
+++ b/drivers/mfd/s5m-core.c
@@ -0,0 +1,176 @@
+/*
+ * s5m87xx.c
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd
+ *              http://www.samsung.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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/pm_runtime.h>
+#include <linux/mutex.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/s5m87xx/s5m-core.h>
+#include <linux/mfd/s5m87xx/s5m-pmic.h>
+#include <linux/mfd/s5m87xx/s5m-rtc.h>
+#include <linux/regmap.h>
+
+static struct mfd_cell s5m87xx_devs[] = {
+        {
+                .name = "s5m8767-pmic",
+        }, {
+                .name = "s5m-rtc",
+        },
+};
+
+int s5m_reg_read(struct s5m87xx_dev *s5m87xx, u8 reg, void *dest)
+{
+        return regmap_read(s5m87xx->regmap, reg, dest);
+}
+EXPORT_SYMBOL_GPL(s5m_reg_read);
+
+int s5m_bulk_read(struct s5m87xx_dev *s5m87xx, u8 reg, int count, u8 *buf)
+{
+        return regmap_bulk_read(s5m87xx->regmap, reg, buf, count);;
+}
+EXPORT_SYMBOL_GPL(s5m_bulk_read);
+
+int s5m_reg_write(struct s5m87xx_dev *s5m87xx, u8 reg, u8 value)
+{
+        return regmap_write(s5m87xx->regmap, reg, value);
+}
+EXPORT_SYMBOL_GPL(s5m_reg_write);
+
+int s5m_bulk_write(struct s5m87xx_dev *s5m87xx, u8 reg, int count, u8 *buf)
+{
+        return regmap_raw_write(s5m87xx->regmap, reg, buf, count * sizeof(u16));
+}
+EXPORT_SYMBOL_GPL(s5m_bulk_write);
+
+int s5m_reg_update(struct s5m87xx_dev *s5m87xx, u8 reg, u8 val, u8 mask)
+{
+        return regmap_update_bits(s5m87xx->regmap, reg, mask, val);
+}
+EXPORT_SYMBOL_GPL(s5m_reg_update);
+
+static struct regmap_config s5m_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+};
+
+static int s5m87xx_i2c_probe(struct i2c_client *i2c,
+                            const struct i2c_device_id *id)
+{
+        struct s5m_platform_data *pdata = i2c->dev.platform_data;
+        struct s5m87xx_dev *s5m87xx;
+        int ret = 0;
+        int error;
+
+        s5m87xx = kzalloc(sizeof(struct s5m87xx_dev), GFP_KERNEL);
+        if (s5m87xx == NULL)
+                return -ENOMEM;
+
+        i2c_set_clientdata(i2c, s5m87xx);
+        s5m87xx->dev = &i2c->dev;
+        s5m87xx->i2c = i2c;
+        s5m87xx->irq = i2c->irq;
+        s5m87xx->type = id->driver_data;
+
+        if (pdata) {
+                s5m87xx->device_type = pdata->device_type;
+                s5m87xx->ono = pdata->ono;
+                s5m87xx->irq_base = pdata->irq_base;
+                s5m87xx->wakeup = pdata->wakeup;
+        }
+
+        s5m87xx->regmap = regmap_init_i2c(i2c, &s5m_regmap_config);
+        if (IS_ERR(s5m87xx->regmap)) {
+                error = PTR_ERR(s5m87xx->regmap);
+                dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
+                        error);
+                goto err;
+        }
+
+        s5m87xx->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR);
+        i2c_set_clientdata(s5m87xx->rtc, s5m87xx);
+
+        if (pdata->cfg_pmic_irq)
+                pdata->cfg_pmic_irq();
+
+        s5m_irq_init(s5m87xx);
+
+        pm_runtime_set_active(s5m87xx->dev);
+
+        ret = mfd_add_devices(s5m87xx->dev, -1,
+                                s5m87xx_devs, ARRAY_SIZE(s5m87xx_devs),
+                                NULL, 0);
+
+        if (ret < 0)
+                goto err;
+
+        return ret;
+
+err:
+        mfd_remove_devices(s5m87xx->dev);
+        s5m_irq_exit(s5m87xx);
+        i2c_unregister_device(s5m87xx->rtc);
+        regmap_exit(s5m87xx->regmap);
+        kfree(s5m87xx);
+        return ret;
+}
+
+static int s5m87xx_i2c_remove(struct i2c_client *i2c)
+{
+        struct s5m87xx_dev *s5m87xx = i2c_get_clientdata(i2c);
+
+        mfd_remove_devices(s5m87xx->dev);
+        s5m_irq_exit(s5m87xx);
+        i2c_unregister_device(s5m87xx->rtc);
+        regmap_exit(s5m87xx->regmap);
+        kfree(s5m87xx);
+        return 0;
+}
+
+static const struct i2c_device_id s5m87xx_i2c_id[] = {
+        { "s5m87xx", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, s5m87xx_i2c_id);
+
+static struct i2c_driver s5m87xx_i2c_driver = {
+        .driver = {
+                   .name = "s5m87xx",
+                   .owner = THIS_MODULE,
+        },
+        .probe = s5m87xx_i2c_probe,
+        .remove = s5m87xx_i2c_remove,
+        .id_table = s5m87xx_i2c_id,
+};
+
+static int __init s5m87xx_i2c_init(void)
+{
+        return i2c_add_driver(&s5m87xx_i2c_driver);
+}
+
+subsys_initcall(s5m87xx_i2c_init);
+
+static void __exit s5m87xx_i2c_exit(void)
+{
+        i2c_del_driver(&s5m87xx_i2c_driver);
+}
+module_exit(s5m87xx_i2c_exit);
+
+MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
+MODULE_DESCRIPTION("Core support for the S5M MFD");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/s5m-irq.c b/drivers/mfd/s5m-irq.c
new file mode 100644
index 000000000000..de76dfb6f0ad
--- /dev/null
+++ b/drivers/mfd/s5m-irq.c
@@ -0,0 +1,487 @@
+/*
+ * s5m-irq.c
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd
+ *              http://www.samsung.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.
+ *
+ */
+
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/mfd/s5m87xx/s5m-core.h>
+
+struct s5m_irq_data {
+        int reg;
+        int mask;
+};
+
+static struct s5m_irq_data s5m8767_irqs[] = {
+        [S5M8767_IRQ_PWRR] = {
+                .reg = 1,
+                .mask = S5M8767_IRQ_PWRR_MASK,
+        },
+        [S5M8767_IRQ_PWRF] = {
+                .reg = 1,
+                .mask = S5M8767_IRQ_PWRF_MASK,
+        },
+        [S5M8767_IRQ_PWR1S] = {
+                .reg = 1,
+                .mask = S5M8767_IRQ_PWR1S_MASK,
+        },
+        [S5M8767_IRQ_JIGR] = {
+                .reg = 1,
+                .mask = S5M8767_IRQ_JIGR_MASK,
+        },
+        [S5M8767_IRQ_JIGF] = {
+                .reg = 1,
+                .mask = S5M8767_IRQ_JIGF_MASK,
+        },
+        [S5M8767_IRQ_LOWBAT2] = {
+                .reg = 1,
+                .mask = S5M8767_IRQ_LOWBAT2_MASK,
+        },
+        [S5M8767_IRQ_LOWBAT1] = {
+                .reg = 1,
+                .mask = S5M8767_IRQ_LOWBAT1_MASK,
+        },
+        [S5M8767_IRQ_MRB] = {
+                .reg = 2,
+                .mask = S5M8767_IRQ_MRB_MASK,
+        },
+        [S5M8767_IRQ_DVSOK2] = {
+                .reg = 2,
+                .mask = S5M8767_IRQ_DVSOK2_MASK,
+        },
+        [S5M8767_IRQ_DVSOK3] = {
+                .reg = 2,
+                .mask = S5M8767_IRQ_DVSOK3_MASK,
+        },
+        [S5M8767_IRQ_DVSOK4] = {
+                .reg = 2,
+                .mask = S5M8767_IRQ_DVSOK4_MASK,
+        },
+        [S5M8767_IRQ_RTC60S] = {
+                .reg = 3,
+                .mask = S5M8767_IRQ_RTC60S_MASK,
+        },
+        [S5M8767_IRQ_RTCA1] = {
+                .reg = 3,
+                .mask = S5M8767_IRQ_RTCA1_MASK,
+        },
+        [S5M8767_IRQ_RTCA2] = {
+                .reg = 3,
+                .mask = S5M8767_IRQ_RTCA2_MASK,
+        },
+        [S5M8767_IRQ_SMPL] = {
+                .reg = 3,
+                .mask = S5M8767_IRQ_SMPL_MASK,
+        },
+        [S5M8767_IRQ_RTC1S] = {
+                .reg = 3,
+                .mask = S5M8767_IRQ_RTC1S_MASK,
+        },
+        [S5M8767_IRQ_WTSR] = {
+                .reg = 3,
+                .mask = S5M8767_IRQ_WTSR_MASK,
+        },
+};
+
+static struct s5m_irq_data s5m8763_irqs[] = {
+        [S5M8763_IRQ_DCINF] = {
+                .reg = 1,
+                .mask = S5M8763_IRQ_DCINF_MASK,
+        },
+        [S5M8763_IRQ_DCINR] = {
+                .reg = 1,
+                .mask = S5M8763_IRQ_DCINR_MASK,
+        },
+        [S5M8763_IRQ_JIGF] = {
+                .reg = 1,
+                .mask = S5M8763_IRQ_JIGF_MASK,
+        },
+        [S5M8763_IRQ_JIGR] = {
+                .reg = 1,
+                .mask = S5M8763_IRQ_JIGR_MASK,
+        },
+        [S5M8763_IRQ_PWRONF] = {
+                .reg = 1,
+                .mask = S5M8763_IRQ_PWRONF_MASK,
+        },
+        [S5M8763_IRQ_PWRONR] = {
+                .reg = 1,
+                .mask = S5M8763_IRQ_PWRONR_MASK,
+        },
+        [S5M8763_IRQ_WTSREVNT] = {
+                .reg = 2,
+                .mask = S5M8763_IRQ_WTSREVNT_MASK,
+        },
+        [S5M8763_IRQ_SMPLEVNT] = {
+                .reg = 2,
+                .mask = S5M8763_IRQ_SMPLEVNT_MASK,
+        },
+        [S5M8763_IRQ_ALARM1] = {
+                .reg = 2,
+                .mask = S5M8763_IRQ_ALARM1_MASK,
+        },
+        [S5M8763_IRQ_ALARM0] = {
+                .reg = 2,
+                .mask = S5M8763_IRQ_ALARM0_MASK,
+        },
+        [S5M8763_IRQ_ONKEY1S] = {
+                .reg = 3,
+                .mask = S5M8763_IRQ_ONKEY1S_MASK,
+        },
+        [S5M8763_IRQ_TOPOFFR] = {
+                .reg = 3,
+                .mask = S5M8763_IRQ_TOPOFFR_MASK,
+        },
+        [S5M8763_IRQ_DCINOVPR] = {
+                .reg = 3,
+                .mask = S5M8763_IRQ_DCINOVPR_MASK,
+        },
+        [S5M8763_IRQ_CHGRSTF] = {
+                .reg = 3,
+                .mask = S5M8763_IRQ_CHGRSTF_MASK,
+        },
+        [S5M8763_IRQ_DONER] = {
+                .reg = 3,
+                .mask = S5M8763_IRQ_DONER_MASK,
+        },
+        [S5M8763_IRQ_CHGFAULT] = {
+                .reg = 3,
+                .mask = S5M8763_IRQ_CHGFAULT_MASK,
+        },
+        [S5M8763_IRQ_LOBAT1] = {
+                .reg = 4,
+                .mask = S5M8763_IRQ_LOBAT1_MASK,
+        },
+        [S5M8763_IRQ_LOBAT2] = {
+                .reg = 4,
+                .mask = S5M8763_IRQ_LOBAT2_MASK,
+        },
+};
+
+static inline struct s5m_irq_data *
+irq_to_s5m8767_irq(struct s5m87xx_dev *s5m87xx, int irq)
+{
+        return &s5m8767_irqs[irq - s5m87xx->irq_base];
+}
+
+static void s5m8767_irq_lock(struct irq_data *data)
+{
+        struct s5m87xx_dev *s5m87xx = irq_data_get_irq_chip_data(data);
+
+        mutex_lock(&s5m87xx->irqlock);
+}
+
+static void s5m8767_irq_sync_unlock(struct irq_data *data)
+{
+        struct s5m87xx_dev *s5m87xx = irq_data_get_irq_chip_data(data);
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(s5m87xx->irq_masks_cur); i++) {
+                if (s5m87xx->irq_masks_cur[i] != s5m87xx->irq_masks_cache[i]) {
+                        s5m87xx->irq_masks_cache[i] = s5m87xx->irq_masks_cur[i];
+                        s5m_reg_write(s5m87xx, S5M8767_REG_INT1M + i,
+                                        s5m87xx->irq_masks_cur[i]);
+                }
+        }
+
+        mutex_unlock(&s5m87xx->irqlock);
+}
+
+static void s5m8767_irq_unmask(struct irq_data *data)
+{
+        struct s5m87xx_dev *s5m87xx = irq_data_get_irq_chip_data(data);
+        struct s5m_irq_data *irq_data = irq_to_s5m8767_irq(s5m87xx,
+                                                               data->irq);
+
+        s5m87xx->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask;
+}
+
+static void s5m8767_irq_mask(struct irq_data *data)
+{
+        struct s5m87xx_dev *s5m87xx = irq_data_get_irq_chip_data(data);
+        struct s5m_irq_data *irq_data = irq_to_s5m8767_irq(s5m87xx,
+                                                               data->irq);
+
+        s5m87xx->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask;
+}
+
+static struct irq_chip s5m8767_irq_chip = {
+        .name = "s5m8767",
+        .irq_bus_lock = s5m8767_irq_lock,
+        .irq_bus_sync_unlock = s5m8767_irq_sync_unlock,
+        .irq_mask = s5m8767_irq_mask,
+        .irq_unmask = s5m8767_irq_unmask,
+};
+
+static inline struct s5m_irq_data *
+irq_to_s5m8763_irq(struct s5m87xx_dev *s5m87xx, int irq)
+{
+        return &s5m8763_irqs[irq - s5m87xx->irq_base];
+}
+
+static void s5m8763_irq_lock(struct irq_data *data)
+{
+        struct s5m87xx_dev *s5m87xx = irq_data_get_irq_chip_data(data);
+
+        mutex_lock(&s5m87xx->irqlock);
+}
+
+static void s5m8763_irq_sync_unlock(struct irq_data *data)
+{
+        struct s5m87xx_dev *s5m87xx = irq_data_get_irq_chip_data(data);
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(s5m87xx->irq_masks_cur); i++) {
+                if (s5m87xx->irq_masks_cur[i] != s5m87xx->irq_masks_cache[i]) {
+                        s5m87xx->irq_masks_cache[i] = s5m87xx->irq_masks_cur[i];
+                        s5m_reg_write(s5m87xx, S5M8763_REG_IRQM1 + i,
+                                        s5m87xx->irq_masks_cur[i]);
+                }
+        }
+
+        mutex_unlock(&s5m87xx->irqlock);
+}
+
+static void s5m8763_irq_unmask(struct irq_data *data)
+{
+        struct s5m87xx_dev *s5m87xx = irq_data_get_irq_chip_data(data);
+        struct s5m_irq_data *irq_data = irq_to_s5m8763_irq(s5m87xx,
+                                                               data->irq);
+
+        s5m87xx->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask;
+}
+
+static void s5m8763_irq_mask(struct irq_data *data)
+{
+        struct s5m87xx_dev *s5m87xx = irq_data_get_irq_chip_data(data);
+        struct s5m_irq_data *irq_data = irq_to_s5m8763_irq(s5m87xx,
+                                                               data->irq);
+
+        s5m87xx->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask;
+}
+
+static struct irq_chip s5m8763_irq_chip = {
+        .name = "s5m8763",
+        .irq_bus_lock = s5m8763_irq_lock,
+        .irq_bus_sync_unlock = s5m8763_irq_sync_unlock,
+        .irq_mask = s5m8763_irq_mask,
+        .irq_unmask = s5m8763_irq_unmask,
+};
+
+
+static irqreturn_t s5m8767_irq_thread(int irq, void *data)
+{
+        struct s5m87xx_dev *s5m87xx = data;
+        u8 irq_reg[NUM_IRQ_REGS-1];
+        int ret;
+        int i;
+
+
+        ret = s5m_bulk_read(s5m87xx, S5M8767_REG_INT1,
+                                NUM_IRQ_REGS - 1, irq_reg);
+        if (ret < 0) {
+                dev_err(s5m87xx->dev, "Failed to read interrupt register: %d\n",
+                                ret);
+                return IRQ_NONE;
+        }
+
+        for (i = 0; i < NUM_IRQ_REGS - 1; i++)
+                irq_reg[i] &= ~s5m87xx->irq_masks_cur[i];
+
+        for (i = 0; i < S5M8767_IRQ_NR; i++) {
+                if (irq_reg[s5m8767_irqs[i].reg - 1] & s5m8767_irqs[i].mask)
+                        handle_nested_irq(s5m87xx->irq_base + i);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t s5m8763_irq_thread(int irq, void *data)
+{
+        struct s5m87xx_dev *s5m87xx = data;
+        u8 irq_reg[NUM_IRQ_REGS];
+        int ret;
+        int i;
+
+        ret = s5m_bulk_read(s5m87xx, S5M8763_REG_IRQ1,
+                                NUM_IRQ_REGS, irq_reg);
+        if (ret < 0) {
+                dev_err(s5m87xx->dev, "Failed to read interrupt register: %d\n",
+                                ret);
+                return IRQ_NONE;
+        }
+
+        for (i = 0; i < NUM_IRQ_REGS; i++)
+                irq_reg[i] &= ~s5m87xx->irq_masks_cur[i];
+
+        for (i = 0; i < S5M8763_IRQ_NR; i++) {
+                if (irq_reg[s5m8763_irqs[i].reg - 1] & s5m8763_irqs[i].mask)
+                        handle_nested_irq(s5m87xx->irq_base + i);
+        }
+
+        return IRQ_HANDLED;
+}
+
+int s5m_irq_resume(struct s5m87xx_dev *s5m87xx)
+{
+        if (s5m87xx->irq && s5m87xx->irq_base){
+                switch (s5m87xx->device_type) {
+                case S5M8763X:
+                        s5m8763_irq_thread(s5m87xx->irq_base, s5m87xx);
+                        break;
+                case S5M8767X:
+                        s5m8767_irq_thread(s5m87xx->irq_base, s5m87xx);
+                        break;
+                default:
+                        break;
+
+                }
+        }
+        return 0;
+}
+
+int s5m_irq_init(struct s5m87xx_dev *s5m87xx)
+{
+        int i;
+        int cur_irq;
+        int ret = 0;
+        int type = s5m87xx->device_type;
+
+        if (!s5m87xx->irq) {
+                dev_warn(s5m87xx->dev,
+                         "No interrupt specified, no interrupts\n");
+                s5m87xx->irq_base = 0;
+                return 0;
+        }
+
+        if (!s5m87xx->irq_base) {
+                dev_err(s5m87xx->dev,
+                        "No interrupt base specified, no interrupts\n");
+                return 0;
+        }
+
+        mutex_init(&s5m87xx->irqlock);
+
+        switch (type) {
+        case S5M8763X:
+                for (i = 0; i < NUM_IRQ_REGS; i++) {
+                        s5m87xx->irq_masks_cur[i] = 0xff;
+                        s5m87xx->irq_masks_cache[i] = 0xff;
+                        s5m_reg_write(s5m87xx, S5M8763_REG_IRQM1 + i,
+                                                0xff);
+                }
+
+                s5m_reg_write(s5m87xx, S5M8763_REG_STATUSM1, 0xff);
+                s5m_reg_write(s5m87xx, S5M8763_REG_STATUSM2, 0xff);
+
+                for (i = 0; i < S5M8763_IRQ_NR; i++) {
+                        cur_irq = i + s5m87xx->irq_base;
+                        irq_set_chip_data(cur_irq, s5m87xx);
+                        irq_set_chip_and_handler(cur_irq, &s5m8763_irq_chip,
+                                                 handle_edge_irq);
+                        irq_set_nested_thread(cur_irq, 1);
+#ifdef CONFIG_ARM
+                        set_irq_flags(cur_irq, IRQF_VALID);
+#else
+                        irq_set_noprobe(cur_irq);
+#endif
+                }
+
+                ret = request_threaded_irq(s5m87xx->irq, NULL,
+                                        s5m8763_irq_thread,
+                                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                        "s5m87xx-irq", s5m87xx);
+                if (ret) {
+                        dev_err(s5m87xx->dev, "Failed to request IRQ %d: %d\n",
+                                s5m87xx->irq, ret);
+                        return ret;
+                }
+                break;
+        case S5M8767X:
+                for (i = 0; i < NUM_IRQ_REGS - 1; i++) {
+                        s5m87xx->irq_masks_cur[i] = 0xff;
+                        s5m87xx->irq_masks_cache[i] = 0xff;
+                        s5m_reg_write(s5m87xx, S5M8767_REG_INT1M + i,
+                                                0xff);
+                }
+                for (i = 0; i < S5M8767_IRQ_NR; i++) {
+                        cur_irq = i + s5m87xx->irq_base;
+                        irq_set_chip_data(cur_irq, s5m87xx);
+                        if (ret) {
+                                dev_err(s5m87xx->dev,
+                                        "Failed to irq_set_chip_data %d: %d\n",
+                                        s5m87xx->irq, ret);
+                                return ret;
+                        }
+
+                        irq_set_chip_and_handler(cur_irq, &s5m8767_irq_chip,
+                                                 handle_edge_irq);
+                        irq_set_nested_thread(cur_irq, 1);
+#ifdef CONFIG_ARM
+                        set_irq_flags(cur_irq, IRQF_VALID);
+#else
+                        irq_set_noprobe(cur_irq);
+#endif
+                }
+
+                ret = request_threaded_irq(s5m87xx->irq, NULL,
+                                           s5m8767_irq_thread,
+                                           IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                           "s5m87xx-irq", s5m87xx);
+                if (ret) {
+                        dev_err(s5m87xx->dev, "Failed to request IRQ %d: %d\n",
+                                s5m87xx->irq, ret);
+                        return ret;
+                }
+                break;
+        default:
+                break;
+        }
+
+        if (!s5m87xx->ono)
+                return 0;
+
+        switch (type) {
+        case S5M8763X:
+                ret = request_threaded_irq(s5m87xx->ono, NULL,
+                                                s5m8763_irq_thread,
+                                                IRQF_TRIGGER_FALLING |
+                                                IRQF_TRIGGER_RISING |
+                                                IRQF_ONESHOT, "s5m87xx-ono",
+                                                s5m87xx);
+                break;
+        case S5M8767X:
+                ret = request_threaded_irq(s5m87xx->ono, NULL,
+                                        s5m8767_irq_thread,
+                                        IRQF_TRIGGER_FALLING |
+                                        IRQF_TRIGGER_RISING |
+                                        IRQF_ONESHOT, "s5m87xx-ono", s5m87xx);
+                break;
+        default:
+                break;
+        }
+
+        if (ret)
+                dev_err(s5m87xx->dev, "Failed to request IRQ %d: %d\n",
+                        s5m87xx->ono, ret);
+
+        return 0;
+}
+
+void s5m_irq_exit(struct s5m87xx_dev *s5m87xx)
+{
+        if (s5m87xx->ono)
+                free_irq(s5m87xx->ono, s5m87xx);
+
+        if (s5m87xx->irq)
+                free_irq(s5m87xx->irq, s5m87xx);
+}
diff --git a/drivers/mfd/sm501.c b/drivers/mfd/sm501.c
index df3702c1756d..f4d86117f44a 100644
--- a/drivers/mfd/sm501.c
+++ b/drivers/mfd/sm501.c
@@ -1720,7 +1720,7 @@ static int sm501_plat_remove(struct platform_device *dev)
         return 0;
 }
 
-static struct pci_device_id sm501_pci_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(sm501_pci_tbl) = {
         { 0x126f, 0x0501, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
         { 0, },
 };
diff --git a/drivers/mfd/stmpe-i2c.c b/drivers/mfd/stmpe-i2c.c
new file mode 100644
index 000000000000..373f423b1181
--- /dev/null
+++ b/drivers/mfd/stmpe-i2c.c
@@ -0,0 +1,109 @@
+/*
+ * ST Microelectronics MFD: stmpe's i2c client specific driver
+ *
+ * Copyright (C) ST-Ericsson SA 2010
+ * Copyright (C) ST Microelectronics SA 2011
+ *
+ * License Terms: GNU General Public License, version 2
+ * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
+ * Author: Viresh Kumar <viresh.kumar@st.com> for ST Microelectronics
+ */
+
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include "stmpe.h"
+
+static int i2c_reg_read(struct stmpe *stmpe, u8 reg)
+{
+        struct i2c_client *i2c = stmpe->client;
+
+        return i2c_smbus_read_byte_data(i2c, reg);
+}
+
+static int i2c_reg_write(struct stmpe *stmpe, u8 reg, u8 val)
+{
+        struct i2c_client *i2c = stmpe->client;
+
+        return i2c_smbus_write_byte_data(i2c, reg, val);
+}
+
+static int i2c_block_read(struct stmpe *stmpe, u8 reg, u8 length, u8 *values)
+{
+        struct i2c_client *i2c = stmpe->client;
+
+        return i2c_smbus_read_i2c_block_data(i2c, reg, length, values);
+}
+
+static int i2c_block_write(struct stmpe *stmpe, u8 reg, u8 length,
+                const u8 *values)
+{
+        struct i2c_client *i2c = stmpe->client;
+
+        return i2c_smbus_write_i2c_block_data(i2c, reg, length, values);
+}
+
+static struct stmpe_client_info i2c_ci = {
+        .read_byte = i2c_reg_read,
+        .write_byte = i2c_reg_write,
+        .read_block = i2c_block_read,
+        .write_block = i2c_block_write,
+};
+
+static int __devinit
+stmpe_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
+{
+        i2c_ci.data = (void *)id;
+        i2c_ci.irq = i2c->irq;
+        i2c_ci.client = i2c;
+        i2c_ci.dev = &i2c->dev;
+
+        return stmpe_probe(&i2c_ci, id->driver_data);
+}
+
+static int __devexit stmpe_i2c_remove(struct i2c_client *i2c)
+{
+        struct stmpe *stmpe = dev_get_drvdata(&i2c->dev);
+
+        return stmpe_remove(stmpe);
+}
+
+static const struct i2c_device_id stmpe_i2c_id[] = {
+        { "stmpe610", STMPE610 },
+        { "stmpe801", STMPE801 },
+        { "stmpe811", STMPE811 },
+        { "stmpe1601", STMPE1601 },
+        { "stmpe2401", STMPE2401 },
+        { "stmpe2403", STMPE2403 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, stmpe_id);
+
+static struct i2c_driver stmpe_i2c_driver = {
+        .driver.name    = "stmpe-i2c",
+        .driver.owner   = THIS_MODULE,
+#ifdef CONFIG_PM
+        .driver.pm      = &stmpe_dev_pm_ops,
+#endif
+        .probe          = stmpe_i2c_probe,
+        .remove         = __devexit_p(stmpe_i2c_remove),
+        .id_table       = stmpe_i2c_id,
+};
+
+static int __init stmpe_init(void)
+{
+        return i2c_add_driver(&stmpe_i2c_driver);
+}
+subsys_initcall(stmpe_init);
+
+static void __exit stmpe_exit(void)
+{
+        i2c_del_driver(&stmpe_i2c_driver);
+}
+module_exit(stmpe_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("STMPE MFD I2C Interface Driver");
+MODULE_AUTHOR("Rabin Vincent <rabin.vincent@stericsson.com>");
diff --git a/drivers/mfd/stmpe-spi.c b/drivers/mfd/stmpe-spi.c
new file mode 100644
index 000000000000..b58c43c7ea93
--- /dev/null
+++ b/drivers/mfd/stmpe-spi.c
@@ -0,0 +1,150 @@
+/*
+ * ST Microelectronics MFD: stmpe's spi client specific driver
+ *
+ * Copyright (C) ST Microelectronics SA 2011
+ *
+ * License Terms: GNU General Public License, version 2
+ * Author: Viresh Kumar <viresh.kumar@st.com> for ST Microelectronics
+ */
+
+#include <linux/spi/spi.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include "stmpe.h"
+
+#define READ_CMD        (1 << 7)
+
+static int spi_reg_read(struct stmpe *stmpe, u8 reg)
+{
+        struct spi_device *spi = stmpe->client;
+        int status = spi_w8r16(spi, reg | READ_CMD);
+
+        return (status < 0) ? status : status >> 8;
+}
+
+static int spi_reg_write(struct stmpe *stmpe, u8 reg, u8 val)
+{
+        struct spi_device *spi = stmpe->client;
+        u16 cmd = (val << 8) | reg;
+
+        return spi_write(spi, (const u8 *)&cmd, 2);
+}
+
+static int spi_block_read(struct stmpe *stmpe, u8 reg, u8 length, u8 *values)
+{
+        int ret, i;
+
+        for (i = 0; i < length; i++) {
+                ret = spi_reg_read(stmpe, reg + i);
+                if (ret < 0)
+                        return ret;
+                *(values + i) = ret;
+        }
+
+        return 0;
+}
+
+static int spi_block_write(struct stmpe *stmpe, u8 reg, u8 length,
+                const u8 *values)
+{
+        int ret = 0, i;
+
+        for (i = length; i > 0; i--, reg++) {
+                ret = spi_reg_write(stmpe, reg, *(values + i - 1));
+                if (ret < 0)
+                        return ret;
+        }
+
+        return ret;
+}
+
+static void spi_init(struct stmpe *stmpe)
+{
+        struct spi_device *spi = stmpe->client;
+
+        spi->bits_per_word = 8;
+
+        /* This register is only present for stmpe811 */
+        if (stmpe->variant->id_val == 0x0811)
+                spi_reg_write(stmpe, STMPE811_REG_SPI_CFG, spi->mode);
+
+        if (spi_setup(spi) < 0)
+                dev_dbg(&spi->dev, "spi_setup failed\n");
+}
+
+static struct stmpe_client_info spi_ci = {
+        .read_byte = spi_reg_read,
+        .write_byte = spi_reg_write,
+        .read_block = spi_block_read,
+        .write_block = spi_block_write,
+        .init = spi_init,
+};
+
+static int __devinit
+stmpe_spi_probe(struct spi_device *spi)
+{
+        const struct spi_device_id *id = spi_get_device_id(spi);
+
+        /* don't exceed max specified rate - 1MHz - Limitation of STMPE */
+        if (spi->max_speed_hz > 1000000) {
+                dev_dbg(&spi->dev, "f(sample) %d KHz?\n",
+                                (spi->max_speed_hz/1000));
+                return -EINVAL;
+        }
+
+        spi_ci.irq = spi->irq;
+        spi_ci.client = spi;
+        spi_ci.dev = &spi->dev;
+
+        return stmpe_probe(&spi_ci, id->driver_data);
+}
+
+static int __devexit stmpe_spi_remove(struct spi_device *spi)
+{
+        struct stmpe *stmpe = dev_get_drvdata(&spi->dev);
+
+        return stmpe_remove(stmpe);
+}
+
+static const struct spi_device_id stmpe_spi_id[] = {
+        { "stmpe610", STMPE610 },
+        { "stmpe801", STMPE801 },
+        { "stmpe811", STMPE811 },
+        { "stmpe1601", STMPE1601 },
+        { "stmpe2401", STMPE2401 },
+        { "stmpe2403", STMPE2403 },
+        { }
+};
+MODULE_DEVICE_TABLE(spi, stmpe_id);
+
+static struct spi_driver stmpe_spi_driver = {
+        .driver = {
+                .name   = "stmpe-spi",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &stmpe_dev_pm_ops,
+#endif
+        },
+        .probe          = stmpe_spi_probe,
+        .remove         = __devexit_p(stmpe_spi_remove),
+        .id_table       = stmpe_spi_id,
+};
+
+static int __init stmpe_init(void)
+{
+        return spi_register_driver(&stmpe_spi_driver);
+}
+subsys_initcall(stmpe_init);
+
+static void __exit stmpe_exit(void)
+{
+        spi_unregister_driver(&stmpe_spi_driver);
+}
+module_exit(stmpe_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("STMPE MFD SPI Interface Driver");
+MODULE_AUTHOR("Viresh Kumar <viresh.kumar@st.com>");
diff --git a/drivers/mfd/stmpe.c b/drivers/mfd/stmpe.c
index 2963689cf45c..e07947e56b2a 100644
--- a/drivers/mfd/stmpe.c
+++ b/drivers/mfd/stmpe.c
@@ -1,18 +1,20 @@
 /*
+ * ST Microelectronics MFD: stmpe's driver
+ *
  * Copyright (C) ST-Ericsson SA 2010
  *
  * License Terms: GNU General Public License, version 2
  * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
  */
 
+#include <linux/gpio.h>
+#include <linux/export.h>
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
+#include <linux/pm.h>
 #include <linux/slab.h>
-#include <linux/i2c.h>
 #include <linux/mfd/core.h>
-#include <linux/mfd/stmpe.h>
 #include "stmpe.h"
 
 static int __stmpe_enable(struct stmpe *stmpe, unsigned int blocks)
@@ -29,10 +31,9 @@ static int __stmpe_reg_read(struct stmpe *stmpe, u8 reg)
 {
         int ret;
 
-        ret = i2c_smbus_read_byte_data(stmpe->i2c, reg);
+        ret = stmpe->ci->read_byte(stmpe, reg);
         if (ret < 0)
-                dev_err(stmpe->dev, "failed to read reg %#x: %d\n",
-                        reg, ret);
+                dev_err(stmpe->dev, "failed to read reg %#x: %d\n", reg, ret);
 
         dev_vdbg(stmpe->dev, "rd: reg %#x => data %#x\n", reg, ret);
 
@@ -45,10 +46,9 @@ static int __stmpe_reg_write(struct stmpe *stmpe, u8 reg, u8 val)
 
         dev_vdbg(stmpe->dev, "wr: reg %#x <= %#x\n", reg, val);
 
-        ret = i2c_smbus_write_byte_data(stmpe->i2c, reg, val);
+        ret = stmpe->ci->write_byte(stmpe, reg, val);
         if (ret < 0)
-                dev_err(stmpe->dev, "failed to write reg %#x: %d\n",
-                        reg, ret);
+                dev_err(stmpe->dev, "failed to write reg %#x: %d\n", reg, ret);
 
         return ret;
 }
@@ -72,10 +72,9 @@ static int __stmpe_block_read(struct stmpe *stmpe, u8 reg, u8 length,
 {
         int ret;
 
-        ret = i2c_smbus_read_i2c_block_data(stmpe->i2c, reg, length, values);
+        ret = stmpe->ci->read_block(stmpe, reg, length, values);
         if (ret < 0)
-                dev_err(stmpe->dev, "failed to read regs %#x: %d\n",
-                        reg, ret);
+                dev_err(stmpe->dev, "failed to read regs %#x: %d\n", reg, ret);
 
         dev_vdbg(stmpe->dev, "rd: reg %#x (%d) => ret %#x\n", reg, length, ret);
         stmpe_dump_bytes("stmpe rd: ", values, length);
@@ -91,11 +90,9 @@ static int __stmpe_block_write(struct stmpe *stmpe, u8 reg, u8 length,
         dev_vdbg(stmpe->dev, "wr: regs %#x (%d)\n", reg, length);
         stmpe_dump_bytes("stmpe wr: ", values, length);
 
-        ret = i2c_smbus_write_i2c_block_data(stmpe->i2c, reg, length,
-                                             values);
+        ret = stmpe->ci->write_block(stmpe, reg, length, values);
         if (ret < 0)
-                dev_err(stmpe->dev, "failed to write regs %#x: %d\n",
-                        reg, ret);
+                dev_err(stmpe->dev, "failed to write regs %#x: %d\n", reg, ret);
 
         return ret;
 }
@@ -245,12 +242,14 @@ int stmpe_set_altfunc(struct stmpe *stmpe, u32 pins, enum stmpe_block block)
         u8 regaddr = stmpe->regs[STMPE_IDX_GPAFR_U_MSB];
         int af_bits = variant->af_bits;
         int numregs = DIV_ROUND_UP(stmpe->num_gpios * af_bits, 8);
-        int afperreg = 8 / af_bits;
         int mask = (1 << af_bits) - 1;
         u8 regs[numregs];
-        int af;
-        int ret;
+        int af, afperreg, ret;
+
+        if (!variant->get_altfunc)
+                return 0;
 
+        afperreg = 8 / af_bits;
         mutex_lock(&stmpe->lock);
 
         ret = __stmpe_enable(stmpe, STMPE_BLOCK_GPIO);
@@ -325,7 +324,51 @@ static struct mfd_cell stmpe_keypad_cell = {
 };
 
 /*
- * Touchscreen (STMPE811)
+ * STMPE801
+ */
+static const u8 stmpe801_regs[] = {
+        [STMPE_IDX_CHIP_ID]     = STMPE801_REG_CHIP_ID,
+        [STMPE_IDX_ICR_LSB]     = STMPE801_REG_SYS_CTRL,
+        [STMPE_IDX_GPMR_LSB]    = STMPE801_REG_GPIO_MP_STA,
+        [STMPE_IDX_GPSR_LSB]    = STMPE801_REG_GPIO_SET_PIN,
+        [STMPE_IDX_GPCR_LSB]    = STMPE801_REG_GPIO_SET_PIN,
+        [STMPE_IDX_GPDR_LSB]    = STMPE801_REG_GPIO_DIR,
+        [STMPE_IDX_IEGPIOR_LSB] = STMPE801_REG_GPIO_INT_EN,
+        [STMPE_IDX_ISGPIOR_MSB] = STMPE801_REG_GPIO_INT_STA,
+
+};
+
+static struct stmpe_variant_block stmpe801_blocks[] = {
+        {
+                .cell   = &stmpe_gpio_cell,
+                .irq    = 0,
+                .block  = STMPE_BLOCK_GPIO,
+        },
+};
+
+static int stmpe801_enable(struct stmpe *stmpe, unsigned int blocks,
+                           bool enable)
+{
+        if (blocks & STMPE_BLOCK_GPIO)
+                return 0;
+        else
+                return -EINVAL;
+}
+
+static struct stmpe_variant_info stmpe801 = {
+        .name           = "stmpe801",
+        .id_val         = STMPE801_ID,
+        .id_mask        = 0xffff,
+        .num_gpios      = 8,
+        .regs           = stmpe801_regs,
+        .blocks         = stmpe801_blocks,
+        .num_blocks     = ARRAY_SIZE(stmpe801_blocks),
+        .num_irqs       = STMPE801_NR_INTERNAL_IRQS,
+        .enable         = stmpe801_enable,
+};
+
+/*
+ * Touchscreen (STMPE811 or STMPE610)
  */
 
 static struct resource stmpe_ts_resources[] = {
@@ -350,7 +393,7 @@ static struct mfd_cell stmpe_ts_cell = {
 };
 
 /*
- * STMPE811
+ * STMPE811 or STMPE610
  */
 
 static const u8 stmpe811_regs[] = {
@@ -421,6 +464,21 @@ static struct stmpe_variant_info stmpe811 = {
         .get_altfunc    = stmpe811_get_altfunc,
 };
 
+/* Similar to 811, except number of gpios */
+static struct stmpe_variant_info stmpe610 = {
+        .name           = "stmpe610",
+        .id_val         = 0x0811,
+        .id_mask        = 0xffff,
+        .num_gpios      = 6,
+        .af_bits        = 1,
+        .regs           = stmpe811_regs,
+        .blocks         = stmpe811_blocks,
+        .num_blocks     = ARRAY_SIZE(stmpe811_blocks),
+        .num_irqs       = STMPE811_NR_INTERNAL_IRQS,
+        .enable         = stmpe811_enable,
+        .get_altfunc    = stmpe811_get_altfunc,
+};
+
 /*
  * STMPE1601
  */
@@ -655,6 +713,8 @@ static struct stmpe_variant_info stmpe2403 = {
 };
 
 static struct stmpe_variant_info *stmpe_variant_info[] = {
+        [STMPE610]      = &stmpe610,
+        [STMPE801]      = &stmpe801,
         [STMPE811]      = &stmpe811,
         [STMPE1601]     = &stmpe1601,
         [STMPE2401]     = &stmpe2401,
@@ -671,6 +731,11 @@ static irqreturn_t stmpe_irq(int irq, void *data)
         int ret;
         int i;
 
+        if (variant->id_val == STMPE801_ID) {
+                handle_nested_irq(stmpe->irq_base);
+                return IRQ_HANDLED;
+        }
+
         ret = stmpe_block_read(stmpe, israddr, num, isr);
         if (ret < 0)
                 return IRQ_NONE;
@@ -757,14 +822,17 @@ static struct irq_chip stmpe_irq_chip = {
 
 static int __devinit stmpe_irq_init(struct stmpe *stmpe)
 {
+        struct irq_chip *chip = NULL;
         int num_irqs = stmpe->variant->num_irqs;
         int base = stmpe->irq_base;
         int irq;
 
+        if (stmpe->variant->id_val != STMPE801_ID)
+                chip = &stmpe_irq_chip;
+
         for (irq = base; irq < base + num_irqs; irq++) {
                 irq_set_chip_data(irq, stmpe);
-                irq_set_chip_and_handler(irq, &stmpe_irq_chip,
-                                         handle_edge_irq);
+                irq_set_chip_and_handler(irq, chip, handle_edge_irq);
                 irq_set_nested_thread(irq, 1);
 #ifdef CONFIG_ARM
                 set_irq_flags(irq, IRQF_VALID);
@@ -796,7 +864,7 @@ static int __devinit stmpe_chip_init(struct stmpe *stmpe)
         unsigned int irq_trigger = stmpe->pdata->irq_trigger;
         int autosleep_timeout = stmpe->pdata->autosleep_timeout;
         struct stmpe_variant_info *variant = stmpe->variant;
-        u8 icr = STMPE_ICR_LSB_GIM;
+        u8 icr;
         unsigned int id;
         u8 data[2];
         int ret;
@@ -819,16 +887,32 @@ static int __devinit stmpe_chip_init(struct stmpe *stmpe)
         if (ret)
                 return ret;
 
-        if (irq_trigger == IRQF_TRIGGER_FALLING ||
-            irq_trigger == IRQF_TRIGGER_RISING)
-                icr |= STMPE_ICR_LSB_EDGE;
+        if (id == STMPE801_ID)
+                icr = STMPE801_REG_SYS_CTRL_INT_EN;
+        else
+                icr = STMPE_ICR_LSB_GIM;
+
+        /* STMPE801 doesn't support Edge interrupts */
+        if (id != STMPE801_ID) {
+                if (irq_trigger == IRQF_TRIGGER_FALLING ||
+                                irq_trigger == IRQF_TRIGGER_RISING)
+                        icr |= STMPE_ICR_LSB_EDGE;
+        }
 
         if (irq_trigger == IRQF_TRIGGER_RISING ||
-            irq_trigger == IRQF_TRIGGER_HIGH)
-                icr |= STMPE_ICR_LSB_HIGH;
+                        irq_trigger == IRQF_TRIGGER_HIGH) {
+                if (id == STMPE801_ID)
+                        icr |= STMPE801_REG_SYS_CTRL_INT_HI;
+                else
+                        icr |= STMPE_ICR_LSB_HIGH;
+        }
 
-        if (stmpe->pdata->irq_invert_polarity)
-                icr ^= STMPE_ICR_LSB_HIGH;
+        if (stmpe->pdata->irq_invert_polarity) {
+                if (id == STMPE801_ID)
+                        icr ^= STMPE801_REG_SYS_CTRL_INT_HI;
+                else
+                        icr ^= STMPE_ICR_LSB_HIGH;
+        }
 
         if (stmpe->pdata->autosleep) {
                 ret = stmpe_autosleep(stmpe, autosleep_timeout);
@@ -873,32 +957,10 @@ static int __devinit stmpe_devices_init(struct stmpe *stmpe)
         return ret;
 }
 
-#ifdef CONFIG_PM
-static int stmpe_suspend(struct device *dev)
-{
-        struct i2c_client *i2c = to_i2c_client(dev);
-
-        if (device_may_wakeup(&i2c->dev))
-                enable_irq_wake(i2c->irq);
-
-        return 0;
-}
-
-static int stmpe_resume(struct device *dev)
-{
-        struct i2c_client *i2c = to_i2c_client(dev);
-
-        if (device_may_wakeup(&i2c->dev))
-                disable_irq_wake(i2c->irq);
-
-        return 0;
-}
-#endif
-
-static int __devinit stmpe_probe(struct i2c_client *i2c,
-                                 const struct i2c_device_id *id)
+/* Called from client specific probe routines */
+int __devinit stmpe_probe(struct stmpe_client_info *ci, int partnum)
 {
-        struct stmpe_platform_data *pdata = i2c->dev.platform_data;
+        struct stmpe_platform_data *pdata = dev_get_platdata(ci->dev);
         struct stmpe *stmpe;
         int ret;
 
@@ -912,30 +974,43 @@ static int __devinit stmpe_probe(struct i2c_client *i2c,
         mutex_init(&stmpe->irq_lock);
         mutex_init(&stmpe->lock);
 
-        stmpe->dev = &i2c->dev;
-        stmpe->i2c = i2c;
-
+        stmpe->dev = ci->dev;
+        stmpe->client = ci->client;
         stmpe->pdata = pdata;
         stmpe->irq_base = pdata->irq_base;
-
-        stmpe->partnum = id->driver_data;
-        stmpe->variant = stmpe_variant_info[stmpe->partnum];
+        stmpe->ci = ci;
+        stmpe->partnum = partnum;
+        stmpe->variant = stmpe_variant_info[partnum];
         stmpe->regs = stmpe->variant->regs;
         stmpe->num_gpios = stmpe->variant->num_gpios;
+        dev_set_drvdata(stmpe->dev, stmpe);
 
-        i2c_set_clientdata(i2c, stmpe);
+        if (ci->init)
+                ci->init(stmpe);
+
+        if (pdata->irq_over_gpio) {
+                ret = gpio_request_one(pdata->irq_gpio, GPIOF_DIR_IN, "stmpe");
+                if (ret) {
+                        dev_err(stmpe->dev, "failed to request IRQ GPIO: %d\n",
+                                        ret);
+                        goto out_free;
+                }
+
+                stmpe->irq = gpio_to_irq(pdata->irq_gpio);
+        } else {
+                stmpe->irq = ci->irq;
+        }
 
         ret = stmpe_chip_init(stmpe);
         if (ret)
-                goto out_free;
+                goto free_gpio;
 
         ret = stmpe_irq_init(stmpe);
         if (ret)
-                goto out_free;
+                goto free_gpio;
 
-        ret = request_threaded_irq(stmpe->i2c->irq, NULL, stmpe_irq,
-                                   pdata->irq_trigger | IRQF_ONESHOT,
-                                   "stmpe", stmpe);
+        ret = request_threaded_irq(stmpe->irq, NULL, stmpe_irq,
+                        pdata->irq_trigger | IRQF_ONESHOT, "stmpe", stmpe);
         if (ret) {
                 dev_err(stmpe->dev, "failed to request IRQ: %d\n", ret);
                 goto out_removeirq;
@@ -951,67 +1026,55 @@ static int __devinit stmpe_probe(struct i2c_client *i2c,
 
 out_removedevs:
         mfd_remove_devices(stmpe->dev);
-        free_irq(stmpe->i2c->irq, stmpe);
+        free_irq(stmpe->irq, stmpe);
 out_removeirq:
         stmpe_irq_remove(stmpe);
+free_gpio:
+        if (pdata->irq_over_gpio)
+                gpio_free(pdata->irq_gpio);
 out_free:
         kfree(stmpe);
         return ret;
 }
 
-static int __devexit stmpe_remove(struct i2c_client *client)
+int stmpe_remove(struct stmpe *stmpe)
 {
-        struct stmpe *stmpe = i2c_get_clientdata(client);
-
         mfd_remove_devices(stmpe->dev);
 
-        free_irq(stmpe->i2c->irq, stmpe);
+        free_irq(stmpe->irq, stmpe);
         stmpe_irq_remove(stmpe);
 
+        if (stmpe->pdata->irq_over_gpio)
+                gpio_free(stmpe->pdata->irq_gpio);
+
         kfree(stmpe);
 
         return 0;
 }
 
-static const struct i2c_device_id stmpe_id[] = {
-        { "stmpe811", STMPE811 },
-        { "stmpe1601", STMPE1601 },
-        { "stmpe2401", STMPE2401 },
-        { "stmpe2403", STMPE2403 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, stmpe_id);
-
 #ifdef CONFIG_PM
-static const struct dev_pm_ops stmpe_dev_pm_ops = {
-        .suspend        = stmpe_suspend,
-        .resume         = stmpe_resume,
-};
-#endif
+static int stmpe_suspend(struct device *dev)
+{
+        struct stmpe *stmpe = dev_get_drvdata(dev);
 
-static struct i2c_driver stmpe_driver = {
-        .driver.name    = "stmpe",
-        .driver.owner   = THIS_MODULE,
-#ifdef CONFIG_PM
-        .driver.pm      = &stmpe_dev_pm_ops,
-#endif
-        .probe          = stmpe_probe,
-        .remove         = __devexit_p(stmpe_remove),
-        .id_table       = stmpe_id,
-};
+        if (device_may_wakeup(dev))
+                enable_irq_wake(stmpe->irq);
 
-static int __init stmpe_init(void)
-{
-        return i2c_add_driver(&stmpe_driver);
+        return 0;
 }
-subsys_initcall(stmpe_init);
 
-static void __exit stmpe_exit(void)
+static int stmpe_resume(struct device *dev)
 {
-        i2c_del_driver(&stmpe_driver);
+        struct stmpe *stmpe = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                disable_irq_wake(stmpe->irq);
+
+        return 0;
 }
-module_exit(stmpe_exit);
 
-MODULE_LICENSE("GPL v2");
-MODULE_DESCRIPTION("STMPE MFD core driver");
-MODULE_AUTHOR("Rabin Vincent <rabin.vincent@stericsson.com>");
+const struct dev_pm_ops stmpe_dev_pm_ops = {
+        .suspend        = stmpe_suspend,
+        .resume         = stmpe_resume,
+};
+#endif
diff --git a/drivers/mfd/stmpe.h b/drivers/mfd/stmpe.h
index e4ee38956583..7b8e13f5b764 100644
--- a/drivers/mfd/stmpe.h
+++ b/drivers/mfd/stmpe.h
@@ -8,6 +8,14 @@
 #ifndef __STMPE_H
 #define __STMPE_H
 
+#include <linux/device.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/stmpe.h>
+#include <linux/printk.h>
+#include <linux/types.h>
+
+extern const struct dev_pm_ops stmpe_dev_pm_ops;
+
 #ifdef STMPE_DUMP_BYTES
 static inline void stmpe_dump_bytes(const char *str, const void *buf,
                                     size_t len)
@@ -67,11 +75,55 @@ struct stmpe_variant_info {
         int (*enable_autosleep)(struct stmpe *stmpe, int autosleep_timeout);
 };
 
+/**
+ * struct stmpe_client_info - i2c or spi specific routines/info
+ * @data: client specific data
+ * @read_byte: read single byte
+ * @write_byte: write single byte
+ * @read_block: read block or multiple bytes
+ * @write_block: write block or multiple bytes
+ * @init: client init routine, called during probe
+ */
+struct stmpe_client_info {
+        void *data;
+        int irq;
+        void *client;
+        struct device *dev;
+        int (*read_byte)(struct stmpe *stmpe, u8 reg);
+        int (*write_byte)(struct stmpe *stmpe, u8 reg, u8 val);
+        int (*read_block)(struct stmpe *stmpe, u8 reg, u8 len, u8 *values);
+        int (*write_block)(struct stmpe *stmpe, u8 reg, u8 len,
+                        const u8 *values);
+        void (*init)(struct stmpe *stmpe);
+};
+
+int stmpe_probe(struct stmpe_client_info *ci, int partnum);
+int stmpe_remove(struct stmpe *stmpe);
+
 #define STMPE_ICR_LSB_HIGH      (1 << 2)
 #define STMPE_ICR_LSB_EDGE      (1 << 1)
 #define STMPE_ICR_LSB_GIM       (1 << 0)
 
 /*
+ * STMPE801
+ */
+#define STMPE801_ID                     0x0108
+#define STMPE801_NR_INTERNAL_IRQS       1
+
+#define STMPE801_REG_CHIP_ID            0x00
+#define STMPE801_REG_VERSION_ID         0x02
+#define STMPE801_REG_SYS_CTRL           0x04
+#define STMPE801_REG_GPIO_INT_EN        0x08
+#define STMPE801_REG_GPIO_INT_STA       0x09
+#define STMPE801_REG_GPIO_MP_STA        0x10
+#define STMPE801_REG_GPIO_SET_PIN       0x11
+#define STMPE801_REG_GPIO_DIR           0x12
+
+#define STMPE801_REG_SYS_CTRL_RESET     (1 << 7)
+#define STMPE801_REG_SYS_CTRL_INT_EN    (1 << 2)
+#define STMPE801_REG_SYS_CTRL_INT_HI    (1 << 0)
+
+/*
  * STMPE811
  */
 
@@ -87,6 +139,7 @@ struct stmpe_variant_info {
 
 #define STMPE811_REG_CHIP_ID            0x00
 #define STMPE811_REG_SYS_CTRL2          0x04
+#define STMPE811_REG_SPI_CFG            0x08
 #define STMPE811_REG_INT_CTRL           0x09
 #define STMPE811_REG_INT_EN             0x0A
 #define STMPE811_REG_INT_STA            0x0B
diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
index 91ad21ef7721..2d9e8799e733 100644
--- a/drivers/mfd/t7l66xb.c
+++ b/drivers/mfd/t7l66xb.c
@@ -442,21 +442,7 @@ static struct platform_driver t7l66xb_platform_driver = {
 
 /*--------------------------------------------------------------------------*/
 
-static int __init t7l66xb_init(void)
-{
-        int retval = 0;
-
-        retval = platform_driver_register(&t7l66xb_platform_driver);
-        return retval;
-}
-
-static void __exit t7l66xb_exit(void)
-{
-        platform_driver_unregister(&t7l66xb_platform_driver);
-}
-
-module_init(t7l66xb_init);
-module_exit(t7l66xb_exit);
+module_platform_driver(t7l66xb_platform_driver);
 
 MODULE_DESCRIPTION("Toshiba T7L66XB core driver");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/tc6387xb.c b/drivers/mfd/tc6387xb.c
index 71bc835324d8..d20a284ad4ba 100644
--- a/drivers/mfd/tc6387xb.c
+++ b/drivers/mfd/tc6387xb.c
@@ -234,19 +234,7 @@ static struct platform_driver tc6387xb_platform_driver = {
         .resume         = tc6387xb_resume,
 };
 
-
-static int __init tc6387xb_init(void)
-{
-        return platform_driver_register(&tc6387xb_platform_driver);
-}
-
-static void __exit tc6387xb_exit(void)
-{
-        platform_driver_unregister(&tc6387xb_platform_driver);
-}
-
-module_init(tc6387xb_init);
-module_exit(tc6387xb_exit);
+module_platform_driver(tc6387xb_platform_driver);
 
 MODULE_DESCRIPTION("Toshiba TC6387XB core driver");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/ti-ssp.c b/drivers/mfd/ti-ssp.c
index af9ab0e5ca64..4fb0e6c8e8fe 100644
--- a/drivers/mfd/ti-ssp.c
+++ b/drivers/mfd/ti-ssp.c
@@ -458,17 +458,7 @@ static struct platform_driver ti_ssp_driver = {
         }
 };
 
-static int __init ti_ssp_init(void)
-{
-        return platform_driver_register(&ti_ssp_driver);
-}
-module_init(ti_ssp_init);
-
-static void __exit ti_ssp_exit(void)
-{
-        platform_driver_unregister(&ti_ssp_driver);
-}
-module_exit(ti_ssp_exit);
+module_platform_driver(ti_ssp_driver);
 
 MODULE_DESCRIPTION("Sequencer Serial Port (SSP) Driver");
 MODULE_AUTHOR("Cyril Chemparathy");
diff --git a/drivers/mfd/timberdale.c b/drivers/mfd/timberdale.c
index 02d65692ceb4..0ba26fb12cf5 100644
--- a/drivers/mfd/timberdale.c
+++ b/drivers/mfd/timberdale.c
@@ -857,7 +857,7 @@ static void __devexit timb_remove(struct pci_dev *dev)
         kfree(priv);
 }
 
-static struct pci_device_id timberdale_pci_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(timberdale_pci_tbl) = {
         { PCI_DEVICE(PCI_VENDOR_ID_TIMB, PCI_DEVICE_ID_TIMB) },
         { 0 }
 };
diff --git a/drivers/mfd/tps65910-irq.c b/drivers/mfd/tps65910-irq.c
index a56be931551c..95c0d7978bec 100644
--- a/drivers/mfd/tps65910-irq.c
+++ b/drivers/mfd/tps65910-irq.c
@@ -215,6 +215,7 @@ int tps65910_irq_init(struct tps65910 *tps65910, int irq,
 
 int tps65910_irq_exit(struct tps65910 *tps65910)
 {
-        free_irq(tps65910->chip_irq, tps65910);
+        if (tps65910->chip_irq)
+                free_irq(tps65910->chip_irq, tps65910);
         return 0;
 }
diff --git a/drivers/mfd/tps65910.c b/drivers/mfd/tps65910.c
index c1da84bc1573..01cf5012a08f 100644
--- a/drivers/mfd/tps65910.c
+++ b/drivers/mfd/tps65910.c
@@ -172,15 +172,12 @@ static int tps65910_i2c_probe(struct i2c_client *i2c,
 
         tps65910_gpio_init(tps65910, pmic_plat_data->gpio_base);
 
-        ret = tps65910_irq_init(tps65910, init_data->irq, init_data);
-        if (ret < 0)
-                goto err;
+        tps65910_irq_init(tps65910, init_data->irq, init_data);
 
         kfree(init_data);
         return ret;
 
 err:
-        mfd_remove_devices(tps65910->dev);
         kfree(tps65910);
         kfree(init_data);
         return ret;
@@ -190,8 +187,8 @@ static int tps65910_i2c_remove(struct i2c_client *i2c)
 {
         struct tps65910 *tps65910 = i2c_get_clientdata(i2c);
 
-        mfd_remove_devices(tps65910->dev);
         tps65910_irq_exit(tps65910);
+        mfd_remove_devices(tps65910->dev);
         kfree(tps65910);
 
         return 0;
diff --git a/drivers/mfd/tps65912-spi.c b/drivers/mfd/tps65912-spi.c
index 6d71e0d25744..27d3302d56b8 100644
--- a/drivers/mfd/tps65912-spi.c
+++ b/drivers/mfd/tps65912-spi.c
@@ -111,7 +111,6 @@ static int __devexit tps65912_spi_remove(struct spi_device *spi)
 static struct spi_driver tps65912_spi_driver = {
         .driver = {
                 .name = "tps65912",
-                .bus = &spi_bus_type,
                 .owner = THIS_MODULE,
         },
         .probe  = tps65912_spi_probe,
diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c
index 61e70cfaa774..e04e04ddc15e 100644
--- a/drivers/mfd/twl-core.c
+++ b/drivers/mfd/twl-core.c
@@ -34,6 +34,11 @@
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/err.h>
+#include <linux/device.h>
+#include <linux/of.h>
+#include <linux/of_irq.h>
+#include <linux/of_platform.h>
+#include <linux/irqdomain.h>
 
 #include <linux/regulator/machine.h>
 
@@ -144,6 +149,9 @@
 
 #define TWL_MODULE_LAST TWL4030_MODULE_LAST
 
+#define TWL4030_NR_IRQS    8
+#define TWL6030_NR_IRQS    20
+
 /* Base Address defns for twl4030_map[] */
 
 /* subchip/slave 0 - USB ID */
@@ -255,6 +263,7 @@ struct twl_client {
 
 static struct twl_client twl_modules[TWL_NUM_SLAVES];
 
+static struct irq_domain domain;
 
 /* mapping the module id to slave id and base address */
 struct twl_mapping {
@@ -1183,14 +1192,48 @@ twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
         int                             status;
         unsigned                        i;
         struct twl4030_platform_data    *pdata = client->dev.platform_data;
+        struct device_node              *node = client->dev.of_node;
         u8 temp;
         int ret = 0;
+        int nr_irqs = TWL4030_NR_IRQS;
+
+        if ((id->driver_data) & TWL6030_CLASS)
+                nr_irqs = TWL6030_NR_IRQS;
+
+        if (node && !pdata) {
+                /*
+                 * XXX: Temporary pdata until the information is correctly
+                 * retrieved by every TWL modules from DT.
+                 */
+                pdata = devm_kzalloc(&client->dev,
+                                     sizeof(struct twl4030_platform_data),
+                                     GFP_KERNEL);
+                if (!pdata)
+                        return -ENOMEM;
+        }
 
         if (!pdata) {
                 dev_dbg(&client->dev, "no platform data?\n");
                 return -EINVAL;
         }
 
+        status = irq_alloc_descs(-1, pdata->irq_base, nr_irqs, 0);
+        if (IS_ERR_VALUE(status)) {
+                dev_err(&client->dev, "Fail to allocate IRQ descs\n");
+                return status;
+        }
+
+        pdata->irq_base = status;
+        pdata->irq_end = pdata->irq_base + nr_irqs;
+
+        domain.irq_base = pdata->irq_base;
+        domain.nr_irq = nr_irqs;
+#ifdef CONFIG_OF_IRQ
+        domain.of_node = of_node_get(node);
+        domain.ops = &irq_domain_simple_ops;
+#endif
+        irq_domain_add(&domain);
+
         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {
                 dev_dbg(&client->dev, "can't talk I2C?\n");
                 return -EIO;
@@ -1270,7 +1313,13 @@ twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
                 twl_i2c_write_u8(TWL4030_MODULE_INTBR, temp, REG_GPPUPDCTR1);
         }
 
-        status = add_children(pdata, id->driver_data);
+#ifdef CONFIG_OF_DEVICE
+        if (node)
+                status = of_platform_populate(node, NULL, NULL, &client->dev);
+        else
+#endif
+                status = add_children(pdata, id->driver_data);
+
 fail:
         if (status < 0)
                 twl_remove(client);
diff --git a/drivers/mfd/twl4030-audio.c b/drivers/mfd/twl4030-audio.c
index ae51ab5d0e5d..838ce4eb444e 100644
--- a/drivers/mfd/twl4030-audio.c
+++ b/drivers/mfd/twl4030-audio.c
@@ -261,17 +261,7 @@ static struct platform_driver twl4030_audio_driver = {
         },
 };
 
-static int __devinit twl4030_audio_init(void)
-{
-        return platform_driver_register(&twl4030_audio_driver);
-}
-module_init(twl4030_audio_init);
-
-static void __devexit twl4030_audio_exit(void)
-{
-        platform_driver_unregister(&twl4030_audio_driver);
-}
-module_exit(twl4030_audio_exit);
+module_platform_driver(twl4030_audio_driver);
 
 MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@ti.com>");
 MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/twl4030-irq.c b/drivers/mfd/twl4030-irq.c
index 29f11e0765fe..b69bb517b102 100644
--- a/drivers/mfd/twl4030-irq.c
+++ b/drivers/mfd/twl4030-irq.c
@@ -492,7 +492,7 @@ static void twl4030_sih_bus_sync_unlock(struct irq_data *data)
                         u8      bytes[4];
                 } imr;
 
-                /* byte[0] gets overwriten as we write ... */
+                /* byte[0] gets overwritten as we write ... */
                 imr.word = cpu_to_le32(agent->imr << 8);
                 agent->imr_change_pending = false;
 
@@ -667,6 +667,7 @@ int twl4030_sih_setup(int module)
                 irq_set_chip_data(irq, agent);
                 irq_set_chip_and_handler(irq, &twl4030_sih_irq_chip,
                                          handle_edge_irq);
+                irq_set_nested_thread(irq, 1);
                 activate_irq(irq);
         }
 
diff --git a/drivers/mfd/twl4030-madc.c b/drivers/mfd/twl4030-madc.c
index 834f824d3c11..456ecb5ac4fe 100644
--- a/drivers/mfd/twl4030-madc.c
+++ b/drivers/mfd/twl4030-madc.c
@@ -807,19 +807,7 @@ static struct platform_driver twl4030_madc_driver = {
                    },
 };
 
-static int __init twl4030_madc_init(void)
-{
-        return platform_driver_register(&twl4030_madc_driver);
-}
-
-module_init(twl4030_madc_init);
-
-static void __exit twl4030_madc_exit(void)
-{
-        platform_driver_unregister(&twl4030_madc_driver);
-}
-
-module_exit(twl4030_madc_exit);
+module_platform_driver(twl4030_madc_driver);
 
 MODULE_DESCRIPTION("TWL4030 ADC driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/twl4030-power.c b/drivers/mfd/twl4030-power.c
index a764676f0922..d905f5171153 100644
--- a/drivers/mfd/twl4030-power.c
+++ b/drivers/mfd/twl4030-power.c
@@ -34,7 +34,8 @@
 static u8 twl4030_start_script_address = 0x2b;
 
 #define PWR_P1_SW_EVENTS        0x10
-#define PWR_DEVOFF      (1<<0)
+#define PWR_DEVOFF              (1 << 0)
+#define SEQ_OFFSYNC             (1 << 0)
 
 #define PHY_TO_OFF_PM_MASTER(p)         (p - 0x36)
 #define PHY_TO_OFF_PM_RECEIVER(p)       (p - 0x5b)
@@ -511,12 +512,27 @@ int twl4030_remove_script(u8 flags)
         return err;
 }
 
+/*
+ * In master mode, start the power off sequence.
+ * After a successful execution, TWL shuts down the power to the SoC
+ * and all peripherals connected to it.
+ */
+void twl4030_power_off(void)
+{
+        int err;
+
+        err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, PWR_DEVOFF,
+                               TWL4030_PM_MASTER_P1_SW_EVENTS);
+        if (err)
+                pr_err("TWL4030 Unable to power off\n");
+}
+
 void __init twl4030_power_init(struct twl4030_power_data *twl4030_scripts)
 {
         int err = 0;
         int i;
         struct twl4030_resconfig *resconfig;
-        u8 address = twl4030_start_script_address;
+        u8 val, address = twl4030_start_script_address;
 
         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER,
                         TWL4030_PM_MASTER_KEY_CFG1,
@@ -548,6 +564,28 @@ void __init twl4030_power_init(struct twl4030_power_data *twl4030_scripts)
                 }
         }
 
+        /* Board has to be wired properly to use this feature */
+        if (twl4030_scripts->use_poweroff && !pm_power_off) {
+                /* Default for SEQ_OFFSYNC is set, lets ensure this */
+                err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &val,
+                                      TWL4030_PM_MASTER_CFG_P123_TRANSITION);
+                if (err) {
+                        pr_warning("TWL4030 Unable to read registers\n");
+
+                } else if (!(val & SEQ_OFFSYNC)) {
+                        val |= SEQ_OFFSYNC;
+                        err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, val,
+                                        TWL4030_PM_MASTER_CFG_P123_TRANSITION);
+                        if (err) {
+                                pr_err("TWL4030 Unable to setup SEQ_OFFSYNC\n");
+                                goto relock;
+                        }
+                }
+
+                pm_power_off = twl4030_power_off;
+        }
+
+relock:
         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0,
                         TWL4030_PM_MASTER_PROTECT_KEY);
         if (err)
diff --git a/drivers/mfd/twl6040-core.c b/drivers/mfd/twl6040-core.c
index 268f80fd0439..dda86293dc9f 100644
--- a/drivers/mfd/twl6040-core.c
+++ b/drivers/mfd/twl6040-core.c
@@ -509,13 +509,10 @@ static int __devinit twl6040_probe(struct platform_device *pdev)
                 twl6040->audpwron = -EINVAL;
 
         if (gpio_is_valid(twl6040->audpwron)) {
-                ret = gpio_request(twl6040->audpwron, "audpwron");
+                ret = gpio_request_one(twl6040->audpwron, GPIOF_OUT_INIT_LOW,
+                                       "audpwron");
                 if (ret)
                         goto gpio1_err;
-
-                ret = gpio_direction_output(twl6040->audpwron, 0);
-                if (ret)
-                        goto gpio2_err;
         }
 
         /* codec interrupt */
@@ -619,18 +616,7 @@ static struct platform_driver twl6040_driver = {
         },
 };
 
-static int __devinit twl6040_init(void)
-{
-        return platform_driver_register(&twl6040_driver);
-}
-module_init(twl6040_init);
-
-static void __devexit twl6040_exit(void)
-{
-        platform_driver_unregister(&twl6040_driver);
-}
-
-module_exit(twl6040_exit);
+module_platform_driver(twl6040_driver);
 
 MODULE_DESCRIPTION("TWL6040 MFD");
 MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>");
diff --git a/drivers/mfd/ucb1x00-core.c b/drivers/mfd/ucb1x00-core.c
index b281217334eb..91c4f25e0e55 100644
--- a/drivers/mfd/ucb1x00-core.c
+++ b/drivers/mfd/ucb1x00-core.c
@@ -36,6 +36,15 @@ static DEFINE_MUTEX(ucb1x00_mutex);
 static LIST_HEAD(ucb1x00_drivers);
 static LIST_HEAD(ucb1x00_devices);
 
+static struct mcp_device_id ucb1x00_id[] = {
+        { "ucb1x00", 0 },  /* auto-detection */
+        { "ucb1200", UCB_ID_1200 },
+        { "ucb1300", UCB_ID_1300 },
+        { "tc35143", UCB_ID_TC35143 },
+        { }
+};
+MODULE_DEVICE_TABLE(mcp, ucb1x00_id);
+
 /**
  *      ucb1x00_io_set_dir - set IO direction
  *      @ucb: UCB1x00 structure describing chip
@@ -527,17 +536,33 @@ static struct class ucb1x00_class = {
 
 static int ucb1x00_probe(struct mcp *mcp)
 {
+        const struct mcp_device_id *mid;
         struct ucb1x00 *ucb;
         struct ucb1x00_driver *drv;
+        struct ucb1x00_plat_data *pdata;
         unsigned int id;
         int ret = -ENODEV;
         int temp;
 
         mcp_enable(mcp);
         id = mcp_reg_read(mcp, UCB_ID);
+        mid = mcp_get_device_id(mcp);
 
-        if (id != UCB_ID_1200 && id != UCB_ID_1300 && id != UCB_ID_TC35143) {
-                printk(KERN_WARNING "UCB1x00 ID not found: %04x\n", id);
+        if (mid && mid->driver_data) {
+                if (id != mid->driver_data) {
+                        printk(KERN_WARNING "%s wrong ID %04x found: %04x\n",
+                                mid->name, (unsigned int) mid->driver_data, id);
+                        goto err_disable;
+                }
+        } else {
+                mid = &ucb1x00_id[1];
+                while (mid->driver_data) {
+                        if (id == mid->driver_data)
+                                break;
+                        mid++;
+                }
+                printk(KERN_WARNING "%s ID not found: %04x\n",
+                        ucb1x00_id[0].name, id);
                 goto err_disable;
         }
 
@@ -546,28 +571,28 @@ static int ucb1x00_probe(struct mcp *mcp)
         if (!ucb)
                 goto err_disable;
 
-
+        pdata = mcp->attached_device.platform_data;
         ucb->dev.class = &ucb1x00_class;
         ucb->dev.parent = &mcp->attached_device;
-        dev_set_name(&ucb->dev, "ucb1x00");
+        dev_set_name(&ucb->dev, mid->name);
 
         spin_lock_init(&ucb->lock);
         spin_lock_init(&ucb->io_lock);
         sema_init(&ucb->adc_sem, 1);
 
-        ucb->id  = id;
+        ucb->id  = mid;
         ucb->mcp = mcp;
         ucb->irq = ucb1x00_detect_irq(ucb);
         if (ucb->irq == NO_IRQ) {
-                printk(KERN_ERR "UCB1x00: IRQ probe failed\n");
+                printk(KERN_ERR "%s: IRQ probe failed\n", mid->name);
                 ret = -ENODEV;
                 goto err_free;
         }
 
         ucb->gpio.base = -1;
-        if (mcp->gpio_base != 0) {
+        if (pdata && (pdata->gpio_base >= 0)) {
                 ucb->gpio.label = dev_name(&ucb->dev);
-                ucb->gpio.base = mcp->gpio_base;
+                ucb->gpio.base = pdata->gpio_base;
                 ucb->gpio.ngpio = 10;
                 ucb->gpio.set = ucb1x00_gpio_set;
                 ucb->gpio.get = ucb1x00_gpio_get;
@@ -580,10 +605,10 @@ static int ucb1x00_probe(struct mcp *mcp)
                 dev_info(&ucb->dev, "gpio_base not set so no gpiolib support");
 
         ret = request_irq(ucb->irq, ucb1x00_irq, IRQF_TRIGGER_RISING,
-                          "UCB1x00", ucb);
+                          mid->name, ucb);
         if (ret) {
-                printk(KERN_ERR "ucb1x00: unable to grab irq%d: %d\n",
-                        ucb->irq, ret);
+                printk(KERN_ERR "%s: unable to grab irq%d: %d\n",
+                        mid->name, ucb->irq, ret);
                 goto err_gpio;
         }
 
@@ -705,6 +730,7 @@ static struct mcp_driver ucb1x00_driver = {
         .remove         = ucb1x00_remove,
         .suspend        = ucb1x00_suspend,
         .resume         = ucb1x00_resume,
+        .id_table       = ucb1x00_id,
 };
 
 static int __init ucb1x00_init(void)
diff --git a/drivers/mfd/ucb1x00-ts.c b/drivers/mfd/ucb1x00-ts.c
index 38ffbd50a0d2..40ec3c118868 100644
--- a/drivers/mfd/ucb1x00-ts.c
+++ b/drivers/mfd/ucb1x00-ts.c
@@ -382,7 +382,7 @@ static int ucb1x00_ts_add(struct ucb1x00_dev *dev)
         ts->adcsync = adcsync ? UCB_SYNC : UCB_NOSYNC;
 
         idev->name       = "Touchscreen panel";
-        idev->id.product = ts->ucb->id;
+        idev->id.product = ts->ucb->id->driver_data;
         idev->open       = ucb1x00_ts_open;
         idev->close      = ucb1x00_ts_close;
 
diff --git a/drivers/mfd/vx855.c b/drivers/mfd/vx855.c
index d698703dbd46..b73cc15e0081 100644
--- a/drivers/mfd/vx855.c
+++ b/drivers/mfd/vx855.c
@@ -118,7 +118,7 @@ static void __devexit vx855_remove(struct pci_dev *pdev)
         pci_disable_device(pdev);
 }
 
-static struct pci_device_id vx855_pci_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(vx855_pci_tbl) = {
         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VX855) },
         { 0, }
 };
diff --git a/drivers/mfd/wm831x-core.c b/drivers/mfd/wm831x-core.c
index 0a2b8d41a702..f5e54fae8ada 100644
--- a/drivers/mfd/wm831x-core.c
+++ b/drivers/mfd/wm831x-core.c
@@ -559,6 +559,8 @@ static int wm831x_write(struct wm831x *wm831x, unsigned short reg,
                 dev_vdbg(wm831x->dev, "Write %04x to R%d(0x%x)\n",
                          buf[i], reg + i, reg + i);
                 ret = regmap_write(wm831x->regmap, reg + i, buf[i]);
+                if (ret != 0)
+                        return ret;
         }
 
         return 0;
@@ -1875,7 +1877,6 @@ err_irq:
 err_regmap:
         mfd_remove_devices(wm831x->dev);
         regmap_exit(wm831x->regmap);
-        kfree(wm831x);
         return ret;
 }
 
@@ -1887,7 +1888,6 @@ void wm831x_device_exit(struct wm831x *wm831x)
                 free_irq(wm831x->irq_base + WM831X_IRQ_AUXADC_DATA, wm831x);
         wm831x_irq_exit(wm831x);
         regmap_exit(wm831x->regmap);
-        kfree(wm831x);
 }
 
 int wm831x_device_suspend(struct wm831x *wm831x)
diff --git a/drivers/mfd/wm831x-i2c.c b/drivers/mfd/wm831x-i2c.c
index ac8da1d439da..cb15609b0a48 100644
--- a/drivers/mfd/wm831x-i2c.c
+++ b/drivers/mfd/wm831x-i2c.c
@@ -30,7 +30,7 @@ static int wm831x_i2c_probe(struct i2c_client *i2c,
         struct wm831x *wm831x;
         int ret;
 
-        wm831x = kzalloc(sizeof(struct wm831x), GFP_KERNEL);
+        wm831x = devm_kzalloc(&i2c->dev, sizeof(struct wm831x), GFP_KERNEL);
         if (wm831x == NULL)
                 return -ENOMEM;
 
@@ -42,7 +42,6 @@ static int wm831x_i2c_probe(struct i2c_client *i2c,
                 ret = PTR_ERR(wm831x->regmap);
                 dev_err(wm831x->dev, "Failed to allocate register map: %d\n",
                         ret);
-                kfree(wm831x);
                 return ret;
         }
 
diff --git a/drivers/mfd/wm831x-irq.c b/drivers/mfd/wm831x-irq.c
index f4747a4a9a93..bec4d0539160 100644
--- a/drivers/mfd/wm831x-irq.c
+++ b/drivers/mfd/wm831x-irq.c
@@ -325,11 +325,6 @@ static inline int irq_data_to_status_reg(struct wm831x_irq_data *irq_data)
         return WM831X_INTERRUPT_STATUS_1 - 1 + irq_data->reg;
 }
 
-static inline int irq_data_to_mask_reg(struct wm831x_irq_data *irq_data)
-{
-        return WM831X_INTERRUPT_STATUS_1_MASK - 1 + irq_data->reg;
-}
-
 static inline struct wm831x_irq_data *irq_to_wm831x_irq(struct wm831x *wm831x,
                                                         int irq)
 {
@@ -477,8 +472,7 @@ static irqreturn_t wm831x_irq_thread(int irq, void *data)
                 handle_nested_irq(wm831x->irq_base + WM831X_IRQ_TCHPD);
         if (primary & WM831X_TCHDATA_INT)
                 handle_nested_irq(wm831x->irq_base + WM831X_IRQ_TCHDATA);
-        if (primary & (WM831X_TCHDATA_EINT | WM831X_TCHPD_EINT))
-                goto out;
+        primary &= ~(WM831X_TCHDATA_EINT | WM831X_TCHPD_EINT);
 
         for (i = 0; i < ARRAY_SIZE(wm831x_irqs); i++) {
                 int offset = wm831x_irqs[i].reg - 1;
diff --git a/drivers/mfd/wm831x-spi.c b/drivers/mfd/wm831x-spi.c
index 8d6a9a969dbc..62ef3254105f 100644
--- a/drivers/mfd/wm831x-spi.c
+++ b/drivers/mfd/wm831x-spi.c
@@ -30,7 +30,7 @@ static int __devinit wm831x_spi_probe(struct spi_device *spi)
 
         type = (enum wm831x_parent)id->driver_data;
 
-        wm831x = kzalloc(sizeof(struct wm831x), GFP_KERNEL);
+        wm831x = devm_kzalloc(&spi->dev, sizeof(struct wm831x), GFP_KERNEL);
         if (wm831x == NULL)
                 return -ENOMEM;
 
@@ -45,7 +45,6 @@ static int __devinit wm831x_spi_probe(struct spi_device *spi)
                 ret = PTR_ERR(wm831x->regmap);
                 dev_err(wm831x->dev, "Failed to allocate register map: %d\n",
                         ret);
-                kfree(wm831x);
                 return ret;
         }
 
@@ -95,7 +94,6 @@ MODULE_DEVICE_TABLE(spi, wm831x_spi_id);
 static struct spi_driver wm831x_spi_driver = {
         .driver = {
                 .name   = "wm831x",
-                .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
                 .pm     = &wm831x_spi_pm,
         },
diff --git a/drivers/mfd/wm8350-core.c b/drivers/mfd/wm8350-core.c
index e81cc31e4202..dd1caaac55e4 100644
--- a/drivers/mfd/wm8350-core.c
+++ b/drivers/mfd/wm8350-core.c
@@ -573,6 +573,8 @@ int wm8350_device_init(struct wm8350 *wm8350, int irq,
         u16 id1, id2, mask_rev;
         u16 cust_id, mode, chip_rev;
 
+        dev_set_drvdata(wm8350->dev, wm8350);
+
         /* get WM8350 revision and config mode */
         ret = wm8350->read_dev(wm8350, WM8350_RESET_ID, sizeof(id1), &id1);
         if (ret != 0) {
diff --git a/drivers/mfd/wm8350-i2c.c b/drivers/mfd/wm8350-i2c.c
index 5fe5de166adb..d955faaf27c4 100644
--- a/drivers/mfd/wm8350-i2c.c
+++ b/drivers/mfd/wm8350-i2c.c
@@ -63,7 +63,7 @@ static int wm8350_i2c_probe(struct i2c_client *i2c,
         struct wm8350 *wm8350;
         int ret = 0;
 
-        wm8350 = kzalloc(sizeof(struct wm8350), GFP_KERNEL);
+        wm8350 = devm_kzalloc(&i2c->dev, sizeof(struct wm8350), GFP_KERNEL);
         if (wm8350 == NULL)
                 return -ENOMEM;
 
@@ -80,7 +80,6 @@ static int wm8350_i2c_probe(struct i2c_client *i2c,
         return ret;
 
 err:
-        kfree(wm8350);
         return ret;
 }
 
@@ -89,7 +88,6 @@ static int wm8350_i2c_remove(struct i2c_client *i2c)
         struct wm8350 *wm8350 = i2c_get_clientdata(i2c);
 
         wm8350_device_exit(wm8350);
-        kfree(wm8350);
 
         return 0;
 }
diff --git a/drivers/mfd/wm8400-core.c b/drivers/mfd/wm8400-core.c
index 62b4626f4561..2204893444a6 100644
--- a/drivers/mfd/wm8400-core.c
+++ b/drivers/mfd/wm8400-core.c
@@ -344,7 +344,7 @@ static int wm8400_i2c_probe(struct i2c_client *i2c,
         struct wm8400 *wm8400;
         int ret;
 
-        wm8400 = kzalloc(sizeof(struct wm8400), GFP_KERNEL);
+        wm8400 = devm_kzalloc(&i2c->dev, sizeof(struct wm8400), GFP_KERNEL);
         if (wm8400 == NULL) {
                 ret = -ENOMEM;
                 goto err;
@@ -353,7 +353,7 @@ static int wm8400_i2c_probe(struct i2c_client *i2c,
         wm8400->regmap = regmap_init_i2c(i2c, &wm8400_regmap_config);
         if (IS_ERR(wm8400->regmap)) {
                 ret = PTR_ERR(wm8400->regmap);
-                goto struct_err;
+                goto err;
         }
 
         wm8400->dev = &i2c->dev;
@@ -367,8 +367,6 @@ static int wm8400_i2c_probe(struct i2c_client *i2c,
 
 map_err:
         regmap_exit(wm8400->regmap);
-struct_err:
-        kfree(wm8400);
 err:
         return ret;
 }
@@ -379,7 +377,6 @@ static int wm8400_i2c_remove(struct i2c_client *i2c)
 
         wm8400_release(wm8400);
         regmap_exit(wm8400->regmap);
-        kfree(wm8400);
 
         return 0;
 }
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 5664696f2d3a..6a1a092db146 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -500,6 +500,14 @@ config USB_SWITCH_FSA9480
           stereo and mono audio, video, microphone and UART data to use
           a common connector port.
 
+config MAX8997_MUIC
+        tristate "MAX8997 MUIC Support"
+        depends on MFD_MAX8997
+        help
+          If you say yes here you get support for the MUIC device of
+          Maxim MAX8997 PMIC.
+          The MAX8997 MUIC is a USB port accessory detector and switch.
+
 source "drivers/misc/c2port/Kconfig"
 source "drivers/misc/eeprom/Kconfig"
 source "drivers/misc/cb710/Kconfig"
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index b26495a02554..3e1d80106f04 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -48,3 +48,4 @@ obj-y				+= lis3lv02d/
 obj-y                           += carma/
 obj-$(CONFIG_USB_SWITCH_FSA9480) += fsa9480.o
 obj-$(CONFIG_ALTERA_STAPL)      +=altera-stapl/
+obj-$(CONFIG_MAX8997_MUIC)      += max8997-muic.o
diff --git a/drivers/misc/ab8500-pwm.c b/drivers/misc/ab8500-pwm.c
index 2208a9d52622..d7a9aa14e5d5 100644
--- a/drivers/misc/ab8500-pwm.c
+++ b/drivers/misc/ab8500-pwm.c
@@ -8,8 +8,8 @@
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/pwm.h>
-#include <linux/mfd/ab8500.h>
 #include <linux/mfd/abx500.h>
+#include <linux/mfd/abx500/ab8500.h>
 #include <linux/module.h>
 
 /*
diff --git a/drivers/misc/max8997-muic.c b/drivers/misc/max8997-muic.c
new file mode 100644
index 000000000000..d74ef41aabd5
--- /dev/null
+++ b/drivers/misc/max8997-muic.c
@@ -0,0 +1,505 @@
+/*
+ * max8997-muic.c - MAX8997 muic driver for the Maxim 8997
+ *
+ *  Copyright (C) 2011 Samsung Electrnoics
+ *  Donggeun Kim <dg77.kim@samsung.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
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/kobject.h>
+#include <linux/mfd/max8997.h>
+#include <linux/mfd/max8997-private.h>
+
+/* MAX8997-MUIC STATUS1 register */
+#define STATUS1_ADC_SHIFT               0
+#define STATUS1_ADCLOW_SHIFT            5
+#define STATUS1_ADCERR_SHIFT            6
+#define STATUS1_ADC_MASK                (0x1f << STATUS1_ADC_SHIFT)
+#define STATUS1_ADCLOW_MASK             (0x1 << STATUS1_ADCLOW_SHIFT)
+#define STATUS1_ADCERR_MASK             (0x1 << STATUS1_ADCERR_SHIFT)
+
+/* MAX8997-MUIC STATUS2 register */
+#define STATUS2_CHGTYP_SHIFT            0
+#define STATUS2_CHGDETRUN_SHIFT         3
+#define STATUS2_DCDTMR_SHIFT            4
+#define STATUS2_DBCHG_SHIFT             5
+#define STATUS2_VBVOLT_SHIFT            6
+#define STATUS2_CHGTYP_MASK             (0x7 << STATUS2_CHGTYP_SHIFT)
+#define STATUS2_CHGDETRUN_MASK          (0x1 << STATUS2_CHGDETRUN_SHIFT)
+#define STATUS2_DCDTMR_MASK             (0x1 << STATUS2_DCDTMR_SHIFT)
+#define STATUS2_DBCHG_MASK              (0x1 << STATUS2_DBCHG_SHIFT)
+#define STATUS2_VBVOLT_MASK             (0x1 << STATUS2_VBVOLT_SHIFT)
+
+/* MAX8997-MUIC STATUS3 register */
+#define STATUS3_OVP_SHIFT               2
+#define STATUS3_OVP_MASK                (0x1 << STATUS3_OVP_SHIFT)
+
+/* MAX8997-MUIC CONTROL1 register */
+#define COMN1SW_SHIFT                   0
+#define COMP2SW_SHIFT                   3
+#define COMN1SW_MASK                    (0x7 << COMN1SW_SHIFT)
+#define COMP2SW_MASK                    (0x7 << COMP2SW_SHIFT)
+#define SW_MASK                         (COMP2SW_MASK | COMN1SW_MASK)
+
+#define MAX8997_SW_USB          ((1 << COMP2SW_SHIFT) | (1 << COMN1SW_SHIFT))
+#define MAX8997_SW_AUDIO        ((2 << COMP2SW_SHIFT) | (2 << COMN1SW_SHIFT))
+#define MAX8997_SW_UART         ((3 << COMP2SW_SHIFT) | (3 << COMN1SW_SHIFT))
+#define MAX8997_SW_OPEN         ((0 << COMP2SW_SHIFT) | (0 << COMN1SW_SHIFT))
+
+#define MAX8997_ADC_GROUND              0x00
+#define MAX8997_ADC_MHL                 0x01
+#define MAX8997_ADC_JIG_USB_1           0x18
+#define MAX8997_ADC_JIG_USB_2           0x19
+#define MAX8997_ADC_DESKDOCK            0x1a
+#define MAX8997_ADC_JIG_UART            0x1c
+#define MAX8997_ADC_CARDOCK             0x1d
+#define MAX8997_ADC_OPEN                0x1f
+
+struct max8997_muic_irq {
+        unsigned int irq;
+        const char *name;
+};
+
+static struct max8997_muic_irq muic_irqs[] = {
+        { MAX8997_MUICIRQ_ADCError, "muic-ADC_error" },
+        { MAX8997_MUICIRQ_ADCLow, "muic-ADC_low" },
+        { MAX8997_MUICIRQ_ADC, "muic-ADC" },
+        { MAX8997_MUICIRQ_VBVolt, "muic-VB_voltage" },
+        { MAX8997_MUICIRQ_DBChg, "muic-DB_charger" },
+        { MAX8997_MUICIRQ_DCDTmr, "muic-DCD_timer" },
+        { MAX8997_MUICIRQ_ChgDetRun, "muic-CDR_status" },
+        { MAX8997_MUICIRQ_ChgTyp, "muic-charger_type" },
+        { MAX8997_MUICIRQ_OVP, "muic-over_voltage" },
+};
+
+struct max8997_muic_info {
+        struct device *dev;
+        struct max8997_dev *iodev;
+        struct i2c_client *muic;
+        struct max8997_muic_platform_data *muic_pdata;
+
+        int irq;
+        struct work_struct irq_work;
+
+        enum max8997_muic_charger_type pre_charger_type;
+        int pre_adc;
+
+        struct mutex mutex;
+};
+
+static int max8997_muic_handle_usb(struct max8997_muic_info *info,
+                        enum max8997_muic_usb_type usb_type, bool attached)
+{
+        struct max8997_muic_platform_data *mdata = info->muic_pdata;
+        int ret = 0;
+
+        if (usb_type == MAX8997_USB_HOST) {
+                /* switch to USB */
+                ret = max8997_update_reg(info->muic, MAX8997_MUIC_REG_CONTROL1,
+                                attached ? MAX8997_SW_USB : MAX8997_SW_OPEN,
+                                SW_MASK);
+                if (ret) {
+                        dev_err(info->dev, "failed to update muic register\n");
+                        goto out;
+                }
+        }
+
+        if (mdata->usb_callback)
+                mdata->usb_callback(usb_type, attached);
+out:
+        return ret;
+}
+
+static void max8997_muic_handle_mhl(struct max8997_muic_info *info,
+                        bool attached)
+{
+        struct max8997_muic_platform_data *mdata = info->muic_pdata;
+
+        if (mdata->mhl_callback)
+                mdata->mhl_callback(attached);
+}
+
+static int max8997_muic_handle_dock(struct max8997_muic_info *info,
+                        int adc, bool attached)
+{
+        struct max8997_muic_platform_data *mdata = info->muic_pdata;
+        int ret = 0;
+
+        /* switch to AUDIO */
+        ret = max8997_update_reg(info->muic, MAX8997_MUIC_REG_CONTROL1,
+                                attached ? MAX8997_SW_AUDIO : MAX8997_SW_OPEN,
+                                SW_MASK);
+        if (ret) {
+                dev_err(info->dev, "failed to update muic register\n");
+                goto out;
+        }
+
+        switch (adc) {
+        case MAX8997_ADC_DESKDOCK:
+                if (mdata->deskdock_callback)
+                        mdata->deskdock_callback(attached);
+                break;
+        case MAX8997_ADC_CARDOCK:
+                if (mdata->cardock_callback)
+                        mdata->cardock_callback(attached);
+                break;
+        default:
+                break;
+        }
+out:
+        return ret;
+}
+
+static int max8997_muic_handle_jig_uart(struct max8997_muic_info *info,
+                        bool attached)
+{
+        struct max8997_muic_platform_data *mdata = info->muic_pdata;
+        int ret = 0;
+
+        /* switch to UART */
+        ret = max8997_update_reg(info->muic, MAX8997_MUIC_REG_CONTROL1,
+                                attached ? MAX8997_SW_UART : MAX8997_SW_OPEN,
+                                SW_MASK);
+        if (ret) {
+                dev_err(info->dev, "failed to update muic register\n");
+                goto out;
+        }
+
+        if (mdata->uart_callback)
+                mdata->uart_callback(attached);
+out:
+        return ret;
+}
+
+static int max8997_muic_handle_adc_detach(struct max8997_muic_info *info)
+{
+        int ret = 0;
+
+        switch (info->pre_adc) {
+        case MAX8997_ADC_GROUND:
+                ret = max8997_muic_handle_usb(info, MAX8997_USB_HOST, false);
+                break;
+        case MAX8997_ADC_MHL:
+                max8997_muic_handle_mhl(info, false);
+                break;
+        case MAX8997_ADC_JIG_USB_1:
+        case MAX8997_ADC_JIG_USB_2:
+                ret = max8997_muic_handle_usb(info, MAX8997_USB_DEVICE, false);
+                break;
+        case MAX8997_ADC_DESKDOCK:
+        case MAX8997_ADC_CARDOCK:
+                ret = max8997_muic_handle_dock(info, info->pre_adc, false);
+                break;
+        case MAX8997_ADC_JIG_UART:
+                ret = max8997_muic_handle_jig_uart(info, false);
+                break;
+        default:
+                break;
+        }
+
+        return ret;
+}
+
+static int max8997_muic_handle_adc(struct max8997_muic_info *info, int adc)
+{
+        int ret = 0;
+
+        switch (adc) {
+        case MAX8997_ADC_GROUND:
+                ret = max8997_muic_handle_usb(info, MAX8997_USB_HOST, true);
+                break;
+        case MAX8997_ADC_MHL:
+                max8997_muic_handle_mhl(info, true);
+                break;
+        case MAX8997_ADC_JIG_USB_1:
+        case MAX8997_ADC_JIG_USB_2:
+                ret = max8997_muic_handle_usb(info, MAX8997_USB_DEVICE, true);
+                break;
+        case MAX8997_ADC_DESKDOCK:
+        case MAX8997_ADC_CARDOCK:
+                ret = max8997_muic_handle_dock(info, adc, true);
+                break;
+        case MAX8997_ADC_JIG_UART:
+                ret = max8997_muic_handle_jig_uart(info, true);
+                break;
+        case MAX8997_ADC_OPEN:
+                ret = max8997_muic_handle_adc_detach(info);
+                break;
+        default:
+                break;
+        }
+
+        info->pre_adc = adc;
+
+        return ret;
+}
+
+static int max8997_muic_handle_charger_type(struct max8997_muic_info *info,
+                                enum max8997_muic_charger_type charger_type)
+{
+        struct max8997_muic_platform_data *mdata = info->muic_pdata;
+        u8 adc;
+        int ret;
+
+        ret = max8997_read_reg(info->muic, MAX8997_MUIC_REG_STATUS1, &adc);
+        if (ret) {
+                dev_err(info->dev, "failed to read muic register\n");
+                goto out;
+        }
+
+        switch (charger_type) {
+        case MAX8997_CHARGER_TYPE_NONE:
+                if (mdata->charger_callback)
+                        mdata->charger_callback(false, charger_type);
+                if (info->pre_charger_type == MAX8997_CHARGER_TYPE_USB) {
+                        max8997_muic_handle_usb(info,
+                                        MAX8997_USB_DEVICE, false);
+                }
+                break;
+        case MAX8997_CHARGER_TYPE_USB:
+                if ((adc & STATUS1_ADC_MASK) == MAX8997_ADC_OPEN) {
+                        max8997_muic_handle_usb(info,
+                                        MAX8997_USB_DEVICE, true);
+                }
+                if (mdata->charger_callback)
+                        mdata->charger_callback(true, charger_type);
+                break;
+        case MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT:
+        case MAX8997_CHARGER_TYPE_DEDICATED_CHG:
+        case MAX8997_CHARGER_TYPE_500MA:
+        case MAX8997_CHARGER_TYPE_1A:
+                if (mdata->charger_callback)
+                        mdata->charger_callback(true, charger_type);
+                break;
+        default:
+                break;
+        }
+
+        info->pre_charger_type = charger_type;
+out:
+        return ret;
+}
+
+static void max8997_muic_irq_work(struct work_struct *work)
+{
+        struct max8997_muic_info *info = container_of(work,
+                        struct max8997_muic_info, irq_work);
+        struct max8997_platform_data *pdata =
+                                dev_get_platdata(info->iodev->dev);
+        u8 status[3];
+        u8 adc, chg_type;
+
+        int irq_type = info->irq - pdata->irq_base;
+        int ret;
+
+        mutex_lock(&info->mutex);
+
+        ret = max8997_bulk_read(info->muic, MAX8997_MUIC_REG_STATUS1,
+                                3, status);
+        if (ret) {
+                dev_err(info->dev, "failed to read muic register\n");
+                mutex_unlock(&info->mutex);
+                return;
+        }
+
+        dev_dbg(info->dev, "%s: STATUS1:0x%x, 2:0x%x\n", __func__,
+                        status[0], status[1]);
+
+        switch (irq_type) {
+        case MAX8997_MUICIRQ_ADC:
+                adc = status[0] & STATUS1_ADC_MASK;
+                adc >>= STATUS1_ADC_SHIFT;
+
+                max8997_muic_handle_adc(info, adc);
+                break;
+        case MAX8997_MUICIRQ_ChgTyp:
+                chg_type = status[1] & STATUS2_CHGTYP_MASK;
+                chg_type >>= STATUS2_CHGTYP_SHIFT;
+
+                max8997_muic_handle_charger_type(info, chg_type);
+                break;
+        default:
+                dev_info(info->dev, "misc interrupt: %s occurred\n",
+                         muic_irqs[irq_type].name);
+                break;
+        }
+
+        mutex_unlock(&info->mutex);
+
+        return;
+}
+
+static irqreturn_t max8997_muic_irq_handler(int irq, void *data)
+{
+        struct max8997_muic_info *info = data;
+
+        dev_dbg(info->dev, "irq:%d\n", irq);
+        info->irq = irq;
+
+        schedule_work(&info->irq_work);
+
+        return IRQ_HANDLED;
+}
+
+static void max8997_muic_detect_dev(struct max8997_muic_info *info)
+{
+        int ret;
+        u8 status[2], adc, chg_type;
+
+        ret = max8997_bulk_read(info->muic, MAX8997_MUIC_REG_STATUS1,
+                                2, status);
+        if (ret) {
+                dev_err(info->dev, "failed to read muic register\n");
+                return;
+        }
+
+        dev_info(info->dev, "STATUS1:0x%x, STATUS2:0x%x\n",
+                        status[0], status[1]);
+
+        adc = status[0] & STATUS1_ADC_MASK;
+        adc >>= STATUS1_ADC_SHIFT;
+
+        chg_type = status[1] & STATUS2_CHGTYP_MASK;
+        chg_type >>= STATUS2_CHGTYP_SHIFT;
+
+        max8997_muic_handle_adc(info, adc);
+        max8997_muic_handle_charger_type(info, chg_type);
+}
+
+static void max8997_initialize_device(struct max8997_muic_info *info)
+{
+        struct max8997_muic_platform_data *mdata = info->muic_pdata;
+        int i;
+
+        for (i = 0; i < mdata->num_init_data; i++) {
+                max8997_write_reg(info->muic, mdata->init_data[i].addr,
+                                mdata->init_data[i].data);
+        }
+}
+
+static int __devinit max8997_muic_probe(struct platform_device *pdev)
+{
+        struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct max8997_muic_info *info;
+        int ret, i;
+
+        info = kzalloc(sizeof(struct max8997_muic_info), GFP_KERNEL);
+        if (!info) {
+                dev_err(&pdev->dev, "failed to allocate memory\n");
+                ret = -ENOMEM;
+                goto err_kfree;
+        }
+
+        if (!pdata->muic_pdata) {
+                dev_err(&pdev->dev, "failed to get platform_data\n");
+                ret = -EINVAL;
+                goto err_pdata;
+        }
+        info->muic_pdata = pdata->muic_pdata;
+
+        info->dev = &pdev->dev;
+        info->iodev = iodev;
+        info->muic = iodev->muic;
+
+        platform_set_drvdata(pdev, info);
+        mutex_init(&info->mutex);
+
+        INIT_WORK(&info->irq_work, max8997_muic_irq_work);
+
+        for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) {
+                struct max8997_muic_irq *muic_irq = &muic_irqs[i];
+
+                ret = request_threaded_irq(pdata->irq_base + muic_irq->irq,
+                                NULL, max8997_muic_irq_handler,
+                                0, muic_irq->name,
+                                info);
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "failed: irq request (IRQ: %d,"
+                                " error :%d)\n",
+                                muic_irq->irq, ret);
+
+                        for (i = i - 1; i >= 0; i--)
+                                free_irq(muic_irq->irq, info);
+
+                        goto err_irq;
+                }
+        }
+
+        /* Initialize registers according to platform data */
+        max8997_initialize_device(info);
+
+        /* Initial device detection */
+        max8997_muic_detect_dev(info);
+
+        return ret;
+
+err_irq:
+err_pdata:
+        kfree(info);
+err_kfree:
+        return ret;
+}
+
+static int __devexit max8997_muic_remove(struct platform_device *pdev)
+{
+        struct max8997_muic_info *info = platform_get_drvdata(pdev);
+        struct max8997_platform_data *pdata =
+                                dev_get_platdata(info->iodev->dev);
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(muic_irqs); i++)
+                free_irq(pdata->irq_base + muic_irqs[i].irq, info);
+        cancel_work_sync(&info->irq_work);
+
+        kfree(info);
+
+        return 0;
+}
+
+static struct platform_driver max8997_muic_driver = {
+        .driver         = {
+                .name   = "max8997-muic",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = max8997_muic_probe,
+        .remove         = __devexit_p(max8997_muic_remove),
+};
+
+static int __init max8997_muic_init(void)
+{
+        return platform_driver_register(&max8997_muic_driver);
+}
+module_init(max8997_muic_init);
+
+static void __exit max8997_muic_exit(void)
+{
+        platform_driver_unregister(&max8997_muic_driver);
+}
+module_exit(max8997_muic_exit);
+
+MODULE_DESCRIPTION("Maxim MAX8997 MUIC driver");
+MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/Makefile b/drivers/mmc/Makefile
index 12eef393e216..400756ec7c49 100644
--- a/drivers/mmc/Makefile
+++ b/drivers/mmc/Makefile
@@ -6,5 +6,4 @@ subdir-ccflags-$(CONFIG_MMC_DEBUG) := -DDEBUG
 
 obj-$(CONFIG_MMC)               += core/
 obj-$(CONFIG_MMC)               += card/
-obj-$(CONFIG_MMC)               += host/
-
+obj-$(subst m,y,$(CONFIG_MMC))  += host/
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 1e0e27cbe987..0cad48a284a8 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -107,6 +107,8 @@ struct mmc_blk_data {
          */
         unsigned int    part_curr;
         struct device_attribute force_ro;
+        struct device_attribute power_ro_lock;
+        int     area_type;
 };
 
 static DEFINE_MUTEX(open_lock);
@@ -119,6 +121,7 @@ enum mmc_blk_status {
         MMC_BLK_ABORT,
         MMC_BLK_DATA_ERR,
         MMC_BLK_ECC_ERR,
+        MMC_BLK_NOMEDIUM,
 };
 
 module_param(perdev_minors, int, 0444);
@@ -165,6 +168,70 @@ static void mmc_blk_put(struct mmc_blk_data *md)
         mutex_unlock(&open_lock);
 }
 
+static ssize_t power_ro_lock_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        int ret;
+        struct mmc_blk_data *md = mmc_blk_get(dev_to_disk(dev));
+        struct mmc_card *card = md->queue.card;
+        int locked = 0;
+
+        if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PERM_WP_EN)
+                locked = 2;
+        else if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_EN)
+                locked = 1;
+
+        ret = snprintf(buf, PAGE_SIZE, "%d\n", locked);
+
+        return ret;
+}
+
+static ssize_t power_ro_lock_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        int ret;
+        struct mmc_blk_data *md, *part_md;
+        struct mmc_card *card;
+        unsigned long set;
+
+        if (kstrtoul(buf, 0, &set))
+                return -EINVAL;
+
+        if (set != 1)
+                return count;
+
+        md = mmc_blk_get(dev_to_disk(dev));
+        card = md->queue.card;
+
+        mmc_claim_host(card->host);
+
+        ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_WP,
+                                card->ext_csd.boot_ro_lock |
+                                EXT_CSD_BOOT_WP_B_PWR_WP_EN,
+                                card->ext_csd.part_time);
+        if (ret)
+                pr_err("%s: Locking boot partition ro until next power on failed: %d\n", md->disk->disk_name, ret);
+        else
+                card->ext_csd.boot_ro_lock |= EXT_CSD_BOOT_WP_B_PWR_WP_EN;
+
+        mmc_release_host(card->host);
+
+        if (!ret) {
+                pr_info("%s: Locking boot partition ro until next power on\n",
+                        md->disk->disk_name);
+                set_disk_ro(md->disk, 1);
+
+                list_for_each_entry(part_md, &md->part, part)
+                        if (part_md->area_type == MMC_BLK_DATA_AREA_BOOT) {
+                                pr_info("%s: Locking boot partition ro until next power on\n", part_md->disk->disk_name);
+                                set_disk_ro(part_md->disk, 1);
+                        }
+        }
+
+        mmc_blk_put(md);
+        return count;
+}
+
 static ssize_t force_ro_show(struct device *dev, struct device_attribute *attr,
                              char *buf)
 {
@@ -266,6 +333,9 @@ static struct mmc_blk_ioc_data *mmc_blk_ioctl_copy_from_user(
                 goto idata_err;
         }
 
+        if (!idata->buf_bytes)
+                return idata;
+
         idata->buf = kzalloc(idata->buf_bytes, GFP_KERNEL);
         if (!idata->buf) {
                 err = -ENOMEM;
@@ -312,25 +382,6 @@ static int mmc_blk_ioctl_cmd(struct block_device *bdev,
         if (IS_ERR(idata))
                 return PTR_ERR(idata);
 
-        cmd.opcode = idata->ic.opcode;
-        cmd.arg = idata->ic.arg;
-        cmd.flags = idata->ic.flags;
-
-        data.sg = &sg;
-        data.sg_len = 1;
-        data.blksz = idata->ic.blksz;
-        data.blocks = idata->ic.blocks;
-
-        sg_init_one(data.sg, idata->buf, idata->buf_bytes);
-
-        if (idata->ic.write_flag)
-                data.flags = MMC_DATA_WRITE;
-        else
-                data.flags = MMC_DATA_READ;
-
-        mrq.cmd = &cmd;
-        mrq.data = &data;
-
         md = mmc_blk_get(bdev->bd_disk);
         if (!md) {
                 err = -EINVAL;
@@ -343,6 +394,48 @@ static int mmc_blk_ioctl_cmd(struct block_device *bdev,
                 goto cmd_done;
         }
 
+        cmd.opcode = idata->ic.opcode;
+        cmd.arg = idata->ic.arg;
+        cmd.flags = idata->ic.flags;
+
+        if (idata->buf_bytes) {
+                data.sg = &sg;
+                data.sg_len = 1;
+                data.blksz = idata->ic.blksz;
+                data.blocks = idata->ic.blocks;
+
+                sg_init_one(data.sg, idata->buf, idata->buf_bytes);
+
+                if (idata->ic.write_flag)
+                        data.flags = MMC_DATA_WRITE;
+                else
+                        data.flags = MMC_DATA_READ;
+
+                /* data.flags must already be set before doing this. */
+                mmc_set_data_timeout(&data, card);
+
+                /* Allow overriding the timeout_ns for empirical tuning. */
+                if (idata->ic.data_timeout_ns)
+                        data.timeout_ns = idata->ic.data_timeout_ns;
+
+                if ((cmd.flags & MMC_RSP_R1B) == MMC_RSP_R1B) {
+                        /*
+                         * Pretend this is a data transfer and rely on the
+                         * host driver to compute timeout.  When all host
+                         * drivers support cmd.cmd_timeout for R1B, this
+                         * can be changed to:
+                         *
+                         *     mrq.data = NULL;
+                         *     cmd.cmd_timeout = idata->ic.cmd_timeout_ms;
+                         */
+                        data.timeout_ns = idata->ic.cmd_timeout_ms * 1000000;
+                }
+
+                mrq.data = &data;
+        }
+
+        mrq.cmd = &cmd;
+
         mmc_claim_host(card->host);
 
         if (idata->ic.is_acmd) {
@@ -351,24 +444,6 @@ static int mmc_blk_ioctl_cmd(struct block_device *bdev,
                         goto cmd_rel_host;
         }
 
-        /* data.flags must already be set before doing this. */
-        mmc_set_data_timeout(&data, card);
-        /* Allow overriding the timeout_ns for empirical tuning. */
-        if (idata->ic.data_timeout_ns)
-                data.timeout_ns = idata->ic.data_timeout_ns;
-
-        if ((cmd.flags & MMC_RSP_R1B) == MMC_RSP_R1B) {
-                /*
-                 * Pretend this is a data transfer and rely on the host driver
-                 * to compute timeout.  When all host drivers support
-                 * cmd.cmd_timeout for R1B, this can be changed to:
-                 *
-                 *     mrq.data = NULL;
-                 *     cmd.cmd_timeout = idata->ic.cmd_timeout_ms;
-                 */
-                data.timeout_ns = idata->ic.cmd_timeout_ms * 1000000;
-        }
-
         mmc_wait_for_req(card->host, &mrq);
 
         if (cmd.error) {
@@ -565,6 +640,7 @@ static int get_card_status(struct mmc_card *card, u32 *status, int retries)
         return err;
 }
 
+#define ERR_NOMEDIUM    3
 #define ERR_RETRY       2
 #define ERR_ABORT       1
 #define ERR_CONTINUE    0
@@ -632,6 +708,9 @@ static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
         u32 status, stop_status = 0;
         int err, retry;
 
+        if (mmc_card_removed(card))
+                return ERR_NOMEDIUM;
+
         /*
          * Try to get card status which indicates both the card state
          * and why there was no response.  If the first attempt fails,
@@ -648,8 +727,12 @@ static int mmc_blk_cmd_recovery(struct mmc_card *card, struct request *req,
         }
 
         /* We couldn't get a response from the card.  Give up. */
-        if (err)
+        if (err) {
+                /* Check if the card is removed */
+                if (mmc_detect_card_removed(card->host))
+                        return ERR_NOMEDIUM;
                 return ERR_ABORT;
+        }
 
         /* Flag ECC errors */
         if ((status & R1_CARD_ECC_FAILED) ||
@@ -922,6 +1005,8 @@ static int mmc_blk_err_check(struct mmc_card *card,
                         return MMC_BLK_RETRY;
                 case ERR_ABORT:
                         return MMC_BLK_ABORT;
+                case ERR_NOMEDIUM:
+                        return MMC_BLK_NOMEDIUM;
                 case ERR_CONTINUE:
                         break;
                 }
@@ -1255,6 +1340,8 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
                         if (!ret)
                                 goto start_new_req;
                         break;
+                case MMC_BLK_NOMEDIUM:
+                        goto cmd_abort;
                 }
 
                 if (ret) {
@@ -1271,6 +1358,8 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
 
  cmd_abort:
         spin_lock_irq(&md->lock);
+        if (mmc_card_removed(card))
+                req->cmd_flags |= REQ_QUIET;
         while (ret)
                 ret = __blk_end_request(req, -EIO, blk_rq_cur_bytes(req));
         spin_unlock_irq(&md->lock);
@@ -1339,7 +1428,8 @@ static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
                                               struct device *parent,
                                               sector_t size,
                                               bool default_ro,
-                                              const char *subname)
+                                              const char *subname,
+                                              int area_type)
 {
         struct mmc_blk_data *md;
         int devidx, ret;
@@ -1364,11 +1454,12 @@ static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
         if (!subname) {
                 md->name_idx = find_first_zero_bit(name_use, max_devices);
                 __set_bit(md->name_idx, name_use);
-        }
-        else
+        } else
                 md->name_idx = ((struct mmc_blk_data *)
                                 dev_to_disk(parent)->private_data)->name_idx;
 
+        md->area_type = area_type;
+
         /*
          * Set the read-only status based on the supported commands
          * and the write protect switch.
@@ -1462,7 +1553,8 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
                 size = card->csd.capacity << (card->csd.read_blkbits - 9);
         }
 
-        md = mmc_blk_alloc_req(card, &card->dev, size, false, NULL);
+        md = mmc_blk_alloc_req(card, &card->dev, size, false, NULL,
+                                        MMC_BLK_DATA_AREA_MAIN);
         return md;
 }
 
@@ -1471,13 +1563,14 @@ static int mmc_blk_alloc_part(struct mmc_card *card,
                               unsigned int part_type,
                               sector_t size,
                               bool default_ro,
-                              const char *subname)
+                              const char *subname,
+                              int area_type)
 {
         char cap_str[10];
         struct mmc_blk_data *part_md;
 
         part_md = mmc_blk_alloc_req(card, disk_to_dev(md->disk), size, default_ro,
-                                    subname);
+                                    subname, area_type);
         if (IS_ERR(part_md))
                 return PTR_ERR(part_md);
         part_md->part_type = part_type;
@@ -1510,7 +1603,8 @@ static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md)
                                 card->part[idx].part_cfg,
                                 card->part[idx].size >> 9,
                                 card->part[idx].force_ro,
-                                card->part[idx].name);
+                                card->part[idx].name,
+                                card->part[idx].area_type);
                         if (ret)
                                 return ret;
                 }
@@ -1539,9 +1633,16 @@ mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
 
 static void mmc_blk_remove_req(struct mmc_blk_data *md)
 {
+        struct mmc_card *card;
+
         if (md) {
+                card = md->queue.card;
                 if (md->disk->flags & GENHD_FL_UP) {
                         device_remove_file(disk_to_dev(md->disk), &md->force_ro);
+                        if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
+                                        card->ext_csd.boot_ro_lockable)
+                                device_remove_file(disk_to_dev(md->disk),
+                                        &md->power_ro_lock);
 
                         /* Stop new requests from getting into the queue */
                         del_gendisk(md->disk);
@@ -1570,6 +1671,7 @@ static void mmc_blk_remove_parts(struct mmc_card *card,
 static int mmc_add_disk(struct mmc_blk_data *md)
 {
         int ret;
+        struct mmc_card *card = md->queue.card;
 
         add_disk(md->disk);
         md->force_ro.show = force_ro_show;
@@ -1579,18 +1681,53 @@ static int mmc_add_disk(struct mmc_blk_data *md)
         md->force_ro.attr.mode = S_IRUGO | S_IWUSR;
         ret = device_create_file(disk_to_dev(md->disk), &md->force_ro);
         if (ret)
-                del_gendisk(md->disk);
+                goto force_ro_fail;
+
+        if ((md->area_type & MMC_BLK_DATA_AREA_BOOT) &&
+             card->ext_csd.boot_ro_lockable) {
+                mode_t mode;
+
+                if (card->ext_csd.boot_ro_lock & EXT_CSD_BOOT_WP_B_PWR_WP_DIS)
+                        mode = S_IRUGO;
+                else
+                        mode = S_IRUGO | S_IWUSR;
+
+                md->power_ro_lock.show = power_ro_lock_show;
+                md->power_ro_lock.store = power_ro_lock_store;
+                md->power_ro_lock.attr.mode = mode;
+                md->power_ro_lock.attr.name =
+                                        "ro_lock_until_next_power_on";
+                ret = device_create_file(disk_to_dev(md->disk),
+                                &md->power_ro_lock);
+                if (ret)
+                        goto power_ro_lock_fail;
+        }
+        return ret;
+
+power_ro_lock_fail:
+        device_remove_file(disk_to_dev(md->disk), &md->force_ro);
+force_ro_fail:
+        del_gendisk(md->disk);
 
         return ret;
 }
 
+#define CID_MANFID_SANDISK      0x2
+#define CID_MANFID_TOSHIBA      0x11
+#define CID_MANFID_MICRON       0x13
+
 static const struct mmc_fixup blk_fixups[] =
 {
-        MMC_FIXUP("SEM02G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
-        MMC_FIXUP("SEM04G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
-        MMC_FIXUP("SEM08G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
-        MMC_FIXUP("SEM16G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
-        MMC_FIXUP("SEM32G", 0x2, 0x100, add_quirk, MMC_QUIRK_INAND_CMD38),
+        MMC_FIXUP("SEM02G", CID_MANFID_SANDISK, 0x100, add_quirk,
+                  MMC_QUIRK_INAND_CMD38),
+        MMC_FIXUP("SEM04G", CID_MANFID_SANDISK, 0x100, add_quirk,
+                  MMC_QUIRK_INAND_CMD38),
+        MMC_FIXUP("SEM08G", CID_MANFID_SANDISK, 0x100, add_quirk,
+                  MMC_QUIRK_INAND_CMD38),
+        MMC_FIXUP("SEM16G", CID_MANFID_SANDISK, 0x100, add_quirk,
+                  MMC_QUIRK_INAND_CMD38),
+        MMC_FIXUP("SEM32G", CID_MANFID_SANDISK, 0x100, add_quirk,
+                  MMC_QUIRK_INAND_CMD38),
 
         /*
          * Some MMC cards experience performance degradation with CMD23
@@ -1600,18 +1737,18 @@ static const struct mmc_fixup blk_fixups[] =
          *
          * N.B. This doesn't affect SD cards.
          */
-        MMC_FIXUP("MMC08G", 0x11, CID_OEMID_ANY, add_quirk_mmc,
+        MMC_FIXUP("MMC08G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
                   MMC_QUIRK_BLK_NO_CMD23),
-        MMC_FIXUP("MMC16G", 0x11, CID_OEMID_ANY, add_quirk_mmc,
+        MMC_FIXUP("MMC16G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
                   MMC_QUIRK_BLK_NO_CMD23),
-        MMC_FIXUP("MMC32G", 0x11, CID_OEMID_ANY, add_quirk_mmc,
+        MMC_FIXUP("MMC32G", CID_MANFID_TOSHIBA, CID_OEMID_ANY, add_quirk_mmc,
                   MMC_QUIRK_BLK_NO_CMD23),
 
         /*
          * Some Micron MMC cards needs longer data read timeout than
          * indicated in CSD.
          */
-        MMC_FIXUP(CID_NAME_ANY, 0x13, 0x200, add_quirk_mmc,
+        MMC_FIXUP(CID_NAME_ANY, CID_MANFID_MICRON, 0x200, add_quirk_mmc,
                   MMC_QUIRK_LONG_READ_TIME),
 
         END_FIXUP
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index e99bdc18002d..759714ed6bee 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -1581,6 +1581,7 @@ static int mmc_test_area_init(struct mmc_test_card *test, int erase, int fill)
 
         t->max_segs = test->card->host->max_segs;
         t->max_seg_sz = test->card->host->max_seg_size;
+        t->max_seg_sz -= t->max_seg_sz % 512;
 
         t->max_tfr = t->max_sz;
         if (t->max_tfr >> 9 > test->card->host->max_blk_count)
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index dcad59cbfef1..2517547b4366 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -29,6 +29,8 @@
  */
 static int mmc_prep_request(struct request_queue *q, struct request *req)
 {
+        struct mmc_queue *mq = q->queuedata;
+
         /*
          * We only like normal block requests and discards.
          */
@@ -37,6 +39,9 @@ static int mmc_prep_request(struct request_queue *q, struct request *req)
                 return BLKPREP_KILL;
         }
 
+        if (mq && mmc_card_removed(mq->card))
+                return BLKPREP_KILL;
+
         req->cmd_flags |= REQ_DONTPREP;
 
         return BLKPREP_OK;
diff --git a/drivers/mmc/core/Makefile b/drivers/mmc/core/Makefile
index 639501970b41..dca4428380f1 100644
--- a/drivers/mmc/core/Makefile
+++ b/drivers/mmc/core/Makefile
@@ -7,6 +7,6 @@ mmc_core-y			:= core.o bus.o host.o \
                                    mmc.o mmc_ops.o sd.o sd_ops.o \
                                    sdio.o sdio_ops.o sdio_bus.o \
                                    sdio_cis.o sdio_io.o sdio_irq.o \
-                                   quirks.o
+                                   quirks.o cd-gpio.o
 
 mmc_core-$(CONFIG_DEBUG_FS)     += debugfs.o
diff --git a/drivers/mmc/core/bus.c b/drivers/mmc/core/bus.c
index 6be49249895a..5d011a39dfff 100644
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -303,10 +303,11 @@ int mmc_add_card(struct mmc_card *card)
                         mmc_card_ddr_mode(card) ? "DDR " : "",
                         type);
         } else {
-                printk(KERN_INFO "%s: new %s%s%s card at address %04x\n",
+                pr_info("%s: new %s%s%s%s card at address %04x\n",
                         mmc_hostname(card->host),
-                        mmc_sd_card_uhs(card) ? "ultra high speed " :
+                        mmc_card_uhs(card) ? "ultra high speed " :
                         (mmc_card_highspeed(card) ? "high speed " : ""),
+                        (mmc_card_hs200(card) ? "HS200 " : ""),
                         mmc_card_ddr_mode(card) ? "DDR " : "",
                         type, card->rca);
         }
diff --git a/drivers/mmc/core/cd-gpio.c b/drivers/mmc/core/cd-gpio.c
new file mode 100644
index 000000000000..082202ae4a03
--- /dev/null
+++ b/drivers/mmc/core/cd-gpio.c
@@ -0,0 +1,74 @@
+/*
+ * Generic GPIO card-detect helper
+ *
+ * Copyright (C) 2011, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * 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/err.h>
+#include <linux/gpio.h>
+#include <linux/interrupt.h>
+#include <linux/jiffies.h>
+#include <linux/mmc/host.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+struct mmc_cd_gpio {
+        unsigned int gpio;
+        char label[0];
+};
+
+static irqreturn_t mmc_cd_gpio_irqt(int irq, void *dev_id)
+{
+        /* Schedule a card detection after a debounce timeout */
+        mmc_detect_change(dev_id, msecs_to_jiffies(100));
+        return IRQ_HANDLED;
+}
+
+int mmc_cd_gpio_request(struct mmc_host *host, unsigned int gpio,
+                        unsigned int irq, unsigned long flags)
+{
+        size_t len = strlen(dev_name(host->parent)) + 4;
+        struct mmc_cd_gpio *cd = kmalloc(sizeof(*cd) + len, GFP_KERNEL);
+        int ret;
+
+        if (!cd)
+                return -ENOMEM;
+
+        snprintf(cd->label, len, "%s cd", dev_name(host->parent));
+
+        ret = gpio_request_one(gpio, GPIOF_DIR_IN, cd->label);
+        if (ret < 0)
+                goto egpioreq;
+
+        ret = request_threaded_irq(irq, NULL, mmc_cd_gpio_irqt,
+                                   flags, cd->label, host);
+        if (ret < 0)
+                goto eirqreq;
+
+        cd->gpio = gpio;
+        host->hotplug.irq = irq;
+        host->hotplug.handler_priv = cd;
+
+        return 0;
+
+eirqreq:
+        gpio_free(gpio);
+egpioreq:
+        kfree(cd);
+        return ret;
+}
+EXPORT_SYMBOL(mmc_cd_gpio_request);
+
+void mmc_cd_gpio_free(struct mmc_host *host)
+{
+        struct mmc_cd_gpio *cd = host->hotplug.handler_priv;
+
+        free_irq(host->hotplug.irq, host);
+        gpio_free(cd->gpio);
+        kfree(cd);
+}
+EXPORT_SYMBOL(mmc_cd_gpio_free);
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 75d7d7e17366..f545a3e6eb80 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -140,7 +140,7 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
                         cmd->retries = 0;
         }
 
-        if (err && cmd->retries) {
+        if (err && cmd->retries && !mmc_card_removed(host->card)) {
                 /*
                  * Request starter must handle retries - see
                  * mmc_wait_for_req_done().
@@ -247,6 +247,11 @@ static void __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
 {
         init_completion(&mrq->completion);
         mrq->done = mmc_wait_done;
+        if (mmc_card_removed(host->card)) {
+                mrq->cmd->error = -ENOMEDIUM;
+                complete(&mrq->completion);
+                return;
+        }
         mmc_start_request(host, mrq);
 }
 
@@ -259,7 +264,8 @@ static void mmc_wait_for_req_done(struct mmc_host *host,
                 wait_for_completion(&mrq->completion);
 
                 cmd = mrq->cmd;
-                if (!cmd->error || !cmd->retries)
+                if (!cmd->error || !cmd->retries ||
+                    mmc_card_removed(host->card))
                         break;
 
                 pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
@@ -1456,7 +1462,7 @@ void mmc_detect_change(struct mmc_host *host, unsigned long delay)
         WARN_ON(host->removed);
         spin_unlock_irqrestore(&host->lock, flags);
 #endif
-
+        host->detect_change = 1;
         mmc_schedule_delayed_work(&host->detect, delay);
 }
 
@@ -2049,6 +2055,43 @@ static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
         return -EIO;
 }
 
+int _mmc_detect_card_removed(struct mmc_host *host)
+{
+        int ret;
+
+        if ((host->caps & MMC_CAP_NONREMOVABLE) || !host->bus_ops->alive)
+                return 0;
+
+        if (!host->card || mmc_card_removed(host->card))
+                return 1;
+
+        ret = host->bus_ops->alive(host);
+        if (ret) {
+                mmc_card_set_removed(host->card);
+                pr_debug("%s: card remove detected\n", mmc_hostname(host));
+        }
+
+        return ret;
+}
+
+int mmc_detect_card_removed(struct mmc_host *host)
+{
+        struct mmc_card *card = host->card;
+
+        WARN_ON(!host->claimed);
+        /*
+         * The card will be considered unchanged unless we have been asked to
+         * detect a change or host requires polling to provide card detection.
+         */
+        if (card && !host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL))
+                return mmc_card_removed(card);
+
+        host->detect_change = 0;
+
+        return _mmc_detect_card_removed(host);
+}
+EXPORT_SYMBOL(mmc_detect_card_removed);
+
 void mmc_rescan(struct work_struct *work)
 {
         static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
@@ -2069,6 +2112,8 @@ void mmc_rescan(struct work_struct *work)
             && !(host->caps & MMC_CAP_NONREMOVABLE))
                 host->bus_ops->detect(host);
 
+        host->detect_change = 0;
+
         /*
          * Let mmc_bus_put() free the bus/bus_ops if we've found that
          * the card is no longer present.
@@ -2130,6 +2175,7 @@ void mmc_stop_host(struct mmc_host *host)
 
         mmc_bus_get(host);
         if (host->bus_ops && !host->bus_dead) {
+                /* Calling bus_ops->remove() with a claimed host can deadlock */
                 if (host->bus_ops->remove)
                         host->bus_ops->remove(host);
 
@@ -2201,6 +2247,9 @@ int mmc_card_awake(struct mmc_host *host)
 {
         int err = -ENOSYS;
 
+        if (host->caps2 & MMC_CAP2_NO_SLEEP_CMD)
+                return 0;
+
         mmc_bus_get(host);
 
         if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
@@ -2216,6 +2265,9 @@ int mmc_card_sleep(struct mmc_host *host)
 {
         int err = -ENOSYS;
 
+        if (host->caps2 & MMC_CAP2_NO_SLEEP_CMD)
+                return 0;
+
         mmc_bus_get(host);
 
         if (host->bus_ops && !host->bus_dead && host->bus_ops->sleep)
@@ -2270,6 +2322,7 @@ EXPORT_SYMBOL(mmc_flush_cache);
 int mmc_cache_ctrl(struct mmc_host *host, u8 enable)
 {
         struct mmc_card *card = host->card;
+        unsigned int timeout;
         int err = 0;
 
         if (!(host->caps2 & MMC_CAP2_CACHE_CTRL) ||
@@ -2280,16 +2333,18 @@ int mmc_cache_ctrl(struct mmc_host *host, u8 enable)
                         (card->ext_csd.cache_size > 0)) {
                 enable = !!enable;
 
-                if (card->ext_csd.cache_ctrl ^ enable)
+                if (card->ext_csd.cache_ctrl ^ enable) {
+                        timeout = enable ? card->ext_csd.generic_cmd6_time : 0;
                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                                        EXT_CSD_CACHE_CTRL, enable, 0);
-                if (err)
-                        pr_err("%s: cache %s error %d\n",
-                                        mmc_hostname(card->host),
-                                        enable ? "on" : "off",
-                                        err);
-                else
-                        card->ext_csd.cache_ctrl = enable;
+                                        EXT_CSD_CACHE_CTRL, enable, timeout);
+                        if (err)
+                                pr_err("%s: cache %s error %d\n",
+                                                mmc_hostname(card->host),
+                                                enable ? "on" : "off",
+                                                err);
+                        else
+                                card->ext_csd.cache_ctrl = enable;
+                }
         }
 
         return err;
@@ -2310,7 +2365,13 @@ int mmc_suspend_host(struct mmc_host *host)
                 cancel_delayed_work(&host->disable);
         cancel_delayed_work(&host->detect);
         mmc_flush_scheduled_work();
-        err = mmc_cache_ctrl(host, 0);
+        if (mmc_try_claim_host(host)) {
+                err = mmc_cache_ctrl(host, 0);
+                mmc_do_release_host(host);
+        } else {
+                err = -EBUSY;
+        }
+
         if (err)
                 goto out;
 
@@ -2338,7 +2399,9 @@ int mmc_suspend_host(struct mmc_host *host)
                         if (err == -ENOSYS || !host->bus_ops->resume) {
                                 /*
                                  * We simply "remove" the card in this case.
-                                 * It will be redetected on resume.
+                                 * It will be redetected on resume.  (Calling
+                                 * bus_ops->remove() with a claimed host can
+                                 * deadlock.)
                                  */
                                 if (host->bus_ops->remove)
                                         host->bus_ops->remove(host);
@@ -2431,11 +2494,11 @@ int mmc_pm_notify(struct notifier_block *notify_block,
                 if (!host->bus_ops || host->bus_ops->suspend)
                         break;
 
-                mmc_claim_host(host);
-
+                /* Calling bus_ops->remove() with a claimed host can deadlock */
                 if (host->bus_ops->remove)
                         host->bus_ops->remove(host);
 
+                mmc_claim_host(host);
                 mmc_detach_bus(host);
                 mmc_power_off(host);
                 mmc_release_host(host);
diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
index afa6bd2b7b70..3bdafbca354f 100644
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -24,6 +24,7 @@ struct mmc_bus_ops {
         int (*resume)(struct mmc_host *);
         int (*power_save)(struct mmc_host *);
         int (*power_restore)(struct mmc_host *);
+        int (*alive)(struct mmc_host *);
 };
 
 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops);
@@ -59,6 +60,8 @@ void mmc_rescan(struct work_struct *work);
 void mmc_start_host(struct mmc_host *host);
 void mmc_stop_host(struct mmc_host *host);
 
+int _mmc_detect_card_removed(struct mmc_host *host);
+
 int mmc_attach_mmc(struct mmc_host *host);
 int mmc_attach_sd(struct mmc_host *host);
 int mmc_attach_sdio(struct mmc_host *host);
diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c
index 3923880118b6..9ab5b17d488a 100644
--- a/drivers/mmc/core/debugfs.c
+++ b/drivers/mmc/core/debugfs.c
@@ -57,6 +57,8 @@ static int mmc_ios_show(struct seq_file *s, void *data)
         const char *str;
 
         seq_printf(s, "clock:\t\t%u Hz\n", ios->clock);
+        if (host->actual_clock)
+                seq_printf(s, "actual clock:\t%u Hz\n", host->actual_clock);
         seq_printf(s, "vdd:\t\t%u ", ios->vdd);
         if ((1 << ios->vdd) & MMC_VDD_165_195)
                 seq_printf(s, "(1.65 - 1.95 V)\n");
@@ -133,6 +135,9 @@ static int mmc_ios_show(struct seq_file *s, void *data)
         case MMC_TIMING_UHS_DDR50:
                 str = "sd uhs DDR50";
                 break;
+        case MMC_TIMING_MMC_HS200:
+                str = "mmc high-speed SDR200";
+                break;
         default:
                 str = "invalid";
                 break;
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index d31c78b72b0f..30055f2b0d44 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -54,6 +54,27 @@ static DEFINE_IDR(mmc_host_idr);
 static DEFINE_SPINLOCK(mmc_host_lock);
 
 #ifdef CONFIG_MMC_CLKGATE
+static ssize_t clkgate_delay_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct mmc_host *host = cls_dev_to_mmc_host(dev);
+        return snprintf(buf, PAGE_SIZE, "%lu\n", host->clkgate_delay);
+}
+
+static ssize_t clkgate_delay_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct mmc_host *host = cls_dev_to_mmc_host(dev);
+        unsigned long flags, value;
+
+        if (kstrtoul(buf, 0, &value))
+                return -EINVAL;
+
+        spin_lock_irqsave(&host->clk_lock, flags);
+        host->clkgate_delay = value;
+        spin_unlock_irqrestore(&host->clk_lock, flags);
+        return count;
+}
 
 /*
  * Enabling clock gating will make the core call out to the host
@@ -114,7 +135,7 @@ static void mmc_host_clk_gate_delayed(struct mmc_host *host)
 static void mmc_host_clk_gate_work(struct work_struct *work)
 {
         struct mmc_host *host = container_of(work, struct mmc_host,
-                                              clk_gate_work);
+                                              clk_gate_work.work);
 
         mmc_host_clk_gate_delayed(host);
 }
@@ -131,6 +152,8 @@ void mmc_host_clk_hold(struct mmc_host *host)
 {
         unsigned long flags;
 
+        /* cancel any clock gating work scheduled by mmc_host_clk_release() */
+        cancel_delayed_work_sync(&host->clk_gate_work);
         mutex_lock(&host->clk_gate_mutex);
         spin_lock_irqsave(&host->clk_lock, flags);
         if (host->clk_gated) {
@@ -180,7 +203,8 @@ void mmc_host_clk_release(struct mmc_host *host)
         host->clk_requests--;
         if (mmc_host_may_gate_card(host->card) &&
             !host->clk_requests)
-                queue_work(system_nrt_wq, &host->clk_gate_work);
+                queue_delayed_work(system_nrt_wq, &host->clk_gate_work,
+                                msecs_to_jiffies(host->clkgate_delay));
         spin_unlock_irqrestore(&host->clk_lock, flags);
 }
 
@@ -213,8 +237,13 @@ static inline void mmc_host_clk_init(struct mmc_host *host)
         host->clk_requests = 0;
         /* Hold MCI clock for 8 cycles by default */
         host->clk_delay = 8;
+        /*
+         * Default clock gating delay is 200ms.
+         * This value can be tuned by writing into sysfs entry.
+         */
+        host->clkgate_delay = 200;
         host->clk_gated = false;
-        INIT_WORK(&host->clk_gate_work, mmc_host_clk_gate_work);
+        INIT_DELAYED_WORK(&host->clk_gate_work, mmc_host_clk_gate_work);
         spin_lock_init(&host->clk_lock);
         mutex_init(&host->clk_gate_mutex);
 }
@@ -229,7 +258,7 @@ static inline void mmc_host_clk_exit(struct mmc_host *host)
          * Wait for any outstanding gate and then make sure we're
          * ungated before exiting.
          */
-        if (cancel_work_sync(&host->clk_gate_work))
+        if (cancel_delayed_work_sync(&host->clk_gate_work))
                 mmc_host_clk_gate_delayed(host);
         if (host->clk_gated)
                 mmc_host_clk_hold(host);
@@ -237,6 +266,17 @@ static inline void mmc_host_clk_exit(struct mmc_host *host)
         WARN_ON(host->clk_requests > 1);
 }
 
+static inline void mmc_host_clk_sysfs_init(struct mmc_host *host)
+{
+        host->clkgate_delay_attr.show = clkgate_delay_show;
+        host->clkgate_delay_attr.store = clkgate_delay_store;
+        sysfs_attr_init(&host->clkgate_delay_attr.attr);
+        host->clkgate_delay_attr.attr.name = "clkgate_delay";
+        host->clkgate_delay_attr.attr.mode = S_IRUGO | S_IWUSR;
+        if (device_create_file(&host->class_dev, &host->clkgate_delay_attr))
+                pr_err("%s: Failed to create clkgate_delay sysfs entry\n",
+                                mmc_hostname(host));
+}
 #else
 
 static inline void mmc_host_clk_init(struct mmc_host *host)
@@ -247,6 +287,10 @@ static inline void mmc_host_clk_exit(struct mmc_host *host)
 {
 }
 
+static inline void mmc_host_clk_sysfs_init(struct mmc_host *host)
+{
+}
+
 #endif
 
 /**
@@ -335,6 +379,7 @@ int mmc_add_host(struct mmc_host *host)
 #ifdef CONFIG_DEBUG_FS
         mmc_add_host_debugfs(host);
 #endif
+        mmc_host_clk_sysfs_init(host);
 
         mmc_start_host(host);
         register_pm_notifier(&host->pm_notify);
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index d240427c1246..59b9ba52e66a 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -286,6 +286,27 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
         }
         card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
         switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) {
+        case EXT_CSD_CARD_TYPE_SDR_ALL:
+        case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_1_8V:
+        case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_1_2V:
+        case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_52:
+                card->ext_csd.hs_max_dtr = 200000000;
+                card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_200;
+                break;
+        case EXT_CSD_CARD_TYPE_SDR_1_2V_ALL:
+        case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_1_8V:
+        case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_1_2V:
+        case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_52:
+                card->ext_csd.hs_max_dtr = 200000000;
+                card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_1_2V;
+                break;
+        case EXT_CSD_CARD_TYPE_SDR_1_8V_ALL:
+        case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_1_8V:
+        case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_1_2V:
+        case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_52:
+                card->ext_csd.hs_max_dtr = 200000000;
+                card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_1_8V;
+                break;
         case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 |
              EXT_CSD_CARD_TYPE_26:
                 card->ext_csd.hs_max_dtr = 52000000;
@@ -348,7 +369,8 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
                                 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
                                 mmc_part_add(card, part_size,
                                         EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
-                                        "boot%d", idx, true);
+                                        "boot%d", idx, true,
+                                        MMC_BLK_DATA_AREA_BOOT);
                         }
                 }
         }
@@ -435,7 +457,8 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
                                         hc_wp_grp_sz);
                                 mmc_part_add(card, part_size << 19,
                                         EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
-                                        "gp%d", idx, false);
+                                        "gp%d", idx, false,
+                                        MMC_BLK_DATA_AREA_GP);
                         }
                 }
                 card->ext_csd.sec_trim_mult =
@@ -446,6 +469,14 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
                         ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
                 card->ext_csd.trim_timeout = 300 *
                         ext_csd[EXT_CSD_TRIM_MULT];
+
+                /*
+                 * Note that the call to mmc_part_add above defaults to read
+                 * only. If this default assumption is changed, the call must
+                 * take into account the value of boot_locked below.
+                 */
+                card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
+                card->ext_csd.boot_ro_lockable = true;
         }
 
         if (card->ext_csd.rev >= 5) {
@@ -690,6 +721,79 @@ static int mmc_select_powerclass(struct mmc_card *card,
 }
 
 /*
+ * Selects the desired buswidth and switch to the HS200 mode
+ * if bus width set without error
+ */
+static int mmc_select_hs200(struct mmc_card *card)
+{
+        int idx, err = 0;
+        struct mmc_host *host;
+        static unsigned ext_csd_bits[] = {
+                EXT_CSD_BUS_WIDTH_4,
+                EXT_CSD_BUS_WIDTH_8,
+        };
+        static unsigned bus_widths[] = {
+                MMC_BUS_WIDTH_4,
+                MMC_BUS_WIDTH_8,
+        };
+
+        BUG_ON(!card);
+
+        host = card->host;
+
+        if (card->ext_csd.card_type & EXT_CSD_CARD_TYPE_SDR_1_2V &&
+            host->caps2 & MMC_CAP2_HS200_1_2V_SDR)
+                if (mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120, 0))
+                        err = mmc_set_signal_voltage(host,
+                                                     MMC_SIGNAL_VOLTAGE_180, 0);
+
+        /* If fails try again during next card power cycle */
+        if (err)
+                goto err;
+
+        idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 1 : 0;
+
+        /*
+         * Unlike SD, MMC cards dont have a configuration register to notify
+         * supported bus width. So bus test command should be run to identify
+         * the supported bus width or compare the ext csd values of current
+         * bus width and ext csd values of 1 bit mode read earlier.
+         */
+        for (; idx >= 0; idx--) {
+
+                /*
+                 * Host is capable of 8bit transfer, then switch
+                 * the device to work in 8bit transfer mode. If the
+                 * mmc switch command returns error then switch to
+                 * 4bit transfer mode. On success set the corresponding
+                 * bus width on the host.
+                 */
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                 EXT_CSD_BUS_WIDTH,
+                                 ext_csd_bits[idx],
+                                 card->ext_csd.generic_cmd6_time);
+                if (err)
+                        continue;
+
+                mmc_set_bus_width(card->host, bus_widths[idx]);
+
+                if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
+                        err = mmc_compare_ext_csds(card, bus_widths[idx]);
+                else
+                        err = mmc_bus_test(card, bus_widths[idx]);
+                if (!err)
+                        break;
+        }
+
+        /* switch to HS200 mode if bus width set successfully */
+        if (!err)
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                 EXT_CSD_HS_TIMING, 2, 0);
+err:
+        return err;
+}
+
+/*
  * Handle the detection and initialisation of a card.
  *
  * In the case of a resume, "oldcard" will contain the card
@@ -895,11 +999,15 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         /*
          * Activate high speed (if supported)
          */
-        if ((card->ext_csd.hs_max_dtr != 0) &&
-                (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
-                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                                 EXT_CSD_HS_TIMING, 1,
-                                 card->ext_csd.generic_cmd6_time);
+        if (card->ext_csd.hs_max_dtr != 0) {
+                err = 0;
+                if (card->ext_csd.hs_max_dtr > 52000000 &&
+                    host->caps2 & MMC_CAP2_HS200)
+                        err = mmc_select_hs200(card);
+                else if (host->caps & MMC_CAP_MMC_HIGHSPEED)
+                        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                         EXT_CSD_HS_TIMING, 1, 0);
+
                 if (err && err != -EBADMSG)
                         goto free_card;
 
@@ -908,8 +1016,15 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                                mmc_hostname(card->host));
                         err = 0;
                 } else {
-                        mmc_card_set_highspeed(card);
-                        mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
+                        if (card->ext_csd.hs_max_dtr > 52000000 &&
+                            host->caps2 & MMC_CAP2_HS200) {
+                                mmc_card_set_hs200(card);
+                                mmc_set_timing(card->host,
+                                               MMC_TIMING_MMC_HS200);
+                        } else {
+                                mmc_card_set_highspeed(card);
+                                mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
+                        }
                 }
         }
 
@@ -934,7 +1049,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
          */
         max_dtr = (unsigned int)-1;
 
-        if (mmc_card_highspeed(card)) {
+        if (mmc_card_highspeed(card) || mmc_card_hs200(card)) {
                 if (max_dtr > card->ext_csd.hs_max_dtr)
                         max_dtr = card->ext_csd.hs_max_dtr;
         } else if (max_dtr > card->csd.max_dtr) {
@@ -960,9 +1075,48 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         }
 
         /*
+         * Indicate HS200 SDR mode (if supported).
+         */
+        if (mmc_card_hs200(card)) {
+                u32 ext_csd_bits;
+                u32 bus_width = card->host->ios.bus_width;
+
+                /*
+                 * For devices supporting HS200 mode, the bus width has
+                 * to be set before executing the tuning function. If
+                 * set before tuning, then device will respond with CRC
+                 * errors for responses on CMD line. So for HS200 the
+                 * sequence will be
+                 * 1. set bus width 4bit / 8 bit (1 bit not supported)
+                 * 2. switch to HS200 mode
+                 * 3. set the clock to > 52Mhz <=200MHz and
+                 * 4. execute tuning for HS200
+                 */
+                if ((host->caps2 & MMC_CAP2_HS200) &&
+                    card->host->ops->execute_tuning)
+                        err = card->host->ops->execute_tuning(card->host,
+                                MMC_SEND_TUNING_BLOCK_HS200);
+                if (err) {
+                        pr_warning("%s: tuning execution failed\n",
+                                   mmc_hostname(card->host));
+                        goto err;
+                }
+
+                ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
+                                EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
+                err = mmc_select_powerclass(card, ext_csd_bits, ext_csd);
+                if (err) {
+                        pr_err("%s: power class selection to bus width %d failed\n",
+                                mmc_hostname(card->host), 1 << bus_width);
+                        goto err;
+                }
+        }
+
+        /*
          * Activate wide bus and DDR (if supported).
          */
-        if ((card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
+        if (!mmc_card_hs200(card) &&
+            (card->csd.mmca_vsn >= CSD_SPEC_VER_3) &&
             (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
                 static unsigned ext_csd_bits[][2] = {
                         { EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8 },
@@ -1048,7 +1202,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                          *
                          * WARNING: eMMC rules are NOT the same as SD DDR
                          */
-                        if (ddr == EXT_CSD_CARD_TYPE_DDR_1_2V) {
+                        if (ddr == MMC_1_2V_DDR_MODE) {
                                 err = mmc_set_signal_voltage(host,
                                         MMC_SIGNAL_VOLTAGE_120, 0);
                                 if (err)
@@ -1067,14 +1221,23 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         if ((host->caps2 & MMC_CAP2_CACHE_CTRL) &&
                         card->ext_csd.cache_size > 0) {
                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
-                                EXT_CSD_CACHE_CTRL, 1, 0);
+                                EXT_CSD_CACHE_CTRL, 1,
+                                card->ext_csd.generic_cmd6_time);
                 if (err && err != -EBADMSG)
                         goto free_card;
 
                 /*
                  * Only if no error, cache is turned on successfully.
                  */
-                card->ext_csd.cache_ctrl = err ? 0 : 1;
+                if (err) {
+                        pr_warning("%s: Cache is supported, "
+                                        "but failed to turn on (%d)\n",
+                                        mmc_hostname(card->host), err);
+                        card->ext_csd.cache_ctrl = 0;
+                        err = 0;
+                } else {
+                        card->ext_csd.cache_ctrl = 1;
+                }
         }
 
         if (!oldcard)
@@ -1105,6 +1268,14 @@ static void mmc_remove(struct mmc_host *host)
 }
 
 /*
+ * Card detection - card is alive.
+ */
+static int mmc_alive(struct mmc_host *host)
+{
+        return mmc_send_status(host->card, NULL);
+}
+
+/*
  * Card detection callback from host.
  */
 static void mmc_detect(struct mmc_host *host)
@@ -1119,7 +1290,7 @@ static void mmc_detect(struct mmc_host *host)
         /*
          * Just check if our card has been removed.
          */
-        err = mmc_send_status(host->card, NULL);
+        err = _mmc_detect_card_removed(host);
 
         mmc_release_host(host);
 
@@ -1224,6 +1395,7 @@ static const struct mmc_bus_ops mmc_ops = {
         .suspend = NULL,
         .resume = NULL,
         .power_restore = mmc_power_restore,
+        .alive = mmc_alive,
 };
 
 static const struct mmc_bus_ops mmc_ops_unsafe = {
@@ -1234,6 +1406,7 @@ static const struct mmc_bus_ops mmc_ops_unsafe = {
         .suspend = mmc_suspend,
         .resume = mmc_resume,
         .power_restore = mmc_power_restore,
+        .alive = mmc_alive,
 };
 
 static void mmc_attach_bus_ops(struct mmc_host *host)
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index f2a05ea40f2a..c63ad03c29c7 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -307,8 +307,8 @@ static int mmc_read_switch(struct mmc_card *card)
                 goto out;
         }
 
-        if (status[13] & UHS_SDR50_BUS_SPEED)
-                card->sw_caps.hs_max_dtr = 50000000;
+        if (status[13] & SD_MODE_HIGH_SPEED)
+                card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
 
         if (card->scr.sda_spec3) {
                 card->sw_caps.sd3_bus_mode = status[13];
@@ -661,7 +661,8 @@ static int mmc_sd_init_uhs_card(struct mmc_card *card)
 
         /* SPI mode doesn't define CMD19 */
         if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning)
-                err = card->host->ops->execute_tuning(card->host);
+                err = card->host->ops->execute_tuning(card->host,
+                                                      MMC_SEND_TUNING_BLOCK);
 
 out:
         kfree(status);
@@ -960,7 +961,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
                         goto free_card;
 
                 /* Card is an ultra-high-speed card */
-                mmc_sd_card_set_uhs(card);
+                mmc_card_set_uhs(card);
 
                 /*
                  * Since initialization is now complete, enable preset
@@ -1019,6 +1020,14 @@ static void mmc_sd_remove(struct mmc_host *host)
 }
 
 /*
+ * Card detection - card is alive.
+ */
+static int mmc_sd_alive(struct mmc_host *host)
+{
+        return mmc_send_status(host->card, NULL);
+}
+
+/*
  * Card detection callback from host.
  */
 static void mmc_sd_detect(struct mmc_host *host)
@@ -1033,7 +1042,7 @@ static void mmc_sd_detect(struct mmc_host *host)
         /*
          * Just check if our card has been removed.
          */
-        err = mmc_send_status(host->card, NULL);
+        err = _mmc_detect_card_removed(host);
 
         mmc_release_host(host);
 
@@ -1102,6 +1111,7 @@ static const struct mmc_bus_ops mmc_sd_ops = {
         .suspend = NULL,
         .resume = NULL,
         .power_restore = mmc_sd_power_restore,
+        .alive = mmc_sd_alive,
 };
 
 static const struct mmc_bus_ops mmc_sd_ops_unsafe = {
@@ -1110,6 +1120,7 @@ static const struct mmc_bus_ops mmc_sd_ops_unsafe = {
         .suspend = mmc_sd_suspend,
         .resume = mmc_sd_resume,
         .power_restore = mmc_sd_power_restore,
+        .alive = mmc_sd_alive,
 };
 
 static void mmc_sd_attach_bus_ops(struct mmc_host *host)
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index 3ab565e32a6a..bd7bacc950dc 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -14,6 +14,7 @@
 
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
+#include <linux/mmc/mmc.h>
 #include <linux/mmc/sdio.h>
 #include <linux/mmc/sdio_func.h>
 #include <linux/mmc/sdio_ids.h>
@@ -102,6 +103,7 @@ static int sdio_read_cccr(struct mmc_card *card)
         int ret;
         int cccr_vsn;
         unsigned char data;
+        unsigned char speed;
 
         memset(&card->cccr, 0, sizeof(struct sdio_cccr));
 
@@ -140,12 +142,60 @@ static int sdio_read_cccr(struct mmc_card *card)
         }
 
         if (cccr_vsn >= SDIO_CCCR_REV_1_20) {
-                ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &data);
+                ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
                 if (ret)
                         goto out;
 
-                if (data & SDIO_SPEED_SHS)
-                        card->cccr.high_speed = 1;
+                card->scr.sda_spec3 = 0;
+                card->sw_caps.sd3_bus_mode = 0;
+                card->sw_caps.sd3_drv_type = 0;
+                if (cccr_vsn >= SDIO_CCCR_REV_3_00) {
+                        card->scr.sda_spec3 = 1;
+                        ret = mmc_io_rw_direct(card, 0, 0,
+                                SDIO_CCCR_UHS, 0, &data);
+                        if (ret)
+                                goto out;
+
+                        if (card->host->caps &
+                                (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+                                 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
+                                 MMC_CAP_UHS_DDR50)) {
+                                if (data & SDIO_UHS_DDR50)
+                                        card->sw_caps.sd3_bus_mode
+                                                |= SD_MODE_UHS_DDR50;
+
+                                if (data & SDIO_UHS_SDR50)
+                                        card->sw_caps.sd3_bus_mode
+                                                |= SD_MODE_UHS_SDR50;
+
+                                if (data & SDIO_UHS_SDR104)
+                                        card->sw_caps.sd3_bus_mode
+                                                |= SD_MODE_UHS_SDR104;
+                        }
+
+                        ret = mmc_io_rw_direct(card, 0, 0,
+                                SDIO_CCCR_DRIVE_STRENGTH, 0, &data);
+                        if (ret)
+                                goto out;
+
+                        if (data & SDIO_DRIVE_SDTA)
+                                card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_A;
+                        if (data & SDIO_DRIVE_SDTC)
+                                card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_C;
+                        if (data & SDIO_DRIVE_SDTD)
+                                card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_D;
+                }
+
+                /* if no uhs mode ensure we check for high speed */
+                if (!card->sw_caps.sd3_bus_mode) {
+                        if (speed & SDIO_SPEED_SHS) {
+                                card->cccr.high_speed = 1;
+                                card->sw_caps.hs_max_dtr = 50000000;
+                        } else {
+                                card->cccr.high_speed = 0;
+                                card->sw_caps.hs_max_dtr = 25000000;
+                        }
+                }
         }
 
 out:
@@ -327,6 +377,194 @@ static unsigned mmc_sdio_get_max_clock(struct mmc_card *card)
         return max_dtr;
 }
 
+static unsigned char host_drive_to_sdio_drive(int host_strength)
+{
+        switch (host_strength) {
+        case MMC_SET_DRIVER_TYPE_A:
+                return SDIO_DTSx_SET_TYPE_A;
+        case MMC_SET_DRIVER_TYPE_B:
+                return SDIO_DTSx_SET_TYPE_B;
+        case MMC_SET_DRIVER_TYPE_C:
+                return SDIO_DTSx_SET_TYPE_C;
+        case MMC_SET_DRIVER_TYPE_D:
+                return SDIO_DTSx_SET_TYPE_D;
+        default:
+                return SDIO_DTSx_SET_TYPE_B;
+        }
+}
+
+static void sdio_select_driver_type(struct mmc_card *card)
+{
+        int host_drv_type = SD_DRIVER_TYPE_B;
+        int card_drv_type = SD_DRIVER_TYPE_B;
+        int drive_strength;
+        unsigned char card_strength;
+        int err;
+
+        /*
+         * If the host doesn't support any of the Driver Types A,C or D,
+         * or there is no board specific handler then default Driver
+         * Type B is used.
+         */
+        if (!(card->host->caps &
+                (MMC_CAP_DRIVER_TYPE_A |
+                 MMC_CAP_DRIVER_TYPE_C |
+                 MMC_CAP_DRIVER_TYPE_D)))
+                return;
+
+        if (!card->host->ops->select_drive_strength)
+                return;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_A)
+                host_drv_type |= SD_DRIVER_TYPE_A;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_C)
+                host_drv_type |= SD_DRIVER_TYPE_C;
+
+        if (card->host->caps & MMC_CAP_DRIVER_TYPE_D)
+                host_drv_type |= SD_DRIVER_TYPE_D;
+
+        if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
+                card_drv_type |= SD_DRIVER_TYPE_A;
+
+        if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
+                card_drv_type |= SD_DRIVER_TYPE_C;
+
+        if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D)
+                card_drv_type |= SD_DRIVER_TYPE_D;
+
+        /*
+         * The drive strength that the hardware can support
+         * depends on the board design.  Pass the appropriate
+         * information and let the hardware specific code
+         * return what is possible given the options
+         */
+        drive_strength = card->host->ops->select_drive_strength(
+                card->sw_caps.uhs_max_dtr,
+                host_drv_type, card_drv_type);
+
+        /* if error just use default for drive strength B */
+        err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_DRIVE_STRENGTH, 0,
+                &card_strength);
+        if (err)
+                return;
+
+        card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT);
+        card_strength |= host_drive_to_sdio_drive(drive_strength);
+
+        err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_DRIVE_STRENGTH,
+                card_strength, NULL);
+
+        /* if error default to drive strength B */
+        if (!err)
+                mmc_set_driver_type(card->host, drive_strength);
+}
+
+
+static int sdio_set_bus_speed_mode(struct mmc_card *card)
+{
+        unsigned int bus_speed, timing;
+        int err;
+        unsigned char speed;
+
+        /*
+         * If the host doesn't support any of the UHS-I modes, fallback on
+         * default speed.
+         */
+        if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50)))
+                return 0;
+
+        bus_speed = SDIO_SPEED_SDR12;
+        timing = MMC_TIMING_UHS_SDR12;
+        if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
+            (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
+                        bus_speed = SDIO_SPEED_SDR104;
+                        timing = MMC_TIMING_UHS_SDR104;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
+        } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
+                   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
+                        bus_speed = SDIO_SPEED_DDR50;
+                        timing = MMC_TIMING_UHS_DDR50;
+                        card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
+        } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
+                    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
+                    SD_MODE_UHS_SDR50)) {
+                        bus_speed = SDIO_SPEED_SDR50;
+                        timing = MMC_TIMING_UHS_SDR50;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
+        } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
+                    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
+                   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
+                        bus_speed = SDIO_SPEED_SDR25;
+                        timing = MMC_TIMING_UHS_SDR25;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
+        } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
+                    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
+                    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
+                    SD_MODE_UHS_SDR12)) {
+                        bus_speed = SDIO_SPEED_SDR12;
+                        timing = MMC_TIMING_UHS_SDR12;
+                        card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
+        }
+
+        err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
+        if (err)
+                return err;
+
+        speed &= ~SDIO_SPEED_BSS_MASK;
+        speed |= bus_speed;
+        err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
+        if (err)
+                return err;
+
+        if (bus_speed) {
+                mmc_set_timing(card->host, timing);
+                mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
+        }
+
+        return 0;
+}
+
+/*
+ * UHS-I specific initialization procedure
+ */
+static int mmc_sdio_init_uhs_card(struct mmc_card *card)
+{
+        int err;
+
+        if (!card->scr.sda_spec3)
+                return 0;
+
+        /*
+         * Switch to wider bus (if supported).
+         */
+        if (card->host->caps & MMC_CAP_4_BIT_DATA) {
+                err = sdio_enable_4bit_bus(card);
+                if (err > 0) {
+                        mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
+                        err = 0;
+                }
+        }
+
+        /* Set the driver strength for the card */
+        sdio_select_driver_type(card);
+
+        /* Set bus speed mode of the card */
+        err = sdio_set_bus_speed_mode(card);
+        if (err)
+                goto out;
+
+        /* Initialize and start re-tuning timer */
+        if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning)
+                err = card->host->ops->execute_tuning(card->host,
+                                                      MMC_SEND_TUNING_BLOCK);
+
+out:
+
+        return err;
+}
+
 /*
  * Handle the detection and initialisation of a card.
  *
@@ -394,6 +632,30 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                 host->ops->init_card(host, card);
 
         /*
+         * If the host and card support UHS-I mode request the card
+         * to switch to 1.8V signaling level.  No 1.8v signalling if
+         * UHS mode is not enabled to maintain compatibilty and some
+         * systems that claim 1.8v signalling in fact do not support
+         * it.
+         */
+        if ((ocr & R4_18V_PRESENT) &&
+                (host->caps &
+                        (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+                         MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
+                         MMC_CAP_UHS_DDR50))) {
+                err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180,
+                                true);
+                if (err) {
+                        ocr &= ~R4_18V_PRESENT;
+                        host->ocr &= ~R4_18V_PRESENT;
+                }
+                err = 0;
+        } else {
+                ocr &= ~R4_18V_PRESENT;
+                host->ocr &= ~R4_18V_PRESENT;
+        }
+
+        /*
          * For native busses:  set card RCA and quit open drain mode.
          */
         if (!powered_resume && !mmc_host_is_spi(host)) {
@@ -492,29 +754,39 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
         if (err)
                 goto remove;
 
-        /*
-         * Switch to high-speed (if supported).
-         */
-        err = sdio_enable_hs(card);
-        if (err > 0)
-                mmc_sd_go_highspeed(card);
-        else if (err)
-                goto remove;
+        /* Initialization sequence for UHS-I cards */
+        /* Only if card supports 1.8v and UHS signaling */
+        if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) {
+                err = mmc_sdio_init_uhs_card(card);
+                if (err)
+                        goto remove;
 
-        /*
-         * Change to the card's maximum speed.
-         */
-        mmc_set_clock(host, mmc_sdio_get_max_clock(card));
+                /* Card is an ultra-high-speed card */
+                mmc_card_set_uhs(card);
+        } else {
+                /*
+                 * Switch to high-speed (if supported).
+                 */
+                err = sdio_enable_hs(card);
+                if (err > 0)
+                        mmc_sd_go_highspeed(card);
+                else if (err)
+                        goto remove;
 
-        /*
-         * Switch to wider bus (if supported).
-         */
-        err = sdio_enable_4bit_bus(card);
-        if (err > 0)
-                mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
-        else if (err)
-                goto remove;
+                /*
+                 * Change to the card's maximum speed.
+                 */
+                mmc_set_clock(host, mmc_sdio_get_max_clock(card));
 
+                /*
+                 * Switch to wider bus (if supported).
+                 */
+                err = sdio_enable_4bit_bus(card);
+                if (err > 0)
+                        mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
+                else if (err)
+                        goto remove;
+        }
 finish:
         if (!oldcard)
                 host->card = card;
@@ -550,6 +822,14 @@ static void mmc_sdio_remove(struct mmc_host *host)
 }
 
 /*
+ * Card detection - card is alive.
+ */
+static int mmc_sdio_alive(struct mmc_host *host)
+{
+        return mmc_select_card(host->card);
+}
+
+/*
  * Card detection callback from host.
  */
 static void mmc_sdio_detect(struct mmc_host *host)
@@ -571,7 +851,7 @@ static void mmc_sdio_detect(struct mmc_host *host)
         /*
          * Just check if our card has been removed.
          */
-        err = mmc_select_card(host->card);
+        err = _mmc_detect_card_removed(host);
 
         mmc_release_host(host);
 
@@ -749,6 +1029,7 @@ static const struct mmc_bus_ops mmc_sdio_ops = {
         .suspend = mmc_sdio_suspend,
         .resume = mmc_sdio_resume,
         .power_restore = mmc_sdio_power_restore,
+        .alive = mmc_sdio_alive,
 };
 
 
@@ -797,8 +1078,17 @@ int mmc_attach_sdio(struct mmc_host *host)
          * Detect and init the card.
          */
         err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
-        if (err)
-                goto err;
+        if (err) {
+                if (err == -EAGAIN) {
+                        /*
+                         * Retry initialization with S18R set to 0.
+                         */
+                        host->ocr &= ~R4_18V_PRESENT;
+                        err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
+                }
+                if (err)
+                        goto err;
+        }
         card = host->card;
 
         /*
diff --git a/drivers/mmc/core/sdio_io.c b/drivers/mmc/core/sdio_io.c
index b1f3168f791b..8f6f5ac131fc 100644
--- a/drivers/mmc/core/sdio_io.c
+++ b/drivers/mmc/core/sdio_io.c
@@ -196,6 +196,9 @@ static inline unsigned int sdio_max_byte_size(struct sdio_func *func)
         else
                 mval = min(mval, func->max_blksize);
 
+        if (mmc_card_broken_byte_mode_512(func->card))
+                return min(mval, 511u);
+
         return min(mval, 512u); /* maximum size for byte mode */
 }
 
@@ -314,7 +317,7 @@ static int sdio_io_rw_ext_helper(struct sdio_func *func, int write,
                         func->card->host->max_seg_size / func->cur_blksize);
                 max_blocks = min(max_blocks, 511u);
 
-                while (remainder > func->cur_blksize) {
+                while (remainder >= func->cur_blksize) {
                         unsigned blocks;
 
                         blocks = remainder / func->cur_blksize;
@@ -339,8 +342,9 @@ static int sdio_io_rw_ext_helper(struct sdio_func *func, int write,
         while (remainder > 0) {
                 size = min(remainder, sdio_max_byte_size(func));
 
+                /* Indicate byte mode by setting "blocks" = 0 */
                 ret = mmc_io_rw_extended(func->card, write, func->num, addr,
-                         incr_addr, buf, 1, size);
+                         incr_addr, buf, 0, size);
                 if (ret)
                         return ret;
 
diff --git a/drivers/mmc/core/sdio_ops.c b/drivers/mmc/core/sdio_ops.c
index b0517cc06200..d29e20630eed 100644
--- a/drivers/mmc/core/sdio_ops.c
+++ b/drivers/mmc/core/sdio_ops.c
@@ -128,8 +128,6 @@ int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
 
         BUG_ON(!card);
         BUG_ON(fn > 7);
-        BUG_ON(blocks == 1 && blksz > 512);
-        WARN_ON(blocks == 0);
         WARN_ON(blksz == 0);
 
         /* sanity check */
@@ -144,22 +142,20 @@ int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         cmd.arg |= fn << 28;
         cmd.arg |= incr_addr ? 0x04000000 : 0x00000000;
         cmd.arg |= addr << 9;
-        if (blocks == 1 && blksz < 512)
-                cmd.arg |= blksz;                       /* byte mode */
-        else if (blocks == 1 && blksz == 512 &&
-                 !(mmc_card_broken_byte_mode_512(card)))
-                cmd.arg |= 0;                           /* byte mode, 0==512 */
+        if (blocks == 0)
+                cmd.arg |= (blksz == 512) ? 0 : blksz;  /* byte mode */
         else
                 cmd.arg |= 0x08000000 | blocks;         /* block mode */
         cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
 
         data.blksz = blksz;
-        data.blocks = blocks;
+        /* Code in host drivers/fwk assumes that "blocks" always is >=1 */
+        data.blocks = blocks ? blocks : 1;
         data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
         data.sg = &sg;
         data.sg_len = 1;
 
-        sg_init_one(&sg, buf, blksz * blocks);
+        sg_init_one(&sg, buf, data.blksz * data.blocks);
 
         mmc_set_data_timeout(&data, card);
 
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index b4b83f302e32..745f8fce2519 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_MMC_MXC)		+= mxcmmc.o
 obj-$(CONFIG_MMC_MXS)           += mxs-mmc.o
 obj-$(CONFIG_MMC_SDHCI)         += sdhci.o
 obj-$(CONFIG_MMC_SDHCI_PCI)     += sdhci-pci.o
+obj-$(subst m,y,$(CONFIG_MMC_SDHCI_PCI))        += sdhci-pci-data.o
 obj-$(CONFIG_MMC_SDHCI_PXAV3)   += sdhci-pxav3.o
 obj-$(CONFIG_MMC_SDHCI_PXAV2)   += sdhci-pxav2.o
 obj-$(CONFIG_MMC_SDHCI_S3C)     += sdhci-s3c.o
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index f437c3e6f3aa..947faa5d2ce4 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -236,7 +236,7 @@ static inline void at91_mci_sg_to_dma(struct at91mci_host *host, struct mmc_data
 
                 sg = &data->sg[i];
 
-                sgbuffer = kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
+                sgbuffer = kmap_atomic(sg_page(sg)) + sg->offset;
                 amount = min(size, sg->length);
                 size -= amount;
 
@@ -252,7 +252,7 @@ static inline void at91_mci_sg_to_dma(struct at91mci_host *host, struct mmc_data
                         dmabuf = (unsigned *)tmpv;
                 }
 
-                kunmap_atomic(sgbuffer, KM_BIO_SRC_IRQ);
+                kunmap_atomic(sgbuffer);
 
                 if (size == 0)
                         break;
@@ -302,7 +302,7 @@ static void at91_mci_post_dma_read(struct at91mci_host *host)
 
                 sg = &data->sg[i];
 
-                sgbuffer = kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
+                sgbuffer = kmap_atomic(sg_page(sg)) + sg->offset;
                 amount = min(size, sg->length);
                 size -= amount;
 
@@ -318,7 +318,7 @@ static void at91_mci_post_dma_read(struct at91mci_host *host)
                 }
 
                 flush_kernel_dcache_page(sg_page(sg));
-                kunmap_atomic(sgbuffer, KM_BIO_SRC_IRQ);
+                kunmap_atomic(sgbuffer);
                 data->bytes_xfered += amount;
                 if (size == 0)
                         break;
diff --git a/drivers/mmc/host/bfin_sdh.c b/drivers/mmc/host/bfin_sdh.c
index 0371bf502249..03666174ca48 100644
--- a/drivers/mmc/host/bfin_sdh.c
+++ b/drivers/mmc/host/bfin_sdh.c
@@ -627,17 +627,7 @@ static struct platform_driver sdh_driver = {
         },
 };
 
-static int __init sdh_init(void)
-{
-        return platform_driver_register(&sdh_driver);
-}
-module_init(sdh_init);
-
-static void __exit sdh_exit(void)
-{
-        platform_driver_unregister(&sdh_driver);
-}
-module_exit(sdh_exit);
+module_platform_driver(sdh_driver);
 
 MODULE_DESCRIPTION("Blackfin Secure Digital Host Driver");
 MODULE_AUTHOR("Cliff Cai, Roy Huang");
diff --git a/drivers/mmc/host/cb710-mmc.c b/drivers/mmc/host/cb710-mmc.c
index ce2a47b71dd6..83693fd7c6b3 100644
--- a/drivers/mmc/host/cb710-mmc.c
+++ b/drivers/mmc/host/cb710-mmc.c
@@ -780,18 +780,7 @@ static struct platform_driver cb710_mmc_driver = {
 #endif
 };
 
-static int __init cb710_mmc_init_module(void)
-{
-        return platform_driver_register(&cb710_mmc_driver);
-}
-
-static void __exit cb710_mmc_cleanup_module(void)
-{
-        platform_driver_unregister(&cb710_mmc_driver);
-}
-
-module_init(cb710_mmc_init_module);
-module_exit(cb710_mmc_cleanup_module);
+module_platform_driver(cb710_mmc_driver);
 
 MODULE_AUTHOR("Michał Mirosław <mirq-linux@rere.qmqm.pl>");
 MODULE_DESCRIPTION("ENE CB710 memory card reader driver - MMC/SD part");
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 3aaeb0841914..0e342793ff14 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -588,11 +588,11 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot)
         mci_writel(host, CTYPE, (slot->ctype << slot->id));
 }
 
-static void dw_mci_start_request(struct dw_mci *host,
-                                 struct dw_mci_slot *slot)
+static void __dw_mci_start_request(struct dw_mci *host,
+                                   struct dw_mci_slot *slot,
+                                   struct mmc_command *cmd)
 {
         struct mmc_request *mrq;
-        struct mmc_command *cmd;
         struct mmc_data *data;
         u32 cmdflags;
 
@@ -610,14 +610,13 @@ static void dw_mci_start_request(struct dw_mci *host,
         host->completed_events = 0;
         host->data_status = 0;
 
-        data = mrq->data;
+        data = cmd->data;
         if (data) {
                 dw_mci_set_timeout(host);
                 mci_writel(host, BYTCNT, data->blksz*data->blocks);
                 mci_writel(host, BLKSIZ, data->blksz);
         }
 
-        cmd = mrq->cmd;
         cmdflags = dw_mci_prepare_command(slot->mmc, cmd);
 
         /* this is the first command, send the initialization clock */
@@ -635,6 +634,16 @@ static void dw_mci_start_request(struct dw_mci *host,
                 host->stop_cmdr = dw_mci_prepare_command(slot->mmc, mrq->stop);
 }
 
+static void dw_mci_start_request(struct dw_mci *host,
+                                 struct dw_mci_slot *slot)
+{
+        struct mmc_request *mrq = slot->mrq;
+        struct mmc_command *cmd;
+
+        cmd = mrq->sbc ? mrq->sbc : mrq->cmd;
+        __dw_mci_start_request(host, slot, cmd);
+}
+
 /* must be called with host->lock held */
 static void dw_mci_queue_request(struct dw_mci *host, struct dw_mci_slot *slot,
                                  struct mmc_request *mrq)
@@ -698,12 +707,15 @@ static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 break;
         }
 
+        regs = mci_readl(slot->host, UHS_REG);
+
         /* DDR mode set */
-        if (ios->timing == MMC_TIMING_UHS_DDR50) {
-                regs = mci_readl(slot->host, UHS_REG);
+        if (ios->timing == MMC_TIMING_UHS_DDR50)
                 regs |= (0x1 << slot->id) << 16;
-                mci_writel(slot->host, UHS_REG, regs);
-        }
+        else
+                regs &= ~(0x1 << slot->id) << 16;
+
+        mci_writel(slot->host, UHS_REG, regs);
 
         if (ios->clock) {
                 /*
@@ -889,7 +901,14 @@ static void dw_mci_tasklet_func(unsigned long priv)
                         cmd = host->cmd;
                         host->cmd = NULL;
                         set_bit(EVENT_CMD_COMPLETE, &host->completed_events);
-                        dw_mci_command_complete(host, host->mrq->cmd);
+                        dw_mci_command_complete(host, cmd);
+                        if (cmd == host->mrq->sbc && !cmd->error) {
+                                prev_state = state = STATE_SENDING_CMD;
+                                __dw_mci_start_request(host, host->cur_slot,
+                                                       host->mrq->cmd);
+                                goto unlock;
+                        }
+
                         if (!host->mrq->data || cmd->error) {
                                 dw_mci_request_end(host, host->mrq);
                                 goto unlock;
@@ -967,6 +986,12 @@ static void dw_mci_tasklet_func(unsigned long priv)
                                 goto unlock;
                         }
 
+                        if (host->mrq->sbc && !data->error) {
+                                data->stop->error = 0;
+                                dw_mci_request_end(host, host->mrq);
+                                goto unlock;
+                        }
+
                         prev_state = state = STATE_SENDING_STOP;
                         if (!data->error)
                                 send_stop_cmd(host, data);
@@ -1678,8 +1703,9 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
 
         if (host->pdata->caps)
                 mmc->caps = host->pdata->caps;
-        else
-                mmc->caps = 0;
+
+        if (host->pdata->caps2)
+                mmc->caps2 = host->pdata->caps2;
 
         if (host->pdata->get_bus_wd)
                 if (host->pdata->get_bus_wd(slot->id) >= 4)
@@ -1923,7 +1949,7 @@ static int dw_mci_probe(struct platform_device *pdev)
                  * should put it in the platform data.
                  */
                 fifo_size = mci_readl(host, FIFOTH);
-                fifo_size = 1 + ((fifo_size >> 16) & 0x7ff);
+                fifo_size = 1 + ((fifo_size >> 16) & 0xfff);
         } else {
                 fifo_size = host->pdata->fifo_depth;
         }
@@ -2062,14 +2088,14 @@ static int __exit dw_mci_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 /*
  * TODO: we should probably disable the clock to the card in the suspend path.
  */
-static int dw_mci_suspend(struct platform_device *pdev, pm_message_t mesg)
+static int dw_mci_suspend(struct device *dev)
 {
         int i, ret;
-        struct dw_mci *host = platform_get_drvdata(pdev);
+        struct dw_mci *host = dev_get_drvdata(dev);
 
         for (i = 0; i < host->num_slots; i++) {
                 struct dw_mci_slot *slot = host->slot[i];
@@ -2092,10 +2118,10 @@ static int dw_mci_suspend(struct platform_device *pdev, pm_message_t mesg)
         return 0;
 }
 
-static int dw_mci_resume(struct platform_device *pdev)
+static int dw_mci_resume(struct device *dev)
 {
         int i, ret;
-        struct dw_mci *host = platform_get_drvdata(pdev);
+        struct dw_mci *host = dev_get_drvdata(dev);
 
         if (host->vmmc)
                 regulator_enable(host->vmmc);
@@ -2103,7 +2129,7 @@ static int dw_mci_resume(struct platform_device *pdev)
         if (host->dma_ops->init)
                 host->dma_ops->init(host);
 
-        if (!mci_wait_reset(&pdev->dev, host)) {
+        if (!mci_wait_reset(dev, host)) {
                 ret = -ENODEV;
                 return ret;
         }
@@ -2131,14 +2157,15 @@ static int dw_mci_resume(struct platform_device *pdev)
 #else
 #define dw_mci_suspend  NULL
 #define dw_mci_resume   NULL
-#endif /* CONFIG_PM */
+#endif /* CONFIG_PM_SLEEP */
+
+static SIMPLE_DEV_PM_OPS(dw_mci_pmops, dw_mci_suspend, dw_mci_resume);
 
 static struct platform_driver dw_mci_driver = {
         .remove         = __exit_p(dw_mci_remove),
-        .suspend        = dw_mci_suspend,
-        .resume         = dw_mci_resume,
         .driver         = {
                 .name           = "dw_mmc",
+                .pm             = &dw_mci_pmops,
         },
 };
 
diff --git a/drivers/mmc/host/dw_mmc.h b/drivers/mmc/host/dw_mmc.h
index 72c071f6e001..df392a1143f2 100644
--- a/drivers/mmc/host/dw_mmc.h
+++ b/drivers/mmc/host/dw_mmc.h
@@ -126,7 +126,7 @@
 #define SDMMC_CMD_RESP_EXP              BIT(6)
 #define SDMMC_CMD_INDX(n)               ((n) & 0x1F)
 /* Status register defines */
-#define SDMMC_GET_FCNT(x)               (((x)>>17) & 0x1FF)
+#define SDMMC_GET_FCNT(x)               (((x)>>17) & 0x1FFF)
 /* Internal DMAC interrupt defines */
 #define SDMMC_IDMAC_INT_AI              BIT(9)
 #define SDMMC_IDMAC_INT_NI              BIT(8)
diff --git a/drivers/mmc/host/jz4740_mmc.c b/drivers/mmc/host/jz4740_mmc.c
index 74218ad677e4..c8852a8128a9 100644
--- a/drivers/mmc/host/jz4740_mmc.c
+++ b/drivers/mmc/host/jz4740_mmc.c
@@ -1012,17 +1012,7 @@ static struct platform_driver jz4740_mmc_driver = {
         },
 };
 
-static int __init jz4740_mmc_init(void)
-{
-        return platform_driver_register(&jz4740_mmc_driver);
-}
-module_init(jz4740_mmc_init);
-
-static void __exit jz4740_mmc_exit(void)
-{
-        platform_driver_unregister(&jz4740_mmc_driver);
-}
-module_exit(jz4740_mmc_exit);
+module_platform_driver(jz4740_mmc_driver);
 
 MODULE_DESCRIPTION("JZ4740 SD/MMC controller driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index 92946b84e9fa..273306c68d58 100644
--- a/drivers/mmc/host/mmc_spi.c
+++ b/drivers/mmc/host/mmc_spi.c
@@ -1525,7 +1525,6 @@ static struct of_device_id mmc_spi_of_match_table[] __devinitdata = {
 static struct spi_driver mmc_spi_driver = {
         .driver = {
                 .name =         "mmc_spi",
-                .bus =          &spi_bus_type,
                 .owner =        THIS_MODULE,
                 .of_match_table = mmc_spi_of_match_table,
         },
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index fa8dd2fda4b2..ece03b491c7d 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -1245,6 +1245,7 @@ static int __devinit mmci_probe(struct amba_device *dev,
         if (host->vcc == NULL)
                 mmc->ocr_avail = plat->ocr_mask;
         mmc->caps = plat->capabilities;
+        mmc->caps2 = plat->capabilities2;
 
         /*
          * We can do SGIO
diff --git a/drivers/mmc/host/msm_sdcc.c b/drivers/mmc/host/msm_sdcc.c
index 80d8eb143b48..1d14cda95e56 100644
--- a/drivers/mmc/host/msm_sdcc.c
+++ b/drivers/mmc/host/msm_sdcc.c
@@ -689,8 +689,8 @@ msmsdcc_pio_irq(int irq, void *dev_id)
 
                 /* Map the current scatter buffer */
                 local_irq_save(flags);
-                buffer = kmap_atomic(sg_page(host->pio.sg),
-                                     KM_BIO_SRC_IRQ) + host->pio.sg->offset;
+                buffer = kmap_atomic(sg_page(host->pio.sg))
+                                     + host->pio.sg->offset;
                 buffer += host->pio.sg_off;
                 remain = host->pio.sg->length - host->pio.sg_off;
                 len = 0;
@@ -700,7 +700,7 @@ msmsdcc_pio_irq(int irq, void *dev_id)
                         len = msmsdcc_pio_write(host, buffer, remain, status);
 
                 /* Unmap the buffer */
-                kunmap_atomic(buffer, KM_BIO_SRC_IRQ);
+                kunmap_atomic(buffer);
                 local_irq_restore(flags);
 
                 host->pio.sg_off += len;
@@ -1480,18 +1480,7 @@ static struct platform_driver msmsdcc_driver = {
         },
 };
 
-static int __init msmsdcc_init(void)
-{
-        return platform_driver_register(&msmsdcc_driver);
-}
-
-static void __exit msmsdcc_exit(void)
-{
-        platform_driver_unregister(&msmsdcc_driver);
-}
-
-module_init(msmsdcc_init);
-module_exit(msmsdcc_exit);
+module_platform_driver(msmsdcc_driver);
 
 MODULE_DESCRIPTION("Qualcomm MSM 7X00A Multimedia Card Interface driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index 8e0fbe994047..7088b40f9579 100644
--- a/drivers/mmc/host/mxcmmc.c
+++ b/drivers/mmc/host/mxcmmc.c
@@ -1047,18 +1047,7 @@ static struct platform_driver mxcmci_driver = {
         }
 };
 
-static int __init mxcmci_init(void)
-{
-        return platform_driver_register(&mxcmci_driver);
-}
-
-static void __exit mxcmci_exit(void)
-{
-        platform_driver_unregister(&mxcmci_driver);
-}
-
-module_init(mxcmci_init);
-module_exit(mxcmci_exit);
+module_platform_driver(mxcmci_driver);
 
 MODULE_DESCRIPTION("i.MX Multimedia Card Interface Driver");
 MODULE_AUTHOR("Sascha Hauer, Pengutronix");
diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
index 973011f9a298..4e2e019dd5c9 100644
--- a/drivers/mmc/host/mxs-mmc.c
+++ b/drivers/mmc/host/mxs-mmc.c
@@ -855,18 +855,7 @@ static struct platform_driver mxs_mmc_driver = {
         },
 };
 
-static int __init mxs_mmc_init(void)
-{
-        return platform_driver_register(&mxs_mmc_driver);
-}
-
-static void __exit mxs_mmc_exit(void)
-{
-        platform_driver_unregister(&mxs_mmc_driver);
-}
-
-module_init(mxs_mmc_init);
-module_exit(mxs_mmc_exit);
+module_platform_driver(mxs_mmc_driver);
 
 MODULE_DESCRIPTION("FREESCALE MXS MMC peripheral");
 MODULE_AUTHOR("Freescale Semiconductor");
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index d1fb561e089d..fd0c661bbad3 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -24,7 +24,6 @@
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
 #include <linux/platform_device.h>
-#include <linux/workqueue.h>
 #include <linux/timer.h>
 #include <linux/clk.h>
 #include <linux/mmc/host.h>
@@ -120,7 +119,6 @@
 
 #define MMC_AUTOSUSPEND_DELAY   100
 #define MMC_TIMEOUT_MS          20
-#define OMAP_MMC_MASTER_CLOCK   96000000
 #define OMAP_MMC_MIN_CLOCK      400000
 #define OMAP_MMC_MAX_CLOCK      52000000
 #define DRIVER_NAME             "omap_hsmmc"
@@ -163,7 +161,6 @@ struct omap_hsmmc_host {
          */
         struct  regulator       *vcc;
         struct  regulator       *vcc_aux;
-        struct  work_struct     mmc_carddetect_work;
         void    __iomem         *base;
         resource_size_t         mapbase;
         spinlock_t              irq_lock; /* Prevent races with irq handler */
@@ -598,12 +595,12 @@ static void omap_hsmmc_disable_irq(struct omap_hsmmc_host *host)
 }
 
 /* Calculate divisor for the given clock frequency */
-static u16 calc_divisor(struct mmc_ios *ios)
+static u16 calc_divisor(struct omap_hsmmc_host *host, struct mmc_ios *ios)
 {
         u16 dsor = 0;
 
         if (ios->clock) {
-                dsor = DIV_ROUND_UP(OMAP_MMC_MASTER_CLOCK, ios->clock);
+                dsor = DIV_ROUND_UP(clk_get_rate(host->fclk), ios->clock);
                 if (dsor > 250)
                         dsor = 250;
         }
@@ -623,7 +620,7 @@ static void omap_hsmmc_set_clock(struct omap_hsmmc_host *host)
 
         regval = OMAP_HSMMC_READ(host->base, SYSCTL);
         regval = regval & ~(CLKD_MASK | DTO_MASK);
-        regval = regval | (calc_divisor(ios) << 6) | (DTO << 16);
+        regval = regval | (calc_divisor(host, ios) << 6) | (DTO << 16);
         OMAP_HSMMC_WRITE(host->base, SYSCTL, regval);
         OMAP_HSMMC_WRITE(host->base, SYSCTL,
                 OMAP_HSMMC_READ(host->base, SYSCTL) | ICE);
@@ -1280,17 +1277,16 @@ static void omap_hsmmc_protect_card(struct omap_hsmmc_host *host)
 }
 
 /*
- * Work Item to notify the core about card insertion/removal
+ * irq handler to notify the core about card insertion/removal
  */
-static void omap_hsmmc_detect(struct work_struct *work)
+static irqreturn_t omap_hsmmc_detect(int irq, void *dev_id)
 {
-        struct omap_hsmmc_host *host =
-                container_of(work, struct omap_hsmmc_host, mmc_carddetect_work);
+        struct omap_hsmmc_host *host = dev_id;
         struct omap_mmc_slot_data *slot = &mmc_slot(host);
         int carddetect;
 
         if (host->suspended)
-                return;
+                return IRQ_HANDLED;
 
         sysfs_notify(&host->mmc->class_dev.kobj, NULL, "cover_switch");
 
@@ -1305,19 +1301,6 @@ static void omap_hsmmc_detect(struct work_struct *work)
                 mmc_detect_change(host->mmc, (HZ * 200) / 1000);
         else
                 mmc_detect_change(host->mmc, (HZ * 50) / 1000);
-}
-
-/*
- * ISR for handling card insertion and removal
- */
-static irqreturn_t omap_hsmmc_cd_handler(int irq, void *dev_id)
-{
-        struct omap_hsmmc_host *host = (struct omap_hsmmc_host *)dev_id;
-
-        if (host->suspended)
-                return IRQ_HANDLED;
-        schedule_work(&host->mmc_carddetect_work);
-
         return IRQ_HANDLED;
 }
 
@@ -1919,7 +1902,6 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         host->next_data.cookie = 1;
 
         platform_set_drvdata(pdev, host);
-        INIT_WORK(&host->mmc_carddetect_work, omap_hsmmc_detect);
 
         mmc->ops        = &omap_hsmmc_ops;
 
@@ -2049,10 +2031,11 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
 
         /* Request IRQ for card detect */
         if ((mmc_slot(host).card_detect_irq)) {
-                ret = request_irq(mmc_slot(host).card_detect_irq,
-                                  omap_hsmmc_cd_handler,
-                                  IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                                  mmc_hostname(mmc), host);
+                ret = request_threaded_irq(mmc_slot(host).card_detect_irq,
+                                           NULL,
+                                           omap_hsmmc_detect,
+                                           IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                           mmc_hostname(mmc), host);
                 if (ret) {
                         dev_dbg(mmc_dev(host->mmc),
                                 "Unable to grab MMC CD IRQ\n");
@@ -2131,7 +2114,6 @@ static int omap_hsmmc_remove(struct platform_device *pdev)
                 free_irq(host->irq, host);
                 if (mmc_slot(host).card_detect_irq)
                         free_irq(mmc_slot(host).card_detect_irq, host);
-                flush_work_sync(&host->mmc_carddetect_work);
 
                 pm_runtime_put_sync(host->dev);
                 pm_runtime_disable(host->dev);
@@ -2178,7 +2160,6 @@ static int omap_hsmmc_suspend(struct device *dev)
                                 return ret;
                         }
                 }
-                cancel_work_sync(&host->mmc_carddetect_work);
                 ret = mmc_suspend_host(host->mmc);
 
                 if (ret) {
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index fc4356e00d46..cb2dc0e75ba7 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -872,18 +872,7 @@ static struct platform_driver pxamci_driver = {
         },
 };
 
-static int __init pxamci_init(void)
-{
-        return platform_driver_register(&pxamci_driver);
-}
-
-static void __exit pxamci_exit(void)
-{
-        platform_driver_unregister(&pxamci_driver);
-}
-
-module_init(pxamci_init);
-module_exit(pxamci_exit);
+module_platform_driver(pxamci_driver);
 
 MODULE_DESCRIPTION("PXA Multimedia Card Interface Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index 720f99334a7f..1bcfd6dbb5cc 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -1914,18 +1914,7 @@ static struct platform_driver s3cmci_driver = {
         .shutdown       = s3cmci_shutdown,
 };
 
-static int __init s3cmci_init(void)
-{
-        return platform_driver_register(&s3cmci_driver);
-}
-
-static void __exit s3cmci_exit(void)
-{
-        platform_driver_unregister(&s3cmci_driver);
-}
-
-module_init(s3cmci_init);
-module_exit(s3cmci_exit);
+module_platform_driver(s3cmci_driver);
 
 MODULE_DESCRIPTION("Samsung S3C MMC/SD Card Interface driver");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci-cns3xxx.c b/drivers/mmc/host/sdhci-cns3xxx.c
index b4257e700617..28a870804f60 100644
--- a/drivers/mmc/host/sdhci-cns3xxx.c
+++ b/drivers/mmc/host/sdhci-cns3xxx.c
@@ -115,17 +115,7 @@ static struct platform_driver sdhci_cns3xxx_driver = {
         .remove         = __devexit_p(sdhci_cns3xxx_remove),
 };
 
-static int __init sdhci_cns3xxx_init(void)
-{
-        return platform_driver_register(&sdhci_cns3xxx_driver);
-}
-module_init(sdhci_cns3xxx_init);
-
-static void __exit sdhci_cns3xxx_exit(void)
-{
-        platform_driver_unregister(&sdhci_cns3xxx_driver);
-}
-module_exit(sdhci_cns3xxx_exit);
+module_platform_driver(sdhci_cns3xxx_driver);
 
 MODULE_DESCRIPTION("SDHCI driver for CNS3xxx");
 MODULE_AUTHOR("Scott Shu, "
diff --git a/drivers/mmc/host/sdhci-dove.c b/drivers/mmc/host/sdhci-dove.c
index a81312c91f70..46fd1fd1b605 100644
--- a/drivers/mmc/host/sdhci-dove.c
+++ b/drivers/mmc/host/sdhci-dove.c
@@ -88,17 +88,7 @@ static struct platform_driver sdhci_dove_driver = {
         .remove         = __devexit_p(sdhci_dove_remove),
 };
 
-static int __init sdhci_dove_init(void)
-{
-        return platform_driver_register(&sdhci_dove_driver);
-}
-module_init(sdhci_dove_init);
-
-static void __exit sdhci_dove_exit(void)
-{
-        platform_driver_unregister(&sdhci_dove_driver);
-}
-module_exit(sdhci_dove_exit);
+module_platform_driver(sdhci_dove_driver);
 
 MODULE_DESCRIPTION("SDHCI driver for Dove");
 MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>, "
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index 38ebc4ea259f..d601e41af282 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -606,17 +606,7 @@ static struct platform_driver sdhci_esdhc_imx_driver = {
         .remove         = __devexit_p(sdhci_esdhc_imx_remove),
 };
 
-static int __init sdhci_esdhc_imx_init(void)
-{
-        return platform_driver_register(&sdhci_esdhc_imx_driver);
-}
-module_init(sdhci_esdhc_imx_init);
-
-static void __exit sdhci_esdhc_imx_exit(void)
-{
-        platform_driver_unregister(&sdhci_esdhc_imx_driver);
-}
-module_exit(sdhci_esdhc_imx_exit);
+module_platform_driver(sdhci_esdhc_imx_driver);
 
 MODULE_DESCRIPTION("SDHCI driver for Freescale i.MX eSDHC");
 MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
diff --git a/drivers/mmc/host/sdhci-esdhc.h b/drivers/mmc/host/sdhci-esdhc.h
index c3b08f111942..b97b2f5dafdb 100644
--- a/drivers/mmc/host/sdhci-esdhc.h
+++ b/drivers/mmc/host/sdhci-esdhc.h
@@ -73,7 +73,7 @@ static inline void esdhc_set_clock(struct sdhci_host *host, unsigned int clock)
                 | (div << ESDHC_DIVIDER_SHIFT)
                 | (pre_div << ESDHC_PREDIV_SHIFT));
         sdhci_writel(host, temp, ESDHC_SYSTEM_CONTROL);
-        mdelay(100);
+        mdelay(1);
 out:
         host->clock = clock;
 }
diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c
index 01e5f627e0f0..ff4adc018041 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -131,17 +131,7 @@ static struct platform_driver sdhci_esdhc_driver = {
         .remove = __devexit_p(sdhci_esdhc_remove),
 };
 
-static int __init sdhci_esdhc_init(void)
-{
-        return platform_driver_register(&sdhci_esdhc_driver);
-}
-module_init(sdhci_esdhc_init);
-
-static void __exit sdhci_esdhc_exit(void)
-{
-        platform_driver_unregister(&sdhci_esdhc_driver);
-}
-module_exit(sdhci_esdhc_exit);
+module_platform_driver(sdhci_esdhc_driver);
 
 MODULE_DESCRIPTION("SDHCI OF driver for Freescale MPC eSDHC");
 MODULE_AUTHOR("Xiaobo Xie <X.Xie@freescale.com>, "
diff --git a/drivers/mmc/host/sdhci-of-hlwd.c b/drivers/mmc/host/sdhci-of-hlwd.c
index 3619adc7d9fc..0ce088ae0228 100644
--- a/drivers/mmc/host/sdhci-of-hlwd.c
+++ b/drivers/mmc/host/sdhci-of-hlwd.c
@@ -93,17 +93,7 @@ static struct platform_driver sdhci_hlwd_driver = {
         .remove = __devexit_p(sdhci_hlwd_remove),
 };
 
-static int __init sdhci_hlwd_init(void)
-{
-        return platform_driver_register(&sdhci_hlwd_driver);
-}
-module_init(sdhci_hlwd_init);
-
-static void __exit sdhci_hlwd_exit(void)
-{
-        platform_driver_unregister(&sdhci_hlwd_driver);
-}
-module_exit(sdhci_hlwd_exit);
+module_platform_driver(sdhci_hlwd_driver);
 
 MODULE_DESCRIPTION("Nintendo Wii SDHCI OF driver");
 MODULE_AUTHOR("The GameCube Linux Team, Albert Herranz");
diff --git a/drivers/mmc/host/sdhci-pci-data.c b/drivers/mmc/host/sdhci-pci-data.c
new file mode 100644
index 000000000000..a611217769f5
--- /dev/null
+++ b/drivers/mmc/host/sdhci-pci-data.c
@@ -0,0 +1,5 @@
+#include <linux/module.h>
+#include <linux/mmc/sdhci-pci-data.h>
+
+struct sdhci_pci_data *(*sdhci_pci_get_data)(struct pci_dev *pdev, int slotno);
+EXPORT_SYMBOL_GPL(sdhci_pci_get_data);
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 6878a94626bc..7165e6a09274 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -23,8 +23,8 @@
 #include <linux/scatterlist.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
-#include <linux/sfi.h>
 #include <linux/pm_runtime.h>
+#include <linux/mmc/sdhci-pci-data.h>
 
 #include "sdhci.h"
 
@@ -61,6 +61,7 @@ struct sdhci_pci_fixes {
 struct sdhci_pci_slot {
         struct sdhci_pci_chip   *chip;
         struct sdhci_host       *host;
+        struct sdhci_pci_data   *data;
 
         int                     pci_bar;
         int                     rst_n_gpio;
@@ -171,32 +172,9 @@ static int mrst_hc_probe(struct sdhci_pci_chip *chip)
         return 0;
 }
 
-/* Medfield eMMC hardware reset GPIOs */
-static int mfd_emmc0_rst_gpio = -EINVAL;
-static int mfd_emmc1_rst_gpio = -EINVAL;
-
-static int mfd_emmc_gpio_parse(struct sfi_table_header *table)
-{
-        struct sfi_table_simple *sb = (struct sfi_table_simple *)table;
-        struct sfi_gpio_table_entry *entry;
-        int i, num;
-
-        num = SFI_GET_NUM_ENTRIES(sb, struct sfi_gpio_table_entry);
-        entry = (struct sfi_gpio_table_entry *)sb->pentry;
-
-        for (i = 0; i < num; i++, entry++) {
-                if (!strncmp(entry->pin_name, "emmc0_rst", SFI_NAME_LEN))
-                        mfd_emmc0_rst_gpio = entry->pin_no;
-                else if (!strncmp(entry->pin_name, "emmc1_rst", SFI_NAME_LEN))
-                        mfd_emmc1_rst_gpio = entry->pin_no;
-        }
-
-        return 0;
-}
-
 #ifdef CONFIG_PM_RUNTIME
 
-static irqreturn_t mfd_sd_cd(int irq, void *dev_id)
+static irqreturn_t sdhci_pci_sd_cd(int irq, void *dev_id)
 {
         struct sdhci_pci_slot *slot = dev_id;
         struct sdhci_host *host = slot->host;
@@ -205,15 +183,16 @@ static irqreturn_t mfd_sd_cd(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-#define MFLD_SD_CD_PIN 69
-
-static int mfd_sd_probe_slot(struct sdhci_pci_slot *slot)
+static void sdhci_pci_add_own_cd(struct sdhci_pci_slot *slot)
 {
-        int err, irq, gpio = MFLD_SD_CD_PIN;
+        int err, irq, gpio = slot->cd_gpio;
 
         slot->cd_gpio = -EINVAL;
         slot->cd_irq = -EINVAL;
 
+        if (!gpio_is_valid(gpio))
+                return;
+
         err = gpio_request(gpio, "sd_cd");
         if (err < 0)
                 goto out;
@@ -226,72 +205,53 @@ static int mfd_sd_probe_slot(struct sdhci_pci_slot *slot)
         if (irq < 0)
                 goto out_free;
 
-        err = request_irq(irq, mfd_sd_cd, IRQF_TRIGGER_RISING |
+        err = request_irq(irq, sdhci_pci_sd_cd, IRQF_TRIGGER_RISING |
                           IRQF_TRIGGER_FALLING, "sd_cd", slot);
         if (err)
                 goto out_free;
 
         slot->cd_gpio = gpio;
         slot->cd_irq = irq;
-        slot->host->quirks2 |= SDHCI_QUIRK2_OWN_CARD_DETECTION;
 
-        return 0;
+        return;
 
 out_free:
         gpio_free(gpio);
 out:
         dev_warn(&slot->chip->pdev->dev, "failed to setup card detect wake up\n");
-        return 0;
 }
 
-static void mfd_sd_remove_slot(struct sdhci_pci_slot *slot, int dead)
+static void sdhci_pci_remove_own_cd(struct sdhci_pci_slot *slot)
 {
         if (slot->cd_irq >= 0)
                 free_irq(slot->cd_irq, slot);
-        gpio_free(slot->cd_gpio);
+        if (gpio_is_valid(slot->cd_gpio))
+                gpio_free(slot->cd_gpio);
 }
 
 #else
 
-#define mfd_sd_probe_slot       NULL
-#define mfd_sd_remove_slot      NULL
+static inline void sdhci_pci_add_own_cd(struct sdhci_pci_slot *slot)
+{
+}
+
+static inline void sdhci_pci_remove_own_cd(struct sdhci_pci_slot *slot)
+{
+}
 
 #endif
 
 static int mfd_emmc_probe_slot(struct sdhci_pci_slot *slot)
 {
-        const char *name = NULL;
-        int gpio = -EINVAL;
-
-        sfi_table_parse(SFI_SIG_GPIO, NULL, NULL, mfd_emmc_gpio_parse);
-
-        switch (slot->chip->pdev->device) {
-        case PCI_DEVICE_ID_INTEL_MFD_EMMC0:
-                gpio = mfd_emmc0_rst_gpio;
-                name = "eMMC0_reset";
-                break;
-        case PCI_DEVICE_ID_INTEL_MFD_EMMC1:
-                gpio = mfd_emmc1_rst_gpio;
-                name = "eMMC1_reset";
-                break;
-        }
-
-        if (!gpio_request(gpio, name)) {
-                gpio_direction_output(gpio, 1);
-                slot->rst_n_gpio = gpio;
-                slot->host->mmc->caps |= MMC_CAP_HW_RESET;
-        }
-
         slot->host->mmc->caps |= MMC_CAP_8_BIT_DATA | MMC_CAP_NONREMOVABLE;
-
         slot->host->mmc->caps2 = MMC_CAP2_BOOTPART_NOACC;
-
         return 0;
 }
 
-static void mfd_emmc_remove_slot(struct sdhci_pci_slot *slot, int dead)
+static int mfd_sdio_probe_slot(struct sdhci_pci_slot *slot)
 {
-        gpio_free(slot->rst_n_gpio);
+        slot->host->mmc->caps |= MMC_CAP_POWER_OFF_CARD;
+        return 0;
 }
 
 static const struct sdhci_pci_fixes sdhci_intel_mrst_hc0 = {
@@ -307,20 +267,18 @@ static const struct sdhci_pci_fixes sdhci_intel_mrst_hc1_hc2 = {
 static const struct sdhci_pci_fixes sdhci_intel_mfd_sd = {
         .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .allow_runtime_pm = true,
-        .probe_slot     = mfd_sd_probe_slot,
-        .remove_slot    = mfd_sd_remove_slot,
 };
 
 static const struct sdhci_pci_fixes sdhci_intel_mfd_sdio = {
         .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .allow_runtime_pm = true,
+        .probe_slot     = mfd_sdio_probe_slot,
 };
 
 static const struct sdhci_pci_fixes sdhci_intel_mfd_emmc = {
         .quirks         = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
         .allow_runtime_pm = true,
         .probe_slot     = mfd_emmc_probe_slot,
-        .remove_slot    = mfd_emmc_remove_slot,
 };
 
 /* O2Micro extra registers */
@@ -1012,11 +970,8 @@ static int sdhci_pci_suspend(struct device *dev)
 
                 ret = sdhci_suspend_host(slot->host);
 
-                if (ret) {
-                        for (i--; i >= 0; i--)
-                                sdhci_resume_host(chip->slots[i]->host);
-                        return ret;
-                }
+                if (ret)
+                        goto err_pci_suspend;
 
                 slot_pm_flags = slot->host->mmc->pm_flags;
                 if (slot_pm_flags & MMC_PM_WAKE_SDIO_IRQ)
@@ -1027,11 +982,8 @@ static int sdhci_pci_suspend(struct device *dev)
 
         if (chip->fixes && chip->fixes->suspend) {
                 ret = chip->fixes->suspend(chip);
-                if (ret) {
-                        for (i = chip->num_slots - 1; i >= 0; i--)
-                                sdhci_resume_host(chip->slots[i]->host);
-                        return ret;
-                }
+                if (ret)
+                        goto err_pci_suspend;
         }
 
         pci_save_state(pdev);
@@ -1048,6 +1000,11 @@ static int sdhci_pci_suspend(struct device *dev)
         }
 
         return 0;
+
+err_pci_suspend:
+        while (--i >= 0)
+                sdhci_resume_host(chip->slots[i]->host);
+        return ret;
 }
 
 static int sdhci_pci_resume(struct device *dev)
@@ -1113,23 +1070,22 @@ static int sdhci_pci_runtime_suspend(struct device *dev)
 
                 ret = sdhci_runtime_suspend_host(slot->host);
 
-                if (ret) {
-                        for (i--; i >= 0; i--)
-                                sdhci_runtime_resume_host(chip->slots[i]->host);
-                        return ret;
-                }
+                if (ret)
+                        goto err_pci_runtime_suspend;
         }
 
         if (chip->fixes && chip->fixes->suspend) {
                 ret = chip->fixes->suspend(chip);
-                if (ret) {
-                        for (i = chip->num_slots - 1; i >= 0; i--)
-                                sdhci_runtime_resume_host(chip->slots[i]->host);
-                        return ret;
-                }
+                if (ret)
+                        goto err_pci_runtime_suspend;
         }
 
         return 0;
+
+err_pci_runtime_suspend:
+        while (--i >= 0)
+                sdhci_runtime_resume_host(chip->slots[i]->host);
+        return ret;
 }
 
 static int sdhci_pci_runtime_resume(struct device *dev)
@@ -1190,11 +1146,12 @@ static const struct dev_pm_ops sdhci_pci_pm_ops = {
 \*****************************************************************************/
 
 static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
-        struct pci_dev *pdev, struct sdhci_pci_chip *chip, int bar)
+        struct pci_dev *pdev, struct sdhci_pci_chip *chip, int first_bar,
+        int slotno)
 {
         struct sdhci_pci_slot *slot;
         struct sdhci_host *host;
-        int ret;
+        int ret, bar = first_bar + slotno;
 
         if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) {
                 dev_err(&pdev->dev, "BAR %d is not iomem. Aborting.\n", bar);
@@ -1228,6 +1185,23 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
         slot->host = host;
         slot->pci_bar = bar;
         slot->rst_n_gpio = -EINVAL;
+        slot->cd_gpio = -EINVAL;
+
+        /* Retrieve platform data if there is any */
+        if (*sdhci_pci_get_data)
+                slot->data = sdhci_pci_get_data(pdev, slotno);
+
+        if (slot->data) {
+                if (slot->data->setup) {
+                        ret = slot->data->setup(slot->data);
+                        if (ret) {
+                                dev_err(&pdev->dev, "platform setup failed\n");
+                                goto free;
+                        }
+                }
+                slot->rst_n_gpio = slot->data->rst_n_gpio;
+                slot->cd_gpio = slot->data->cd_gpio;
+        }
 
         host->hw_name = "PCI";
         host->ops = &sdhci_pci_ops;
@@ -1238,7 +1212,7 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
         ret = pci_request_region(pdev, bar, mmc_hostname(host->mmc));
         if (ret) {
                 dev_err(&pdev->dev, "cannot request region\n");
-                goto free;
+                goto cleanup;
         }
 
         host->ioaddr = pci_ioremap_bar(pdev, bar);
@@ -1254,15 +1228,30 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
                         goto unmap;
         }
 
+        if (gpio_is_valid(slot->rst_n_gpio)) {
+                if (!gpio_request(slot->rst_n_gpio, "eMMC_reset")) {
+                        gpio_direction_output(slot->rst_n_gpio, 1);
+                        slot->host->mmc->caps |= MMC_CAP_HW_RESET;
+                } else {
+                        dev_warn(&pdev->dev, "failed to request rst_n_gpio\n");
+                        slot->rst_n_gpio = -EINVAL;
+                }
+        }
+
         host->mmc->pm_caps = MMC_PM_KEEP_POWER | MMC_PM_WAKE_SDIO_IRQ;
 
         ret = sdhci_add_host(host);
         if (ret)
                 goto remove;
 
+        sdhci_pci_add_own_cd(slot);
+
         return slot;
 
 remove:
+        if (gpio_is_valid(slot->rst_n_gpio))
+                gpio_free(slot->rst_n_gpio);
+
         if (chip->fixes && chip->fixes->remove_slot)
                 chip->fixes->remove_slot(slot, 0);
 
@@ -1272,6 +1261,10 @@ unmap:
 release:
         pci_release_region(pdev, bar);
 
+cleanup:
+        if (slot->data && slot->data->cleanup)
+                slot->data->cleanup(slot->data);
+
 free:
         sdhci_free_host(host);
 
@@ -1283,6 +1276,8 @@ static void sdhci_pci_remove_slot(struct sdhci_pci_slot *slot)
         int dead;
         u32 scratch;
 
+        sdhci_pci_remove_own_cd(slot);
+
         dead = 0;
         scratch = readl(slot->host->ioaddr + SDHCI_INT_STATUS);
         if (scratch == (u32)-1)
@@ -1290,9 +1285,15 @@ static void sdhci_pci_remove_slot(struct sdhci_pci_slot *slot)
 
         sdhci_remove_host(slot->host, dead);
 
+        if (gpio_is_valid(slot->rst_n_gpio))
+                gpio_free(slot->rst_n_gpio);
+
         if (slot->chip->fixes && slot->chip->fixes->remove_slot)
                 slot->chip->fixes->remove_slot(slot, dead);
 
+        if (slot->data && slot->data->cleanup)
+                slot->data->cleanup(slot->data);
+
         pci_release_region(slot->chip->pdev, slot->pci_bar);
 
         sdhci_free_host(slot->host);
@@ -1379,7 +1380,7 @@ static int __devinit sdhci_pci_probe(struct pci_dev *pdev,
         slots = chip->num_slots;        /* Quirk may have changed this */
 
         for (i = 0; i < slots; i++) {
-                slot = sdhci_pci_probe_slot(pdev, chip, first_bar + i);
+                slot = sdhci_pci_probe_slot(pdev, chip, first_bar, i);
                 if (IS_ERR(slot)) {
                         for (i--; i >= 0; i--)
                                 sdhci_pci_remove_slot(chip->slots[i]);
diff --git a/drivers/mmc/host/sdhci-pxav2.c b/drivers/mmc/host/sdhci-pxav2.c
index 7a039c3cb1f1..dbb75bfbcffb 100644
--- a/drivers/mmc/host/sdhci-pxav2.c
+++ b/drivers/mmc/host/sdhci-pxav2.c
@@ -223,18 +223,8 @@ static struct platform_driver sdhci_pxav2_driver = {
         .probe          = sdhci_pxav2_probe,
         .remove         = __devexit_p(sdhci_pxav2_remove),
 };
-static int __init sdhci_pxav2_init(void)
-{
-        return platform_driver_register(&sdhci_pxav2_driver);
-}
-
-static void __exit sdhci_pxav2_exit(void)
-{
-        platform_driver_unregister(&sdhci_pxav2_driver);
-}
 
-module_init(sdhci_pxav2_init);
-module_exit(sdhci_pxav2_exit);
+module_platform_driver(sdhci_pxav2_driver);
 
 MODULE_DESCRIPTION("SDHCI driver for pxav2");
 MODULE_AUTHOR("Marvell International Ltd.");
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
index 15673a7ee6a5..f29695683556 100644
--- a/drivers/mmc/host/sdhci-pxav3.c
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -269,18 +269,8 @@ static struct platform_driver sdhci_pxav3_driver = {
         .probe          = sdhci_pxav3_probe,
         .remove         = __devexit_p(sdhci_pxav3_remove),
 };
-static int __init sdhci_pxav3_init(void)
-{
-        return platform_driver_register(&sdhci_pxav3_driver);
-}
-
-static void __exit sdhci_pxav3_exit(void)
-{
-        platform_driver_unregister(&sdhci_pxav3_driver);
-}
 
-module_init(sdhci_pxav3_init);
-module_exit(sdhci_pxav3_exit);
+module_platform_driver(sdhci_pxav3_driver);
 
 MODULE_DESCRIPTION("SDHCI driver for pxav3");
 MODULE_AUTHOR("Marvell International Ltd.");
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index 9a20d1f55bb7..1af756ee0f9a 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -80,7 +80,7 @@ static void sdhci_s3c_check_sclk(struct sdhci_host *host)
 
                 tmp &= ~S3C_SDHCI_CTRL2_SELBASECLK_MASK;
                 tmp |= ourhost->cur_clk << S3C_SDHCI_CTRL2_SELBASECLK_SHIFT;
-                writel(tmp, host->ioaddr + 0x80);
+                writel(tmp, host->ioaddr + S3C_SDHCI_CONTROL2);
         }
 }
 
@@ -521,6 +521,9 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         if (pdata->host_caps)
                 host->mmc->caps |= pdata->host_caps;
 
+        if (pdata->pm_caps)
+                host->mmc->pm_caps |= pdata->pm_caps;
+
         host->quirks |= (SDHCI_QUIRK_32BIT_DMA_ADDR |
                          SDHCI_QUIRK_32BIT_DMA_SIZE);
 
@@ -654,18 +657,7 @@ static struct platform_driver sdhci_s3c_driver = {
         },
 };
 
-static int __init sdhci_s3c_init(void)
-{
-        return platform_driver_register(&sdhci_s3c_driver);
-}
-
-static void __exit sdhci_s3c_exit(void)
-{
-        platform_driver_unregister(&sdhci_s3c_driver);
-}
-
-module_init(sdhci_s3c_init);
-module_exit(sdhci_s3c_exit);
+module_platform_driver(sdhci_s3c_driver);
 
 MODULE_DESCRIPTION("Samsung SDHCI (HSMMC) glue");
 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
diff --git a/drivers/mmc/host/sdhci-spear.c b/drivers/mmc/host/sdhci-spear.c
index 63cc8b6a1c9e..b7f8b33c5f19 100644
--- a/drivers/mmc/host/sdhci-spear.c
+++ b/drivers/mmc/host/sdhci-spear.c
@@ -21,6 +21,7 @@
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/platform_device.h>
+#include <linux/pm.h>
 #include <linux/slab.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/sdhci-spear.h>
@@ -271,26 +272,54 @@ static int __devexit sdhci_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int sdhci_suspend(struct device *dev)
+{
+        struct sdhci_host *host = dev_get_drvdata(dev);
+        struct spear_sdhci *sdhci = dev_get_platdata(dev);
+        int ret;
+
+        ret = sdhci_suspend_host(host);
+        if (!ret)
+                clk_disable(sdhci->clk);
+
+        return ret;
+}
+
+static int sdhci_resume(struct device *dev)
+{
+        struct sdhci_host *host = dev_get_drvdata(dev);
+        struct spear_sdhci *sdhci = dev_get_platdata(dev);
+        int ret;
+
+        ret = clk_enable(sdhci->clk);
+        if (ret) {
+                dev_dbg(dev, "Resume: Error enabling clock\n");
+                return ret;
+        }
+
+        return sdhci_resume_host(host);
+}
+
+const struct dev_pm_ops sdhci_pm_ops = {
+        .suspend        = sdhci_suspend,
+        .resume         = sdhci_resume,
+};
+#endif
+
 static struct platform_driver sdhci_driver = {
         .driver = {
                 .name   = "sdhci",
                 .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &sdhci_pm_ops,
+#endif
         },
         .probe          = sdhci_probe,
         .remove         = __devexit_p(sdhci_remove),
 };
 
-static int __init sdhci_init(void)
-{
-        return platform_driver_register(&sdhci_driver);
-}
-module_init(sdhci_init);
-
-static void __exit sdhci_exit(void)
-{
-        platform_driver_unregister(&sdhci_driver);
-}
-module_exit(sdhci_exit);
+module_platform_driver(sdhci_driver);
 
 MODULE_DESCRIPTION("SPEAr Secure Digital Host Controller Interface driver");
 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@st.com>");
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
index e2e18d3f949c..78a36eba4df0 100644
--- a/drivers/mmc/host/sdhci-tegra.c
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -324,17 +324,7 @@ static struct platform_driver sdhci_tegra_driver = {
         .remove         = __devexit_p(sdhci_tegra_remove),
 };
 
-static int __init sdhci_tegra_init(void)
-{
-        return platform_driver_register(&sdhci_tegra_driver);
-}
-module_init(sdhci_tegra_init);
-
-static void __exit sdhci_tegra_exit(void)
-{
-        platform_driver_unregister(&sdhci_tegra_driver);
-}
-module_exit(sdhci_tegra_exit);
+module_platform_driver(sdhci_tegra_driver);
 
 MODULE_DESCRIPTION("SDHCI driver for Tegra");
 MODULE_AUTHOR(" Google, Inc.");
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 19ed580f2cab..8d66706824a6 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -49,7 +49,7 @@ static void sdhci_finish_data(struct sdhci_host *);
 
 static void sdhci_send_command(struct sdhci_host *, struct mmc_command *);
 static void sdhci_finish_command(struct sdhci_host *);
-static int sdhci_execute_tuning(struct mmc_host *mmc);
+static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode);
 static void sdhci_tuning_timer(unsigned long data);
 
 #ifdef CONFIG_PM_RUNTIME
@@ -146,10 +146,8 @@ static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
 {
         u32 present, irqs;
 
-        if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
-                return;
-
-        if (host->quirks2 & SDHCI_QUIRK2_OWN_CARD_DETECTION)
+        if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
+            !mmc_card_is_removable(host->mmc))
                 return;
 
         present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
@@ -214,6 +212,11 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
 
         if (host->quirks & SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET)
                 sdhci_clear_set_irqs(host, SDHCI_INT_ALL_MASK, ier);
+
+        if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
+                if ((host->ops->enable_dma) && (mask & SDHCI_RESET_ALL))
+                        host->ops->enable_dma(host);
+        }
 }
 
 static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios);
@@ -423,12 +426,12 @@ static void sdhci_transfer_pio(struct sdhci_host *host)
 static char *sdhci_kmap_atomic(struct scatterlist *sg, unsigned long *flags)
 {
         local_irq_save(*flags);
-        return kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
+        return kmap_atomic(sg_page(sg)) + sg->offset;
 }
 
 static void sdhci_kunmap_atomic(void *buffer, unsigned long *flags)
 {
-        kunmap_atomic(buffer, KM_BIO_SRC_IRQ);
+        kunmap_atomic(buffer);
         local_irq_restore(*flags);
 }
 
@@ -1016,7 +1019,8 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
                 flags |= SDHCI_CMD_INDEX;
 
         /* CMD19 is special in that the Data Present Select should be set */
-        if (cmd->data || (cmd->opcode == MMC_SEND_TUNING_BLOCK))
+        if (cmd->data || cmd->opcode == MMC_SEND_TUNING_BLOCK ||
+            cmd->opcode == MMC_SEND_TUNING_BLOCK_HS200)
                 flags |= SDHCI_CMD_DATA;
 
         sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
@@ -1066,12 +1070,15 @@ static void sdhci_finish_command(struct sdhci_host *host)
 static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
 {
         int div = 0; /* Initialized for compiler warning */
+        int real_div = div, clk_mul = 1;
         u16 clk = 0;
         unsigned long timeout;
 
-        if (clock == host->clock)
+        if (clock && clock == host->clock)
                 return;
 
+        host->mmc->actual_clock = 0;
+
         if (host->ops->set_clock) {
                 host->ops->set_clock(host, clock);
                 if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK)
@@ -1109,6 +1116,8 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
                                  * Control register.
                                  */
                                 clk = SDHCI_PROG_CLOCK_MODE;
+                                real_div = div;
+                                clk_mul = host->clk_mul;
                                 div--;
                         }
                 } else {
@@ -1122,6 +1131,7 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
                                                 break;
                                 }
                         }
+                        real_div = div;
                         div >>= 1;
                 }
         } else {
@@ -1130,9 +1140,13 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
                         if ((host->max_clk / div) <= clock)
                                 break;
                 }
+                real_div = div;
                 div >>= 1;
         }
 
+        if (real_div)
+                host->mmc->actual_clock = (host->max_clk * clk_mul) / real_div;
+
         clk |= (div & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
         clk |= ((div & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN)
                 << SDHCI_DIVIDER_HI_SHIFT;
@@ -1160,7 +1174,7 @@ out:
         host->clock = clock;
 }
 
-static void sdhci_set_power(struct sdhci_host *host, unsigned short power)
+static int sdhci_set_power(struct sdhci_host *host, unsigned short power)
 {
         u8 pwr = 0;
 
@@ -1183,13 +1197,13 @@ static void sdhci_set_power(struct sdhci_host *host, unsigned short power)
         }
 
         if (host->pwr == pwr)
-                return;
+                return -1;
 
         host->pwr = pwr;
 
         if (pwr == 0) {
                 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
-                return;
+                return 0;
         }
 
         /*
@@ -1216,6 +1230,8 @@ static void sdhci_set_power(struct sdhci_host *host, unsigned short power)
          */
         if (host->quirks & SDHCI_QUIRK_DELAY_AFTER_POWER)
                 mdelay(10);
+
+        return power;
 }
 
 /*****************************************************************************\
@@ -1277,7 +1293,7 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
                 if ((host->flags & SDHCI_NEEDS_RETUNING) &&
                     !(present_state & (SDHCI_DOING_WRITE | SDHCI_DOING_READ))) {
                         spin_unlock_irqrestore(&host->lock, flags);
-                        sdhci_execute_tuning(mmc);
+                        sdhci_execute_tuning(mmc, mrq->cmd->opcode);
                         spin_lock_irqsave(&host->lock, flags);
 
                         /* Restore original mmc_request structure */
@@ -1297,12 +1313,17 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
 {
         unsigned long flags;
+        int vdd_bit = -1;
         u8 ctrl;
 
         spin_lock_irqsave(&host->lock, flags);
 
-        if (host->flags & SDHCI_DEVICE_DEAD)
-                goto out;
+        if (host->flags & SDHCI_DEVICE_DEAD) {
+                spin_unlock_irqrestore(&host->lock, flags);
+                if (host->vmmc && ios->power_mode == MMC_POWER_OFF)
+                        mmc_regulator_set_ocr(host->mmc, host->vmmc, 0);
+                return;
+        }
 
         /*
          * Reset the chip on each power off.
@@ -1316,9 +1337,15 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
         sdhci_set_clock(host, ios->clock);
 
         if (ios->power_mode == MMC_POWER_OFF)
-                sdhci_set_power(host, -1);
+                vdd_bit = sdhci_set_power(host, -1);
         else
-                sdhci_set_power(host, ios->vdd);
+                vdd_bit = sdhci_set_power(host, ios->vdd);
+
+        if (host->vmmc && vdd_bit != -1) {
+                spin_unlock_irqrestore(&host->lock, flags);
+                mmc_regulator_set_ocr(host->mmc, host->vmmc, vdd_bit);
+                spin_lock_irqsave(&host->lock, flags);
+        }
 
         if (host->ops->platform_send_init_74_clocks)
                 host->ops->platform_send_init_74_clocks(host, ios->power_mode);
@@ -1361,11 +1388,11 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
                 unsigned int clock;
 
                 /* In case of UHS-I modes, set High Speed Enable */
-                if ((ios->timing == MMC_TIMING_UHS_SDR50) ||
+                if ((ios->timing == MMC_TIMING_MMC_HS200) ||
+                    (ios->timing == MMC_TIMING_UHS_SDR50) ||
                     (ios->timing == MMC_TIMING_UHS_SDR104) ||
                     (ios->timing == MMC_TIMING_UHS_DDR50) ||
-                    (ios->timing == MMC_TIMING_UHS_SDR25) ||
-                    (ios->timing == MMC_TIMING_UHS_SDR12))
+                    (ios->timing == MMC_TIMING_UHS_SDR25))
                         ctrl |= SDHCI_CTRL_HISPD;
 
                 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
@@ -1415,7 +1442,9 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
                         ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
                         /* Select Bus Speed Mode for host */
                         ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
-                        if (ios->timing == MMC_TIMING_UHS_SDR12)
+                        if (ios->timing == MMC_TIMING_MMC_HS200)
+                                ctrl_2 |= SDHCI_CTRL_HS_SDR200;
+                        else if (ios->timing == MMC_TIMING_UHS_SDR12)
                                 ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
                         else if (ios->timing == MMC_TIMING_UHS_SDR25)
                                 ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
@@ -1443,7 +1472,6 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
         if(host->quirks & SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS)
                 sdhci_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
 
-out:
         mmiowb();
         spin_unlock_irqrestore(&host->lock, flags);
 }
@@ -1663,7 +1691,7 @@ static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
         return err;
 }
 
-static int sdhci_execute_tuning(struct mmc_host *mmc)
+static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
 {
         struct sdhci_host *host;
         u16 ctrl;
@@ -1671,6 +1699,7 @@ static int sdhci_execute_tuning(struct mmc_host *mmc)
         int tuning_loop_counter = MAX_TUNING_LOOP;
         unsigned long timeout;
         int err = 0;
+        bool requires_tuning_nonuhs = false;
 
         host = mmc_priv(mmc);
 
@@ -1681,13 +1710,19 @@ static int sdhci_execute_tuning(struct mmc_host *mmc)
         ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
 
         /*
-         * Host Controller needs tuning only in case of SDR104 mode
-         * and for SDR50 mode when Use Tuning for SDR50 is set in
+         * The Host Controller needs tuning only in case of SDR104 mode
+         * and for SDR50 mode when Use Tuning for SDR50 is set in the
          * Capabilities register.
+         * If the Host Controller supports the HS200 mode then the
+         * tuning function has to be executed.
          */
+        if (((ctrl & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
+            (host->flags & SDHCI_SDR50_NEEDS_TUNING ||
+             host->flags & SDHCI_HS200_NEEDS_TUNING))
+                requires_tuning_nonuhs = true;
+
         if (((ctrl & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR104) ||
-            (((ctrl & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
-            (host->flags & SDHCI_SDR50_NEEDS_TUNING)))
+            requires_tuning_nonuhs)
                 ctrl |= SDHCI_CTRL_EXEC_TUNING;
         else {
                 spin_unlock(&host->lock);
@@ -1723,7 +1758,7 @@ static int sdhci_execute_tuning(struct mmc_host *mmc)
                 if (!tuning_loop_counter && !timeout)
                         break;
 
-                cmd.opcode = MMC_SEND_TUNING_BLOCK;
+                cmd.opcode = opcode;
                 cmd.arg = 0;
                 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
                 cmd.retries = 0;
@@ -1738,7 +1773,17 @@ static int sdhci_execute_tuning(struct mmc_host *mmc)
                  * block to the Host Controller. So we set the block size
                  * to 64 here.
                  */
-                sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 64), SDHCI_BLOCK_SIZE);
+                if (cmd.opcode == MMC_SEND_TUNING_BLOCK_HS200) {
+                        if (mmc->ios.bus_width == MMC_BUS_WIDTH_8)
+                                sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 128),
+                                             SDHCI_BLOCK_SIZE);
+                        else if (mmc->ios.bus_width == MMC_BUS_WIDTH_4)
+                                sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 64),
+                                             SDHCI_BLOCK_SIZE);
+                } else {
+                        sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 64),
+                                     SDHCI_BLOCK_SIZE);
+                }
 
                 /*
                  * The tuning block is sent by the card to the host controller.
@@ -2121,12 +2166,14 @@ static void sdhci_show_adma_error(struct sdhci_host *host) { }
 
 static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
 {
+        u32 command;
         BUG_ON(intmask == 0);
 
         /* CMD19 generates _only_ Buffer Read Ready interrupt */
         if (intmask & SDHCI_INT_DATA_AVAIL) {
-                if (SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND)) ==
-                    MMC_SEND_TUNING_BLOCK) {
+                command = SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND));
+                if (command == MMC_SEND_TUNING_BLOCK ||
+                    command == MMC_SEND_TUNING_BLOCK_HS200) {
                         host->tuning_done = 1;
                         wake_up(&host->buf_ready_int);
                         return;
@@ -2330,26 +2377,33 @@ out:
 int sdhci_suspend_host(struct sdhci_host *host)
 {
         int ret;
+        bool has_tuning_timer;
 
         sdhci_disable_card_detection(host);
 
         /* Disable tuning since we are suspending */
-        if (host->version >= SDHCI_SPEC_300 && host->tuning_count &&
-            host->tuning_mode == SDHCI_TUNING_MODE_1) {
+        has_tuning_timer = host->version >= SDHCI_SPEC_300 &&
+                host->tuning_count && host->tuning_mode == SDHCI_TUNING_MODE_1;
+        if (has_tuning_timer) {
+                del_timer_sync(&host->tuning_timer);
                 host->flags &= ~SDHCI_NEEDS_RETUNING;
-                mod_timer(&host->tuning_timer, jiffies +
-                        host->tuning_count * HZ);
         }
 
         ret = mmc_suspend_host(host->mmc);
-        if (ret)
+        if (ret) {
+                if (has_tuning_timer) {
+                        host->flags |= SDHCI_NEEDS_RETUNING;
+                        mod_timer(&host->tuning_timer, jiffies +
+                                        host->tuning_count * HZ);
+                }
+
+                sdhci_enable_card_detection(host);
+
                 return ret;
+        }
 
         free_irq(host->irq, host);
 
-        if (host->vmmc)
-                ret = regulator_disable(host->vmmc);
-
         return ret;
 }
 
@@ -2359,12 +2413,6 @@ int sdhci_resume_host(struct sdhci_host *host)
 {
         int ret;
 
-        if (host->vmmc) {
-                int ret = regulator_enable(host->vmmc);
-                if (ret)
-                        return ret;
-        }
-
         if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
                 if (host->ops->enable_dma)
                         host->ops->enable_dma(host);
@@ -2727,10 +2775,14 @@ int sdhci_add_host(struct sdhci_host *host)
         if (caps[1] & SDHCI_SUPPORT_DDR50)
                 mmc->caps |= MMC_CAP_UHS_DDR50;
 
-        /* Does the host needs tuning for SDR50? */
+        /* Does the host need tuning for SDR50? */
         if (caps[1] & SDHCI_USE_SDR50_TUNING)
                 host->flags |= SDHCI_SDR50_NEEDS_TUNING;
 
+        /* Does the host need tuning for HS200? */
+        if (mmc->caps2 & MMC_CAP2_HS200)
+                host->flags |= SDHCI_HS200_NEEDS_TUNING;
+
         /* Driver Type(s) (A, C, D) supported by the host */
         if (caps[1] & SDHCI_DRIVER_TYPE_A)
                 mmc->caps |= MMC_CAP_DRIVER_TYPE_A;
@@ -2926,8 +2978,6 @@ int sdhci_add_host(struct sdhci_host *host)
         if (IS_ERR(host->vmmc)) {
                 pr_info("%s: no vmmc regulator found\n", mmc_hostname(mmc));
                 host->vmmc = NULL;
-        } else {
-                regulator_enable(host->vmmc);
         }
 
         sdhci_init(host, 0);
@@ -3016,10 +3066,8 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
         tasklet_kill(&host->card_tasklet);
         tasklet_kill(&host->finish_tasklet);
 
-        if (host->vmmc) {
-                regulator_disable(host->vmmc);
+        if (host->vmmc)
                 regulator_put(host->vmmc);
-        }
 
         kfree(host->adma_desc);
         kfree(host->align_buffer);
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index a04d4d0c6fd2..ad265b96b75b 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -158,6 +158,7 @@
 #define   SDHCI_CTRL_UHS_SDR50          0x0002
 #define   SDHCI_CTRL_UHS_SDR104         0x0003
 #define   SDHCI_CTRL_UHS_DDR50          0x0004
+#define   SDHCI_CTRL_HS_SDR200          0x0005 /* reserved value in SDIO spec */
 #define  SDHCI_CTRL_VDD_180             0x0008
 #define  SDHCI_CTRL_DRV_TYPE_MASK       0x0030
 #define   SDHCI_CTRL_DRV_TYPE_B         0x0000
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index d5505f3fe2a1..4a2c5b2355f2 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -16,6 +16,33 @@
  *
  */
 
+/*
+ * The MMCIF driver is now processing MMC requests asynchronously, according
+ * to the Linux MMC API requirement.
+ *
+ * The MMCIF driver processes MMC requests in up to 3 stages: command, optional
+ * data, and optional stop. To achieve asynchronous processing each of these
+ * stages is split into two halves: a top and a bottom half. The top half
+ * initialises the hardware, installs a timeout handler to handle completion
+ * timeouts, and returns. In case of the command stage this immediately returns
+ * control to the caller, leaving all further processing to run asynchronously.
+ * All further request processing is performed by the bottom halves.
+ *
+ * The bottom half further consists of a "hard" IRQ handler, an IRQ handler
+ * thread, a DMA completion callback, if DMA is used, a timeout work, and
+ * request- and stage-specific handler methods.
+ *
+ * Each bottom half run begins with either a hardware interrupt, a DMA callback
+ * invocation, or a timeout work run. In case of an error or a successful
+ * processing completion, the MMC core is informed and the request processing is
+ * finished. In case processing has to continue, i.e., if data has to be read
+ * from or written to the card, or if a stop command has to be sent, the next
+ * top half is called, which performs the necessary hardware handling and
+ * reschedules the timeout work. This returns the driver state machine into the
+ * bottom half waiting state.
+ */
+
+#include <linux/bitops.h>
 #include <linux/clk.h>
 #include <linux/completion.h>
 #include <linux/delay.h>
@@ -123,6 +150,11 @@
 #define MASK_MRBSYTO            (1 << 1)
 #define MASK_MRSPTO             (1 << 0)
 
+#define MASK_START_CMD          (MASK_MCMDVIO | MASK_MBUFVIO | MASK_MWDATERR | \
+                                 MASK_MRDATERR | MASK_MRIDXERR | MASK_MRSPERR | \
+                                 MASK_MCCSTO | MASK_MCRCSTO | MASK_MWDATTO | \
+                                 MASK_MRDATTO | MASK_MRBSYTO | MASK_MRSPTO)
+
 /* CE_HOST_STS1 */
 #define STS1_CMDSEQ             (1 << 31)
 
@@ -162,9 +194,21 @@ enum mmcif_state {
         STATE_IOS,
 };
 
+enum mmcif_wait_for {
+        MMCIF_WAIT_FOR_REQUEST,
+        MMCIF_WAIT_FOR_CMD,
+        MMCIF_WAIT_FOR_MREAD,
+        MMCIF_WAIT_FOR_MWRITE,
+        MMCIF_WAIT_FOR_READ,
+        MMCIF_WAIT_FOR_WRITE,
+        MMCIF_WAIT_FOR_READ_END,
+        MMCIF_WAIT_FOR_WRITE_END,
+        MMCIF_WAIT_FOR_STOP,
+};
+
 struct sh_mmcif_host {
         struct mmc_host *mmc;
-        struct mmc_data *data;
+        struct mmc_request *mrq;
         struct platform_device *pd;
         struct sh_dmae_slave dma_slave_tx;
         struct sh_dmae_slave dma_slave_rx;
@@ -172,11 +216,17 @@ struct sh_mmcif_host {
         unsigned int clk;
         int bus_width;
         bool sd_error;
+        bool dying;
         long timeout;
         void __iomem *addr;
-        struct completion intr_wait;
+        u32 *pio_ptr;
+        spinlock_t lock;                /* protect sh_mmcif_host::state */
         enum mmcif_state state;
-        spinlock_t lock;
+        enum mmcif_wait_for wait_for;
+        struct delayed_work timeout_work;
+        size_t blocksize;
+        int sg_idx;
+        int sg_blkidx;
         bool power;
         bool card_present;
 
@@ -202,19 +252,21 @@ static inline void sh_mmcif_bitclr(struct sh_mmcif_host *host,
 static void mmcif_dma_complete(void *arg)
 {
         struct sh_mmcif_host *host = arg;
+        struct mmc_data *data = host->mrq->data;
+
         dev_dbg(&host->pd->dev, "Command completed\n");
 
-        if (WARN(!host->data, "%s: NULL data in DMA completion!\n",
+        if (WARN(!data, "%s: NULL data in DMA completion!\n",
                  dev_name(&host->pd->dev)))
                 return;
 
-        if (host->data->flags & MMC_DATA_READ)
+        if (data->flags & MMC_DATA_READ)
                 dma_unmap_sg(host->chan_rx->device->dev,
-                             host->data->sg, host->data->sg_len,
+                             data->sg, data->sg_len,
                              DMA_FROM_DEVICE);
         else
                 dma_unmap_sg(host->chan_tx->device->dev,
-                             host->data->sg, host->data->sg_len,
+                             data->sg, data->sg_len,
                              DMA_TO_DEVICE);
 
         complete(&host->dma_complete);
@@ -222,13 +274,14 @@ static void mmcif_dma_complete(void *arg)
 
 static void sh_mmcif_start_dma_rx(struct sh_mmcif_host *host)
 {
-        struct scatterlist *sg = host->data->sg;
+        struct mmc_data *data = host->mrq->data;
+        struct scatterlist *sg = data->sg;
         struct dma_async_tx_descriptor *desc = NULL;
         struct dma_chan *chan = host->chan_rx;
         dma_cookie_t cookie = -EINVAL;
         int ret;
 
-        ret = dma_map_sg(chan->device->dev, sg, host->data->sg_len,
+        ret = dma_map_sg(chan->device->dev, sg, data->sg_len,
                          DMA_FROM_DEVICE);
         if (ret > 0) {
                 host->dma_active = true;
@@ -244,7 +297,7 @@ static void sh_mmcif_start_dma_rx(struct sh_mmcif_host *host)
                 dma_async_issue_pending(chan);
         }
         dev_dbg(&host->pd->dev, "%s(): mapped %d -> %d, cookie %d\n",
-                __func__, host->data->sg_len, ret, cookie);
+                __func__, data->sg_len, ret, cookie);
 
         if (!desc) {
                 /* DMA failed, fall back to PIO */
@@ -265,18 +318,19 @@ static void sh_mmcif_start_dma_rx(struct sh_mmcif_host *host)
         }
 
         dev_dbg(&host->pd->dev, "%s(): desc %p, cookie %d, sg[%d]\n", __func__,
-                desc, cookie, host->data->sg_len);
+                desc, cookie, data->sg_len);
 }
 
 static void sh_mmcif_start_dma_tx(struct sh_mmcif_host *host)
 {
-        struct scatterlist *sg = host->data->sg;
+        struct mmc_data *data = host->mrq->data;
+        struct scatterlist *sg = data->sg;
         struct dma_async_tx_descriptor *desc = NULL;
         struct dma_chan *chan = host->chan_tx;
         dma_cookie_t cookie = -EINVAL;
         int ret;
 
-        ret = dma_map_sg(chan->device->dev, sg, host->data->sg_len,
+        ret = dma_map_sg(chan->device->dev, sg, data->sg_len,
                          DMA_TO_DEVICE);
         if (ret > 0) {
                 host->dma_active = true;
@@ -292,7 +346,7 @@ static void sh_mmcif_start_dma_tx(struct sh_mmcif_host *host)
                 dma_async_issue_pending(chan);
         }
         dev_dbg(&host->pd->dev, "%s(): mapped %d -> %d, cookie %d\n",
-                __func__, host->data->sg_len, ret, cookie);
+                __func__, data->sg_len, ret, cookie);
 
         if (!desc) {
                 /* DMA failed, fall back to PIO */
@@ -399,7 +453,7 @@ static void sh_mmcif_clock_control(struct sh_mmcif_host *host, unsigned int clk)
                 sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_SUP_PCLK);
         else
                 sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_CLEAR &
-                        (ilog2(__rounddown_pow_of_two(host->clk / clk)) << 16));
+                                ((fls(host->clk / clk) - 1) << 16));
 
         sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_ENABLE);
 }
@@ -421,7 +475,7 @@ static void sh_mmcif_sync_reset(struct sh_mmcif_host *host)
 static int sh_mmcif_error_manage(struct sh_mmcif_host *host)
 {
         u32 state1, state2;
-        int ret, timeout = 10000000;
+        int ret, timeout;
 
         host->sd_error = false;
 
@@ -433,155 +487,212 @@ static int sh_mmcif_error_manage(struct sh_mmcif_host *host)
         if (state1 & STS1_CMDSEQ) {
                 sh_mmcif_bitset(host, MMCIF_CE_CMD_CTRL, CMD_CTRL_BREAK);
                 sh_mmcif_bitset(host, MMCIF_CE_CMD_CTRL, ~CMD_CTRL_BREAK);
-                while (1) {
-                        timeout--;
-                        if (timeout < 0) {
-                                dev_err(&host->pd->dev,
-                                        "Forceed end of command sequence timeout err\n");
-                                return -EIO;
-                        }
+                for (timeout = 10000000; timeout; timeout--) {
                         if (!(sh_mmcif_readl(host->addr, MMCIF_CE_HOST_STS1)
-                                                                & STS1_CMDSEQ))
+                              & STS1_CMDSEQ))
                                 break;
                         mdelay(1);
                 }
+                if (!timeout) {
+                        dev_err(&host->pd->dev,
+                                "Forced end of command sequence timeout err\n");
+                        return -EIO;
+                }
                 sh_mmcif_sync_reset(host);
                 dev_dbg(&host->pd->dev, "Forced end of command sequence\n");
                 return -EIO;
         }
 
         if (state2 & STS2_CRC_ERR) {
-                dev_dbg(&host->pd->dev, ": Happened CRC error\n");
+                dev_dbg(&host->pd->dev, ": CRC error\n");
                 ret = -EIO;
         } else if (state2 & STS2_TIMEOUT_ERR) {
-                dev_dbg(&host->pd->dev, ": Happened Timeout error\n");
+                dev_dbg(&host->pd->dev, ": Timeout\n");
                 ret = -ETIMEDOUT;
         } else {
-                dev_dbg(&host->pd->dev, ": Happened End/Index error\n");
+                dev_dbg(&host->pd->dev, ": End/Index error\n");
                 ret = -EIO;
         }
         return ret;
 }
 
-static int sh_mmcif_single_read(struct sh_mmcif_host *host,
-                                        struct mmc_request *mrq)
+static bool sh_mmcif_next_block(struct sh_mmcif_host *host, u32 *p)
 {
-        struct mmc_data *data = mrq->data;
-        long time;
-        u32 blocksize, i, *p = sg_virt(data->sg);
+        struct mmc_data *data = host->mrq->data;
+
+        host->sg_blkidx += host->blocksize;
+
+        /* data->sg->length must be a multiple of host->blocksize? */
+        BUG_ON(host->sg_blkidx > data->sg->length);
+
+        if (host->sg_blkidx == data->sg->length) {
+                host->sg_blkidx = 0;
+                if (++host->sg_idx < data->sg_len)
+                        host->pio_ptr = sg_virt(++data->sg);
+        } else {
+                host->pio_ptr = p;
+        }
+
+        if (host->sg_idx == data->sg_len)
+                return false;
+
+        return true;
+}
+
+static void sh_mmcif_single_read(struct sh_mmcif_host *host,
+                                 struct mmc_request *mrq)
+{
+        host->blocksize = (sh_mmcif_readl(host->addr, MMCIF_CE_BLOCK_SET) &
+                           BLOCK_SIZE_MASK) + 3;
+
+        host->wait_for = MMCIF_WAIT_FOR_READ;
+        schedule_delayed_work(&host->timeout_work, host->timeout);
 
         /* buf read enable */
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
-        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
-                        host->timeout);
-        if (time <= 0 || host->sd_error)
-                return sh_mmcif_error_manage(host);
-
-        blocksize = (BLOCK_SIZE_MASK &
-                        sh_mmcif_readl(host->addr, MMCIF_CE_BLOCK_SET)) + 3;
-        for (i = 0; i < blocksize / 4; i++)
+}
+
+static bool sh_mmcif_read_block(struct sh_mmcif_host *host)
+{
+        struct mmc_data *data = host->mrq->data;
+        u32 *p = sg_virt(data->sg);
+        int i;
+
+        if (host->sd_error) {
+                data->error = sh_mmcif_error_manage(host);
+                return false;
+        }
+
+        for (i = 0; i < host->blocksize / 4; i++)
                 *p++ = sh_mmcif_readl(host->addr, MMCIF_CE_DATA);
 
         /* buffer read end */
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFRE);
-        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
-                        host->timeout);
-        if (time <= 0 || host->sd_error)
-                return sh_mmcif_error_manage(host);
+        host->wait_for = MMCIF_WAIT_FOR_READ_END;
 
-        return 0;
+        return true;
 }
 
-static int sh_mmcif_multi_read(struct sh_mmcif_host *host,
-                                        struct mmc_request *mrq)
+static void sh_mmcif_multi_read(struct sh_mmcif_host *host,
+                                struct mmc_request *mrq)
 {
         struct mmc_data *data = mrq->data;
-        long time;
-        u32 blocksize, i, j, sec, *p;
-
-        blocksize = BLOCK_SIZE_MASK & sh_mmcif_readl(host->addr,
-                                                     MMCIF_CE_BLOCK_SET);
-        for (j = 0; j < data->sg_len; j++) {
-                p = sg_virt(data->sg);
-                for (sec = 0; sec < data->sg->length / blocksize; sec++) {
-                        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
-                        /* buf read enable */
-                        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
-                                host->timeout);
-
-                        if (time <= 0 || host->sd_error)
-                                return sh_mmcif_error_manage(host);
-
-                        for (i = 0; i < blocksize / 4; i++)
-                                *p++ = sh_mmcif_readl(host->addr,
-                                                      MMCIF_CE_DATA);
-                }
-                if (j < data->sg_len - 1)
-                        data->sg++;
+
+        if (!data->sg_len || !data->sg->length)
+                return;
+
+        host->blocksize = sh_mmcif_readl(host->addr, MMCIF_CE_BLOCK_SET) &
+                BLOCK_SIZE_MASK;
+
+        host->wait_for = MMCIF_WAIT_FOR_MREAD;
+        host->sg_idx = 0;
+        host->sg_blkidx = 0;
+        host->pio_ptr = sg_virt(data->sg);
+        schedule_delayed_work(&host->timeout_work, host->timeout);
+        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
+}
+
+static bool sh_mmcif_mread_block(struct sh_mmcif_host *host)
+{
+        struct mmc_data *data = host->mrq->data;
+        u32 *p = host->pio_ptr;
+        int i;
+
+        if (host->sd_error) {
+                data->error = sh_mmcif_error_manage(host);
+                return false;
         }
-        return 0;
+
+        BUG_ON(!data->sg->length);
+
+        for (i = 0; i < host->blocksize / 4; i++)
+                *p++ = sh_mmcif_readl(host->addr, MMCIF_CE_DATA);
+
+        if (!sh_mmcif_next_block(host, p))
+                return false;
+
+        schedule_delayed_work(&host->timeout_work, host->timeout);
+        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
+
+        return true;
 }
 
-static int sh_mmcif_single_write(struct sh_mmcif_host *host,
+static void sh_mmcif_single_write(struct sh_mmcif_host *host,
                                         struct mmc_request *mrq)
 {
-        struct mmc_data *data = mrq->data;
-        long time;
-        u32 blocksize, i, *p = sg_virt(data->sg);
+        host->blocksize = (sh_mmcif_readl(host->addr, MMCIF_CE_BLOCK_SET) &
+                           BLOCK_SIZE_MASK) + 3;
 
-        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
+        host->wait_for = MMCIF_WAIT_FOR_WRITE;
+        schedule_delayed_work(&host->timeout_work, host->timeout);
 
         /* buf write enable */
-        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
-                        host->timeout);
-        if (time <= 0 || host->sd_error)
-                return sh_mmcif_error_manage(host);
-
-        blocksize = (BLOCK_SIZE_MASK &
-                        sh_mmcif_readl(host->addr, MMCIF_CE_BLOCK_SET)) + 3;
-        for (i = 0; i < blocksize / 4; i++)
+        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
+}
+
+static bool sh_mmcif_write_block(struct sh_mmcif_host *host)
+{
+        struct mmc_data *data = host->mrq->data;
+        u32 *p = sg_virt(data->sg);
+        int i;
+
+        if (host->sd_error) {
+                data->error = sh_mmcif_error_manage(host);
+                return false;
+        }
+
+        for (i = 0; i < host->blocksize / 4; i++)
                 sh_mmcif_writel(host->addr, MMCIF_CE_DATA, *p++);
 
         /* buffer write end */
         sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MDTRANE);
+        host->wait_for = MMCIF_WAIT_FOR_WRITE_END;
 
-        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
-                        host->timeout);
-        if (time <= 0 || host->sd_error)
-                return sh_mmcif_error_manage(host);
-
-        return 0;
+        return true;
 }
 
-static int sh_mmcif_multi_write(struct sh_mmcif_host *host,
-                                                struct mmc_request *mrq)
+static void sh_mmcif_multi_write(struct sh_mmcif_host *host,
+                                struct mmc_request *mrq)
 {
         struct mmc_data *data = mrq->data;
-        long time;
-        u32 i, sec, j, blocksize, *p;
 
-        blocksize = BLOCK_SIZE_MASK & sh_mmcif_readl(host->addr,
-                                                     MMCIF_CE_BLOCK_SET);
+        if (!data->sg_len || !data->sg->length)
+                return;
 
-        for (j = 0; j < data->sg_len; j++) {
-                p = sg_virt(data->sg);
-                for (sec = 0; sec < data->sg->length / blocksize; sec++) {
-                        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
-                        /* buf write enable*/
-                        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
-                                host->timeout);
+        host->blocksize = sh_mmcif_readl(host->addr, MMCIF_CE_BLOCK_SET) &
+                BLOCK_SIZE_MASK;
 
-                        if (time <= 0 || host->sd_error)
-                                return sh_mmcif_error_manage(host);
+        host->wait_for = MMCIF_WAIT_FOR_MWRITE;
+        host->sg_idx = 0;
+        host->sg_blkidx = 0;
+        host->pio_ptr = sg_virt(data->sg);
+        schedule_delayed_work(&host->timeout_work, host->timeout);
+        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
+}
 
-                        for (i = 0; i < blocksize / 4; i++)
-                                sh_mmcif_writel(host->addr,
-                                                MMCIF_CE_DATA, *p++);
-                }
-                if (j < data->sg_len - 1)
-                        data->sg++;
+static bool sh_mmcif_mwrite_block(struct sh_mmcif_host *host)
+{
+        struct mmc_data *data = host->mrq->data;
+        u32 *p = host->pio_ptr;
+        int i;
+
+        if (host->sd_error) {
+                data->error = sh_mmcif_error_manage(host);
+                return false;
         }
-        return 0;
+
+        BUG_ON(!data->sg->length);
+
+        for (i = 0; i < host->blocksize / 4; i++)
+                sh_mmcif_writel(host->addr, MMCIF_CE_DATA, *p++);
+
+        if (!sh_mmcif_next_block(host, p))
+                return false;
+
+        schedule_delayed_work(&host->timeout_work, host->timeout);
+        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
+
+        return true;
 }
 
 static void sh_mmcif_get_response(struct sh_mmcif_host *host,
@@ -603,8 +714,11 @@ static void sh_mmcif_get_cmd12response(struct sh_mmcif_host *host,
 }
 
 static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
-                struct mmc_request *mrq, struct mmc_command *cmd, u32 opc)
+                            struct mmc_request *mrq)
 {
+        struct mmc_data *data = mrq->data;
+        struct mmc_command *cmd = mrq->cmd;
+        u32 opc = cmd->opcode;
         u32 tmp = 0;
 
         /* Response Type check */
@@ -636,7 +750,7 @@ static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
                 break;
         }
         /* WDAT / DATW */
-        if (host->data) {
+        if (data) {
                 tmp |= CMD_SET_WDAT;
                 switch (host->bus_width) {
                 case MMC_BUS_WIDTH_1:
@@ -660,7 +774,7 @@ static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
         if (opc == MMC_READ_MULTIPLE_BLOCK || opc == MMC_WRITE_MULTIPLE_BLOCK) {
                 tmp |= CMD_SET_CMLTE | CMD_SET_CMD12EN;
                 sh_mmcif_bitset(host, MMCIF_CE_BLOCK_SET,
-                                        mrq->data->blocks << 16);
+                                data->blocks << 16);
         }
         /* RIDXC[1:0] check bits */
         if (opc == MMC_SEND_OP_COND || opc == MMC_ALL_SEND_CID ||
@@ -674,68 +788,60 @@ static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
                 opc == MMC_SEND_CSD || opc == MMC_SEND_CID)
                 tmp |= CMD_SET_CRC7C_INTERNAL;
 
-        return opc = ((opc << 24) | tmp);
+        return (opc << 24) | tmp;
 }
 
 static int sh_mmcif_data_trans(struct sh_mmcif_host *host,
-                                struct mmc_request *mrq, u32 opc)
+                               struct mmc_request *mrq, u32 opc)
 {
-        int ret;
-
         switch (opc) {
         case MMC_READ_MULTIPLE_BLOCK:
-                ret = sh_mmcif_multi_read(host, mrq);
-                break;
+                sh_mmcif_multi_read(host, mrq);
+                return 0;
         case MMC_WRITE_MULTIPLE_BLOCK:
-                ret = sh_mmcif_multi_write(host, mrq);
-                break;
+                sh_mmcif_multi_write(host, mrq);
+                return 0;
         case MMC_WRITE_BLOCK:
-                ret = sh_mmcif_single_write(host, mrq);
-                break;
+                sh_mmcif_single_write(host, mrq);
+                return 0;
         case MMC_READ_SINGLE_BLOCK:
         case MMC_SEND_EXT_CSD:
-                ret = sh_mmcif_single_read(host, mrq);
-                break;
+                sh_mmcif_single_read(host, mrq);
+                return 0;
         default:
                 dev_err(&host->pd->dev, "UNSUPPORTED CMD = d'%08d\n", opc);
-                ret = -EINVAL;
-                break;
+                return -EINVAL;
         }
-        return ret;
 }
 
 static void sh_mmcif_start_cmd(struct sh_mmcif_host *host,
-                        struct mmc_request *mrq, struct mmc_command *cmd)
+                               struct mmc_request *mrq)
 {
-        long time;
-        int ret = 0, mask = 0;
+        struct mmc_command *cmd = mrq->cmd;
         u32 opc = cmd->opcode;
+        u32 mask;
 
         switch (opc) {
-        /* respons busy check */
+        /* response busy check */
         case MMC_SWITCH:
         case MMC_STOP_TRANSMISSION:
         case MMC_SET_WRITE_PROT:
         case MMC_CLR_WRITE_PROT:
         case MMC_ERASE:
         case MMC_GEN_CMD:
-                mask = MASK_MRBSYE;
+                mask = MASK_START_CMD | MASK_MRBSYE;
                 break;
         default:
-                mask = MASK_MCRSPE;
+                mask = MASK_START_CMD | MASK_MCRSPE;
                 break;
         }
-        mask |= MASK_MCMDVIO | MASK_MBUFVIO | MASK_MWDATERR |
-                MASK_MRDATERR | MASK_MRIDXERR | MASK_MRSPERR |
-                MASK_MCCSTO | MASK_MCRCSTO | MASK_MWDATTO |
-                MASK_MRDATTO | MASK_MRBSYTO | MASK_MRSPTO;
 
-        if (host->data) {
+        if (mrq->data) {
                 sh_mmcif_writel(host->addr, MMCIF_CE_BLOCK_SET, 0);
                 sh_mmcif_writel(host->addr, MMCIF_CE_BLOCK_SET,
                                 mrq->data->blksz);
         }
-        opc = sh_mmcif_set_cmd(host, mrq, cmd, opc);
+        opc = sh_mmcif_set_cmd(host, mrq);
 
         sh_mmcif_writel(host->addr, MMCIF_CE_INT, 0xD80430C0);
         sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, mask);
@@ -744,80 +850,28 @@ static void sh_mmcif_start_cmd(struct sh_mmcif_host *host,
         /* set cmd */
         sh_mmcif_writel(host->addr, MMCIF_CE_CMD_SET, opc);
 
-        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
-                host->timeout);
-        if (time <= 0) {
-                cmd->error = sh_mmcif_error_manage(host);
-                return;
-        }
-        if (host->sd_error) {
-                switch (cmd->opcode) {
-                case MMC_ALL_SEND_CID:
-                case MMC_SELECT_CARD:
-                case MMC_APP_CMD:
-                        cmd->error = -ETIMEDOUT;
-                        break;
-                default:
-                        dev_dbg(&host->pd->dev, "Cmd(d'%d) err\n",
-                                        cmd->opcode);
-                        cmd->error = sh_mmcif_error_manage(host);
-                        break;
-                }
-                host->sd_error = false;
-                return;
-        }
-        if (!(cmd->flags & MMC_RSP_PRESENT)) {
-                cmd->error = 0;
-                return;
-        }
-        sh_mmcif_get_response(host, cmd);
-        if (host->data) {
-                if (!host->dma_active) {
-                        ret = sh_mmcif_data_trans(host, mrq, cmd->opcode);
-                } else {
-                        long time =
-                                wait_for_completion_interruptible_timeout(&host->dma_complete,
-                                                                          host->timeout);
-                        if (!time)
-                                ret = -ETIMEDOUT;
-                        else if (time < 0)
-                                ret = time;
-                        sh_mmcif_bitclr(host, MMCIF_CE_BUF_ACC,
-                                        BUF_ACC_DMAREN | BUF_ACC_DMAWEN);
-                        host->dma_active = false;
-                }
-                if (ret < 0)
-                        mrq->data->bytes_xfered = 0;
-                else
-                        mrq->data->bytes_xfered =
-                                mrq->data->blocks * mrq->data->blksz;
-        }
-        cmd->error = ret;
+        host->wait_for = MMCIF_WAIT_FOR_CMD;
+        schedule_delayed_work(&host->timeout_work, host->timeout);
 }
 
 static void sh_mmcif_stop_cmd(struct sh_mmcif_host *host,
-                struct mmc_request *mrq, struct mmc_command *cmd)
+                              struct mmc_request *mrq)
 {
-        long time;
-
-        if (mrq->cmd->opcode == MMC_READ_MULTIPLE_BLOCK)
+        switch (mrq->cmd->opcode) {
+        case MMC_READ_MULTIPLE_BLOCK:
                 sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MCMD12DRE);
-        else if (mrq->cmd->opcode == MMC_WRITE_MULTIPLE_BLOCK)
+                break;
+        case MMC_WRITE_MULTIPLE_BLOCK:
                 sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MCMD12RBE);
-        else {
+                break;
+        default:
                 dev_err(&host->pd->dev, "unsupported stop cmd\n");
-                cmd->error = sh_mmcif_error_manage(host);
+                mrq->stop->error = sh_mmcif_error_manage(host);
                 return;
         }
 
-        time = wait_for_completion_interruptible_timeout(&host->intr_wait,
-                        host->timeout);
-        if (time <= 0 || host->sd_error) {
-                cmd->error = sh_mmcif_error_manage(host);
-                return;
-        }
-        sh_mmcif_get_cmd12response(host, cmd);
-        cmd->error = 0;
+        host->wait_for = MMCIF_WAIT_FOR_STOP;
+        schedule_delayed_work(&host->timeout_work, host->timeout);
 }
 
 static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
@@ -856,23 +910,10 @@ static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
         default:
                 break;
         }
-        host->data = mrq->data;
-        if (mrq->data) {
-                if (mrq->data->flags & MMC_DATA_READ) {
-                        if (host->chan_rx)
-                                sh_mmcif_start_dma_rx(host);
-                } else {
-                        if (host->chan_tx)
-                                sh_mmcif_start_dma_tx(host);
-                }
-        }
-        sh_mmcif_start_cmd(host, mrq, mrq->cmd);
-        host->data = NULL;
 
-        if (!mrq->cmd->error && mrq->stop)
-                sh_mmcif_stop_cmd(host, mrq, mrq->stop);
-        host->state = STATE_IDLE;
-        mmc_request_done(mmc, mrq);
+        host->mrq = mrq;
+
+        sh_mmcif_start_cmd(host, mrq);
 }
 
 static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
@@ -947,9 +988,156 @@ static struct mmc_host_ops sh_mmcif_ops = {
         .get_cd         = sh_mmcif_get_cd,
 };
 
-static void sh_mmcif_detect(struct mmc_host *mmc)
+static bool sh_mmcif_end_cmd(struct sh_mmcif_host *host)
 {
-        mmc_detect_change(mmc, 0);
+        struct mmc_command *cmd = host->mrq->cmd;
+        struct mmc_data *data = host->mrq->data;
+        long time;
+
+        if (host->sd_error) {
+                switch (cmd->opcode) {
+                case MMC_ALL_SEND_CID:
+                case MMC_SELECT_CARD:
+                case MMC_APP_CMD:
+                        cmd->error = -ETIMEDOUT;
+                        host->sd_error = false;
+                        break;
+                default:
+                        cmd->error = sh_mmcif_error_manage(host);
+                        dev_dbg(&host->pd->dev, "Cmd(d'%d) error %d\n",
+                                cmd->opcode, cmd->error);
+                        break;
+                }
+                return false;
+        }
+        if (!(cmd->flags & MMC_RSP_PRESENT)) {
+                cmd->error = 0;
+                return false;
+        }
+
+        sh_mmcif_get_response(host, cmd);
+
+        if (!data)
+                return false;
+
+        if (data->flags & MMC_DATA_READ) {
+                if (host->chan_rx)
+                        sh_mmcif_start_dma_rx(host);
+        } else {
+                if (host->chan_tx)
+                        sh_mmcif_start_dma_tx(host);
+        }
+
+        if (!host->dma_active) {
+                data->error = sh_mmcif_data_trans(host, host->mrq, cmd->opcode);
+                if (!data->error)
+                        return true;
+                return false;
+        }
+
+        /* Running in the IRQ thread, can sleep */
+        time = wait_for_completion_interruptible_timeout(&host->dma_complete,
+                                                         host->timeout);
+        if (host->sd_error) {
+                dev_err(host->mmc->parent,
+                        "Error IRQ while waiting for DMA completion!\n");
+                /* Woken up by an error IRQ: abort DMA */
+                if (data->flags & MMC_DATA_READ)
+                        dmaengine_terminate_all(host->chan_rx);
+                else
+                        dmaengine_terminate_all(host->chan_tx);
+                data->error = sh_mmcif_error_manage(host);
+        } else if (!time) {
+                data->error = -ETIMEDOUT;
+        } else if (time < 0) {
+                data->error = time;
+        }
+        sh_mmcif_bitclr(host, MMCIF_CE_BUF_ACC,
+                        BUF_ACC_DMAREN | BUF_ACC_DMAWEN);
+        host->dma_active = false;
+
+        if (data->error)
+                data->bytes_xfered = 0;
+
+        return false;
+}
+
+static irqreturn_t sh_mmcif_irqt(int irq, void *dev_id)
+{
+        struct sh_mmcif_host *host = dev_id;
+        struct mmc_request *mrq = host->mrq;
+        struct mmc_data *data = mrq->data;
+
+        cancel_delayed_work_sync(&host->timeout_work);
+
+        /*
+         * All handlers return true, if processing continues, and false, if the
+         * request has to be completed - successfully or not
+         */
+        switch (host->wait_for) {
+        case MMCIF_WAIT_FOR_REQUEST:
+                /* We're too late, the timeout has already kicked in */
+                return IRQ_HANDLED;
+        case MMCIF_WAIT_FOR_CMD:
+                if (sh_mmcif_end_cmd(host))
+                        /* Wait for data */
+                        return IRQ_HANDLED;
+                break;
+        case MMCIF_WAIT_FOR_MREAD:
+                if (sh_mmcif_mread_block(host))
+                        /* Wait for more data */
+                        return IRQ_HANDLED;
+                break;
+        case MMCIF_WAIT_FOR_READ:
+                if (sh_mmcif_read_block(host))
+                        /* Wait for data end */
+                        return IRQ_HANDLED;
+                break;
+        case MMCIF_WAIT_FOR_MWRITE:
+                if (sh_mmcif_mwrite_block(host))
+                        /* Wait data to write */
+                        return IRQ_HANDLED;
+                break;
+        case MMCIF_WAIT_FOR_WRITE:
+                if (sh_mmcif_write_block(host))
+                        /* Wait for data end */
+                        return IRQ_HANDLED;
+                break;
+        case MMCIF_WAIT_FOR_STOP:
+                if (host->sd_error) {
+                        mrq->stop->error = sh_mmcif_error_manage(host);
+                        break;
+                }
+                sh_mmcif_get_cmd12response(host, mrq->stop);
+                mrq->stop->error = 0;
+                break;
+        case MMCIF_WAIT_FOR_READ_END:
+        case MMCIF_WAIT_FOR_WRITE_END:
+                if (host->sd_error)
+                        data->error = sh_mmcif_error_manage(host);
+                break;
+        default:
+                BUG();
+        }
+
+        if (host->wait_for != MMCIF_WAIT_FOR_STOP) {
+                if (!mrq->cmd->error && data && !data->error)
+                        data->bytes_xfered =
+                                data->blocks * data->blksz;
+
+                if (mrq->stop && !mrq->cmd->error && (!data || !data->error)) {
+                        sh_mmcif_stop_cmd(host, mrq);
+                        if (!mrq->stop->error)
+                                return IRQ_HANDLED;
+                }
+        }
+
+        host->wait_for = MMCIF_WAIT_FOR_REQUEST;
+        host->state = STATE_IDLE;
+        host->mrq = NULL;
+        mmc_request_done(host->mmc, mrq);
+
+        return IRQ_HANDLED;
 }
 
 static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
@@ -960,7 +1148,12 @@ static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
 
         state = sh_mmcif_readl(host->addr, MMCIF_CE_INT);
 
-        if (state & INT_RBSYE) {
+        if (state & INT_ERR_STS) {
+                /* error interrupts - process first */
+                sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~state);
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, state);
+                err = 1;
+        } else if (state & INT_RBSYE) {
                 sh_mmcif_writel(host->addr, MMCIF_CE_INT,
                                 ~(INT_RBSYE | INT_CRSPE));
                 sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MRBSYE);
@@ -988,11 +1181,6 @@ static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
                 sh_mmcif_writel(host->addr, MMCIF_CE_INT,
                                 ~(INT_CMD12RBE | INT_CMD12CRE));
                 sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MCMD12RBE);
-        } else if (state & INT_ERR_STS) {
-                /* err interrupts */
-                sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~state);
-                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, state);
-                err = 1;
         } else {
                 dev_dbg(&host->pd->dev, "Unsupported interrupt: 0x%x\n", state);
                 sh_mmcif_writel(host->addr, MMCIF_CE_INT, ~state);
@@ -1003,14 +1191,57 @@ static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
                 host->sd_error = true;
                 dev_dbg(&host->pd->dev, "int err state = %08x\n", state);
         }
-        if (state & ~(INT_CMD12RBE | INT_CMD12CRE))
-                complete(&host->intr_wait);
-        else
+        if (state & ~(INT_CMD12RBE | INT_CMD12CRE)) {
+                if (!host->dma_active)
+                        return IRQ_WAKE_THREAD;
+                else if (host->sd_error)
+                        mmcif_dma_complete(host);
+        } else {
                 dev_dbg(&host->pd->dev, "Unexpected IRQ 0x%x\n", state);
+        }
 
         return IRQ_HANDLED;
 }
 
+static void mmcif_timeout_work(struct work_struct *work)
+{
+        struct delayed_work *d = container_of(work, struct delayed_work, work);
+        struct sh_mmcif_host *host = container_of(d, struct sh_mmcif_host, timeout_work);
+        struct mmc_request *mrq = host->mrq;
+
+        if (host->dying)
+                /* Don't run after mmc_remove_host() */
+                return;
+
+        /*
+         * Handle races with cancel_delayed_work(), unless
+         * cancel_delayed_work_sync() is used
+         */
+        switch (host->wait_for) {
+        case MMCIF_WAIT_FOR_CMD:
+                mrq->cmd->error = sh_mmcif_error_manage(host);
+                break;
+        case MMCIF_WAIT_FOR_STOP:
+                mrq->stop->error = sh_mmcif_error_manage(host);
+                break;
+        case MMCIF_WAIT_FOR_MREAD:
+        case MMCIF_WAIT_FOR_MWRITE:
+        case MMCIF_WAIT_FOR_READ:
+        case MMCIF_WAIT_FOR_WRITE:
+        case MMCIF_WAIT_FOR_READ_END:
+        case MMCIF_WAIT_FOR_WRITE_END:
+                mrq->data->error = sh_mmcif_error_manage(host);
+                break;
+        default:
+                BUG();
+        }
+
+        host->state = STATE_IDLE;
+        host->wait_for = MMCIF_WAIT_FOR_REQUEST;
+        host->mrq = NULL;
+        mmc_request_done(host->mmc, mrq);
+}
+
 static int __devinit sh_mmcif_probe(struct platform_device *pdev)
 {
         int ret = 0, irq[2];
@@ -1064,7 +1295,6 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         host->clk = clk_get_rate(host->hclk);
         host->pd = pdev;
 
-        init_completion(&host->intr_wait);
         spin_lock_init(&host->lock);
 
         mmc->ops = &sh_mmcif_ops;
@@ -1101,19 +1331,21 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
 
         sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
 
-        ret = request_irq(irq[0], sh_mmcif_intr, 0, "sh_mmc:error", host);
+        ret = request_threaded_irq(irq[0], sh_mmcif_intr, sh_mmcif_irqt, 0, "sh_mmc:error", host);
         if (ret) {
                 dev_err(&pdev->dev, "request_irq error (sh_mmc:error)\n");
                 goto clean_up3;
         }
-        ret = request_irq(irq[1], sh_mmcif_intr, 0, "sh_mmc:int", host);
+        ret = request_threaded_irq(irq[1], sh_mmcif_intr, sh_mmcif_irqt, 0, "sh_mmc:int", host);
         if (ret) {
                 free_irq(irq[0], host);
                 dev_err(&pdev->dev, "request_irq error (sh_mmc:int)\n");
                 goto clean_up3;
         }
 
-        sh_mmcif_detect(host->mmc);
+        INIT_DELAYED_WORK(&host->timeout_work, mmcif_timeout_work);
+
+        mmc_detect_change(host->mmc, 0);
 
         dev_info(&pdev->dev, "driver version %s\n", DRIVER_VERSION);
         dev_dbg(&pdev->dev, "chip ver H'%04x\n",
@@ -1139,11 +1371,19 @@ static int __devexit sh_mmcif_remove(struct platform_device *pdev)
         struct sh_mmcif_host *host = platform_get_drvdata(pdev);
         int irq[2];
 
+        host->dying = true;
         pm_runtime_get_sync(&pdev->dev);
 
         mmc_remove_host(host->mmc);
         sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
 
+        /*
+         * FIXME: cancel_delayed_work(_sync)() and free_irq() race with the
+         * mmc_remove_host() call above. But swapping order doesn't help either
+         * (a query on the linux-mmc mailing list didn't bring any replies).
+         */
+        cancel_delayed_work_sync(&host->timeout_work);
+
         if (host->addr)
                 iounmap(host->addr);
 
@@ -1206,19 +1446,7 @@ static struct platform_driver sh_mmcif_driver = {
         },
 };
 
-static int __init sh_mmcif_init(void)
-{
-        return platform_driver_register(&sh_mmcif_driver);
-}
-
-static void __exit sh_mmcif_exit(void)
-{
-        platform_driver_unregister(&sh_mmcif_driver);
-}
-
-module_init(sh_mmcif_init);
-module_exit(sh_mmcif_exit);
-
+module_platform_driver(sh_mmcif_driver);
 
 MODULE_DESCRIPTION("SuperH on-chip MMC/eMMC interface driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index 41ae6466bd83..58da3c44acc5 100644
--- a/drivers/mmc/host/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -282,18 +282,7 @@ static struct platform_driver sh_mobile_sdhi_driver = {
         .remove         = __devexit_p(sh_mobile_sdhi_remove),
 };
 
-static int __init sh_mobile_sdhi_init(void)
-{
-        return platform_driver_register(&sh_mobile_sdhi_driver);
-}
-
-static void __exit sh_mobile_sdhi_exit(void)
-{
-        platform_driver_unregister(&sh_mobile_sdhi_driver);
-}
-
-module_init(sh_mobile_sdhi_init);
-module_exit(sh_mobile_sdhi_exit);
+module_platform_driver(sh_mobile_sdhi_driver);
 
 MODULE_DESCRIPTION("SuperH Mobile SDHI driver");
 MODULE_AUTHOR("Magnus Damm");
diff --git a/drivers/mmc/host/tifm_sd.c b/drivers/mmc/host/tifm_sd.c
index 69d249f51d6a..43d962829f8e 100644
--- a/drivers/mmc/host/tifm_sd.c
+++ b/drivers/mmc/host/tifm_sd.c
@@ -118,7 +118,7 @@ static void tifm_sd_read_fifo(struct tifm_sd *host, struct page *pg,
         unsigned char *buf;
         unsigned int pos = 0, val;
 
-        buf = kmap_atomic(pg, KM_BIO_DST_IRQ) + off;
+        buf = kmap_atomic(pg) + off;
         if (host->cmd_flags & DATA_CARRY) {
                 buf[pos++] = host->bounce_buf_data[0];
                 host->cmd_flags &= ~DATA_CARRY;
@@ -134,7 +134,7 @@ static void tifm_sd_read_fifo(struct tifm_sd *host, struct page *pg,
                 }
                 buf[pos++] = (val >> 8) & 0xff;
         }
-        kunmap_atomic(buf - off, KM_BIO_DST_IRQ);
+        kunmap_atomic(buf - off);
 }
 
 static void tifm_sd_write_fifo(struct tifm_sd *host, struct page *pg,
@@ -144,7 +144,7 @@ static void tifm_sd_write_fifo(struct tifm_sd *host, struct page *pg,
         unsigned char *buf;
         unsigned int pos = 0, val;
 
-        buf = kmap_atomic(pg, KM_BIO_SRC_IRQ) + off;
+        buf = kmap_atomic(pg) + off;
         if (host->cmd_flags & DATA_CARRY) {
                 val = host->bounce_buf_data[0] | ((buf[pos++] << 8) & 0xff00);
                 writel(val, sock->addr + SOCK_MMCSD_DATA);
@@ -161,7 +161,7 @@ static void tifm_sd_write_fifo(struct tifm_sd *host, struct page *pg,
                 val |= (buf[pos++] << 8) & 0xff00;
                 writel(val, sock->addr + SOCK_MMCSD_DATA);
         }
-        kunmap_atomic(buf - off, KM_BIO_SRC_IRQ);
+        kunmap_atomic(buf - off);
 }
 
 static void tifm_sd_transfer_data(struct tifm_sd *host)
@@ -212,13 +212,13 @@ static void tifm_sd_copy_page(struct page *dst, unsigned int dst_off,
                               struct page *src, unsigned int src_off,
                               unsigned int count)
 {
-        unsigned char *src_buf = kmap_atomic(src, KM_BIO_SRC_IRQ) + src_off;
-        unsigned char *dst_buf = kmap_atomic(dst, KM_BIO_DST_IRQ) + dst_off;
+        unsigned char *src_buf = kmap_atomic(src) + src_off;
+        unsigned char *dst_buf = kmap_atomic(dst) + dst_off;
 
         memcpy(dst_buf, src_buf, count);
 
-        kunmap_atomic(dst_buf - dst_off, KM_BIO_DST_IRQ);
-        kunmap_atomic(src_buf - src_off, KM_BIO_SRC_IRQ);
+        kunmap_atomic(dst_buf - dst_off);
+        kunmap_atomic(src_buf - src_off);
 }
 
 static void tifm_sd_bounce_block(struct tifm_sd *host, struct mmc_data *r_data)
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index a4ea10242787..113ce6c9cf32 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -138,19 +138,7 @@ static struct platform_driver tmio_mmc_driver = {
         .resume = tmio_mmc_resume,
 };
 
-
-static int __init tmio_mmc_init(void)
-{
-        return platform_driver_register(&tmio_mmc_driver);
-}
-
-static void __exit tmio_mmc_exit(void)
-{
-        platform_driver_unregister(&tmio_mmc_driver);
-}
-
-module_init(tmio_mmc_init);
-module_exit(tmio_mmc_exit);
+module_platform_driver(tmio_mmc_driver);
 
 MODULE_DESCRIPTION("Toshiba TMIO SD/MMC driver");
 MODULE_AUTHOR("Ian Molton <spyro@f2s.com>");
diff --git a/drivers/mmc/host/tmio_mmc.h b/drivers/mmc/host/tmio_mmc.h
index 3020f98218f0..a95e6d901726 100644
--- a/drivers/mmc/host/tmio_mmc.h
+++ b/drivers/mmc/host/tmio_mmc.h
@@ -105,13 +105,13 @@ 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;
+        return kmap_atomic(sg_page(sg)) + 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);
+        kunmap_atomic(virt - sg->offset);
         local_irq_restore(*flags);
 }
 
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index 4208b3958069..abad01b37cfb 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -800,8 +800,7 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         } else if (ios->power_mode != MMC_POWER_UP) {
                 if (host->set_pwr && ios->power_mode == MMC_POWER_OFF)
                         host->set_pwr(host->pdev, 0);
-                if ((pdata->flags & TMIO_MMC_HAS_COLD_CD) &&
-                    pdata->power) {
+                if (pdata->power) {
                         pdata->power = false;
                         pm_runtime_put(&host->pdev->dev);
                 }
@@ -915,6 +914,23 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
         if (ret < 0)
                 goto pm_disable;
 
+        /*
+         * There are 4 different scenarios for the card detection:
+         *  1) an external gpio irq handles the cd (best for power savings)
+         *  2) internal sdhi irq handles the cd
+         *  3) a worker thread polls the sdhi - indicated by MMC_CAP_NEEDS_POLL
+         *  4) the medium is non-removable - indicated by MMC_CAP_NONREMOVABLE
+         *
+         *  While we increment the rtpm counter for all scenarios when the mmc
+         *  core activates us by calling an appropriate set_ios(), we must
+         *  additionally ensure that in case 2) the tmio mmc hardware stays
+         *  powered on during runtime for the card detection to work.
+         */
+        if (!(pdata->flags & TMIO_MMC_HAS_COLD_CD
+                || mmc->caps & MMC_CAP_NEEDS_POLL
+                || mmc->caps & MMC_CAP_NONREMOVABLE))
+                pm_runtime_get_noresume(&pdev->dev);
+
         tmio_mmc_clk_stop(_host);
         tmio_mmc_reset(_host);
 
@@ -933,12 +949,6 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
         /* See if we also get DMA */
         tmio_mmc_request_dma(_host, pdata);
 
-        /* We have to keep the device powered for its card detection to work */
-        if (!(pdata->flags & TMIO_MMC_HAS_COLD_CD)) {
-                pdata->power = true;
-                pm_runtime_get_noresume(&pdev->dev);
-        }
-
         mmc_add_host(mmc);
 
         /* Unmask the IRQs we want to know about */
@@ -974,7 +984,9 @@ void tmio_mmc_host_remove(struct tmio_mmc_host *host)
          * the controller, the runtime PM is suspended and pdata->power == false,
          * so, our .runtime_resume() will not try to detect a card in the slot.
          */
-        if (host->pdata->flags & TMIO_MMC_HAS_COLD_CD)
+        if (host->pdata->flags & TMIO_MMC_HAS_COLD_CD
+                || host->mmc->caps & MMC_CAP_NEEDS_POLL
+                || host->mmc->caps & MMC_CAP_NONREMOVABLE)
                 pm_runtime_get_sync(&pdev->dev);
 
         mmc_remove_host(host->mmc);
diff --git a/drivers/mtd/mtdoops.c b/drivers/mtd/mtdoops.c
index db8e8272d69b..3ce99e00a49e 100644
--- a/drivers/mtd/mtdoops.c
+++ b/drivers/mtd/mtdoops.c
@@ -315,8 +315,7 @@ static void mtdoops_do_dump(struct kmsg_dumper *dumper,
         char *dst;
 
         if (reason != KMSG_DUMP_OOPS &&
-            reason != KMSG_DUMP_PANIC &&
-            reason != KMSG_DUMP_KEXEC)
+            reason != KMSG_DUMP_PANIC)
                 return;
 
         /* Only dump oopses if dump_oops is set */
diff --git a/drivers/mtd/ubi/debug.h b/drivers/mtd/ubi/debug.h
index 64fbb0021825..ead2cd16ba75 100644
--- a/drivers/mtd/ubi/debug.h
+++ b/drivers/mtd/ubi/debug.h
@@ -43,7 +43,10 @@
         pr_debug("UBI DBG " type ": " fmt "\n", ##__VA_ARGS__)
 
 /* Just a debugging messages not related to any specific UBI subsystem */
-#define dbg_msg(fmt, ...) ubi_dbg_msg("msg", fmt, ##__VA_ARGS__)
+#define dbg_msg(fmt, ...)                                    \
+        printk(KERN_DEBUG "UBI DBG (pid %d): %s: " fmt "\n", \
+               current->pid, __func__, ##__VA_ARGS__)
+
 /* General debugging messages */
 #define dbg_gen(fmt, ...) ubi_dbg_msg("gen", fmt, ##__VA_ARGS__)
 /* Messages from the eraseblock association sub-system */
diff --git a/drivers/mtd/ubi/vtbl.c b/drivers/mtd/ubi/vtbl.c
index 9ad18da1891d..890754c9f327 100644
--- a/drivers/mtd/ubi/vtbl.c
+++ b/drivers/mtd/ubi/vtbl.c
@@ -306,7 +306,7 @@ static int create_vtbl(struct ubi_device *ubi, struct ubi_scan_info *si,
                        int copy, void *vtbl)
 {
         int err, tries = 0;
-        static struct ubi_vid_hdr *vid_hdr;
+        struct ubi_vid_hdr *vid_hdr;
         struct ubi_scan_leb *new_seb;
 
         ubi_msg("create volume table (copy #%d)", copy + 1);
diff --git a/drivers/net/bonding/bond_alb.c b/drivers/net/bonding/bond_alb.c
index 106b88a04738..342626f4bc46 100644
--- a/drivers/net/bonding/bond_alb.c
+++ b/drivers/net/bonding/bond_alb.c
@@ -99,16 +99,26 @@ static inline u8 _simple_hash(const u8 *hash_start, int hash_size)
 
 /*********************** tlb specific functions ***************************/
 
-static inline void _lock_tx_hashtbl(struct bonding *bond)
+static inline void _lock_tx_hashtbl_bh(struct bonding *bond)
 {
         spin_lock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
 }
 
-static inline void _unlock_tx_hashtbl(struct bonding *bond)
+static inline void _unlock_tx_hashtbl_bh(struct bonding *bond)
 {
         spin_unlock_bh(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
 }
 
+static inline void _lock_tx_hashtbl(struct bonding *bond)
+{
+        spin_lock(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
+}
+
+static inline void _unlock_tx_hashtbl(struct bonding *bond)
+{
+        spin_unlock(&(BOND_ALB_INFO(bond).tx_hashtbl_lock));
+}
+
 /* Caller must hold tx_hashtbl lock */
 static inline void tlb_init_table_entry(struct tlb_client_info *entry, int save_load)
 {
@@ -129,14 +139,13 @@ static inline void tlb_init_slave(struct slave *slave)
         SLAVE_TLB_INFO(slave).head = TLB_NULL_INDEX;
 }
 
-/* Caller must hold bond lock for read */
-static void tlb_clear_slave(struct bonding *bond, struct slave *slave, int save_load)
+/* Caller must hold bond lock for read, BH disabled */
+static void __tlb_clear_slave(struct bonding *bond, struct slave *slave,
+                         int save_load)
 {
         struct tlb_client_info *tx_hash_table;
         u32 index;
 
-        _lock_tx_hashtbl(bond);
-
         /* clear slave from tx_hashtbl */
         tx_hash_table = BOND_ALB_INFO(bond).tx_hashtbl;
 
@@ -151,8 +160,15 @@ static void tlb_clear_slave(struct bonding *bond, struct slave *slave, int save_
         }
 
         tlb_init_slave(slave);
+}
 
-        _unlock_tx_hashtbl(bond);
+/* Caller must hold bond lock for read */
+static void tlb_clear_slave(struct bonding *bond, struct slave *slave,
+                         int save_load)
+{
+        _lock_tx_hashtbl_bh(bond);
+        __tlb_clear_slave(bond, slave, save_load);
+        _unlock_tx_hashtbl_bh(bond);
 }
 
 /* Must be called before starting the monitor timer */
@@ -169,7 +185,7 @@ static int tlb_initialize(struct bonding *bond)
                        bond->dev->name);
                 return -1;
         }
-        _lock_tx_hashtbl(bond);
+        _lock_tx_hashtbl_bh(bond);
 
         bond_info->tx_hashtbl = new_hashtbl;
 
@@ -177,7 +193,7 @@ static int tlb_initialize(struct bonding *bond)
                 tlb_init_table_entry(&bond_info->tx_hashtbl[i], 0);
         }
 
-        _unlock_tx_hashtbl(bond);
+        _unlock_tx_hashtbl_bh(bond);
 
         return 0;
 }
@@ -187,12 +203,12 @@ static void tlb_deinitialize(struct bonding *bond)
 {
         struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
 
-        _lock_tx_hashtbl(bond);
+        _lock_tx_hashtbl_bh(bond);
 
         kfree(bond_info->tx_hashtbl);
         bond_info->tx_hashtbl = NULL;
 
-        _unlock_tx_hashtbl(bond);
+        _unlock_tx_hashtbl_bh(bond);
 }
 
 static long long compute_gap(struct slave *slave)
@@ -226,15 +242,13 @@ static struct slave *tlb_get_least_loaded_slave(struct bonding *bond)
         return least_loaded;
 }
 
-/* Caller must hold bond lock for read */
-static struct slave *tlb_choose_channel(struct bonding *bond, u32 hash_index, u32 skb_len)
+static struct slave *__tlb_choose_channel(struct bonding *bond, u32 hash_index,
+                                                u32 skb_len)
 {
         struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
         struct tlb_client_info *hash_table;
         struct slave *assigned_slave;
 
-        _lock_tx_hashtbl(bond);
-
         hash_table = bond_info->tx_hashtbl;
         assigned_slave = hash_table[hash_index].tx_slave;
         if (!assigned_slave) {
@@ -263,22 +277,46 @@ static struct slave *tlb_choose_channel(struct bonding *bond, u32 hash_index, u3
                 hash_table[hash_index].tx_bytes += skb_len;
         }
 
-        _unlock_tx_hashtbl(bond);
-
         return assigned_slave;
 }
 
+/* Caller must hold bond lock for read */
+static struct slave *tlb_choose_channel(struct bonding *bond, u32 hash_index,
+                                        u32 skb_len)
+{
+        struct slave *tx_slave;
+        /*
+         * We don't need to disable softirq here, becase
+         * tlb_choose_channel() is only called by bond_alb_xmit()
+         * which already has softirq disabled.
+         */
+        _lock_tx_hashtbl(bond);
+        tx_slave = __tlb_choose_channel(bond, hash_index, skb_len);
+        _unlock_tx_hashtbl(bond);
+        return tx_slave;
+}
+
 /*********************** rlb specific functions ***************************/
-static inline void _lock_rx_hashtbl(struct bonding *bond)
+static inline void _lock_rx_hashtbl_bh(struct bonding *bond)
 {
         spin_lock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
 }
 
-static inline void _unlock_rx_hashtbl(struct bonding *bond)
+static inline void _unlock_rx_hashtbl_bh(struct bonding *bond)
 {
         spin_unlock_bh(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
 }
 
+static inline void _lock_rx_hashtbl(struct bonding *bond)
+{
+        spin_lock(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
+}
+
+static inline void _unlock_rx_hashtbl(struct bonding *bond)
+{
+        spin_unlock(&(BOND_ALB_INFO(bond).rx_hashtbl_lock));
+}
+
 /* when an ARP REPLY is received from a client update its info
  * in the rx_hashtbl
  */
@@ -288,7 +326,7 @@ static void rlb_update_entry_from_arp(struct bonding *bond, struct arp_pkt *arp)
         struct rlb_client_info *client_info;
         u32 hash_index;
 
-        _lock_rx_hashtbl(bond);
+        _lock_rx_hashtbl_bh(bond);
 
         hash_index = _simple_hash((u8*)&(arp->ip_src), sizeof(arp->ip_src));
         client_info = &(bond_info->rx_hashtbl[hash_index]);
@@ -303,7 +341,7 @@ static void rlb_update_entry_from_arp(struct bonding *bond, struct arp_pkt *arp)
                 bond_info->rx_ntt = 1;
         }
 
-        _unlock_rx_hashtbl(bond);
+        _unlock_rx_hashtbl_bh(bond);
 }
 
 static void rlb_arp_recv(struct sk_buff *skb, struct bonding *bond,
@@ -401,7 +439,7 @@ static void rlb_clear_slave(struct bonding *bond, struct slave *slave)
         u32 index, next_index;
 
         /* clear slave from rx_hashtbl */
-        _lock_rx_hashtbl(bond);
+        _lock_rx_hashtbl_bh(bond);
 
         rx_hash_table = bond_info->rx_hashtbl;
         index = bond_info->rx_hashtbl_head;
@@ -432,7 +470,7 @@ static void rlb_clear_slave(struct bonding *bond, struct slave *slave)
                 }
         }
 
-        _unlock_rx_hashtbl(bond);
+        _unlock_rx_hashtbl_bh(bond);
 
         write_lock_bh(&bond->curr_slave_lock);
 
@@ -489,7 +527,7 @@ static void rlb_update_rx_clients(struct bonding *bond)
         struct rlb_client_info *client_info;
         u32 hash_index;
 
-        _lock_rx_hashtbl(bond);
+        _lock_rx_hashtbl_bh(bond);
 
         hash_index = bond_info->rx_hashtbl_head;
         for (; hash_index != RLB_NULL_INDEX; hash_index = client_info->next) {
@@ -507,7 +545,7 @@ static void rlb_update_rx_clients(struct bonding *bond)
          */
         bond_info->rlb_update_delay_counter = RLB_UPDATE_DELAY;
 
-        _unlock_rx_hashtbl(bond);
+        _unlock_rx_hashtbl_bh(bond);
 }
 
 /* The slave was assigned a new mac address - update the clients */
@@ -518,7 +556,7 @@ static void rlb_req_update_slave_clients(struct bonding *bond, struct slave *sla
         int ntt = 0;
         u32 hash_index;
 
-        _lock_rx_hashtbl(bond);
+        _lock_rx_hashtbl_bh(bond);
 
         hash_index = bond_info->rx_hashtbl_head;
         for (; hash_index != RLB_NULL_INDEX; hash_index = client_info->next) {
@@ -538,7 +576,7 @@ static void rlb_req_update_slave_clients(struct bonding *bond, struct slave *sla
                 bond_info->rlb_update_retry_counter = RLB_UPDATE_RETRY;
         }
 
-        _unlock_rx_hashtbl(bond);
+        _unlock_rx_hashtbl_bh(bond);
 }
 
 /* mark all clients using src_ip to be updated */
@@ -709,7 +747,7 @@ static void rlb_rebalance(struct bonding *bond)
         int ntt;
         u32 hash_index;
 
-        _lock_rx_hashtbl(bond);
+        _lock_rx_hashtbl_bh(bond);
 
         ntt = 0;
         hash_index = bond_info->rx_hashtbl_head;
@@ -727,7 +765,7 @@ static void rlb_rebalance(struct bonding *bond)
         if (ntt) {
                 bond_info->rx_ntt = 1;
         }
-        _unlock_rx_hashtbl(bond);
+        _unlock_rx_hashtbl_bh(bond);
 }
 
 /* Caller must hold rx_hashtbl lock */
@@ -751,7 +789,7 @@ static int rlb_initialize(struct bonding *bond)
                        bond->dev->name);
                 return -1;
         }
-        _lock_rx_hashtbl(bond);
+        _lock_rx_hashtbl_bh(bond);
 
         bond_info->rx_hashtbl = new_hashtbl;
 
@@ -761,7 +799,7 @@ static int rlb_initialize(struct bonding *bond)
                 rlb_init_table_entry(bond_info->rx_hashtbl + i);
         }
 
-        _unlock_rx_hashtbl(bond);
+        _unlock_rx_hashtbl_bh(bond);
 
         /* register to receive ARPs */
         bond->recv_probe = rlb_arp_recv;
@@ -773,13 +811,13 @@ static void rlb_deinitialize(struct bonding *bond)
 {
         struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
 
-        _lock_rx_hashtbl(bond);
+        _lock_rx_hashtbl_bh(bond);
 
         kfree(bond_info->rx_hashtbl);
         bond_info->rx_hashtbl = NULL;
         bond_info->rx_hashtbl_head = RLB_NULL_INDEX;
 
-        _unlock_rx_hashtbl(bond);
+        _unlock_rx_hashtbl_bh(bond);
 }
 
 static void rlb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
@@ -787,7 +825,7 @@ static void rlb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
         struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
         u32 curr_index;
 
-        _lock_rx_hashtbl(bond);
+        _lock_rx_hashtbl_bh(bond);
 
         curr_index = bond_info->rx_hashtbl_head;
         while (curr_index != RLB_NULL_INDEX) {
@@ -812,7 +850,7 @@ static void rlb_clear_vlan(struct bonding *bond, unsigned short vlan_id)
                 curr_index = next_index;
         }
 
-        _unlock_rx_hashtbl(bond);
+        _unlock_rx_hashtbl_bh(bond);
 }
 
 /*********************** tlb/rlb shared functions *********************/
@@ -1320,7 +1358,9 @@ int bond_alb_xmit(struct sk_buff *skb, struct net_device *bond_dev)
                 res = bond_dev_queue_xmit(bond, skb, tx_slave->dev);
         } else {
                 if (tx_slave) {
-                        tlb_clear_slave(bond, tx_slave, 0);
+                        _lock_tx_hashtbl(bond);
+                        __tlb_clear_slave(bond, tx_slave, 0);
+                        _unlock_tx_hashtbl(bond);
                 }
         }
 
diff --git a/drivers/net/ethernet/8390/ax88796.c b/drivers/net/ethernet/8390/ax88796.c
index 9e8ba4f5636b..0f92e3567f68 100644
--- a/drivers/net/ethernet/8390/ax88796.c
+++ b/drivers/net/ethernet/8390/ax88796.c
@@ -623,7 +623,8 @@ static int ax_mii_init(struct net_device *dev)
 
         ax->mii_bus->name = "ax88796_mii_bus";
         ax->mii_bus->parent = dev->dev.parent;
-        snprintf(ax->mii_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id);
+        snprintf(ax->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                pdev->name, pdev->id);
 
         ax->mii_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
         if (!ax->mii_bus->irq) {
diff --git a/drivers/net/ethernet/adi/bfin_mac.c b/drivers/net/ethernet/adi/bfin_mac.c
index b6d69c91db96..d812a103e032 100644
--- a/drivers/net/ethernet/adi/bfin_mac.c
+++ b/drivers/net/ethernet/adi/bfin_mac.c
@@ -1670,7 +1670,8 @@ static int __devinit bfin_mii_bus_probe(struct platform_device *pdev)
         miibus->name = "bfin_mii_bus";
         miibus->phy_mask = mii_bus_pd->phy_mask;
 
-        snprintf(miibus->id, MII_BUS_ID_SIZE, "0");
+        snprintf(miibus->id, MII_BUS_ID_SIZE, "%s-%x",
+                pdev->name, pdev->id);
         miibus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
         if (!miibus->irq)
                 goto out_err_irq_alloc;
diff --git a/drivers/net/ethernet/amd/au1000_eth.c b/drivers/net/ethernet/amd/au1000_eth.c
index cc9262be69c8..8b95dd314253 100644
--- a/drivers/net/ethernet/amd/au1000_eth.c
+++ b/drivers/net/ethernet/amd/au1000_eth.c
@@ -1171,7 +1171,8 @@ static int __devinit au1000_probe(struct platform_device *pdev)
         aup->mii_bus->write = au1000_mdiobus_write;
         aup->mii_bus->reset = au1000_mdiobus_reset;
         aup->mii_bus->name = "au1000_eth_mii";
-        snprintf(aup->mii_bus->id, MII_BUS_ID_SIZE, "%x", aup->mac_id);
+        snprintf(aup->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                pdev->name, aup->mac_id);
         aup->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
         if (aup->mii_bus->irq == NULL)
                 goto err_out;
diff --git a/drivers/net/ethernet/broadcom/bcm63xx_enet.c b/drivers/net/ethernet/broadcom/bcm63xx_enet.c
index d44331eb07fe..986019b2c849 100644
--- a/drivers/net/ethernet/broadcom/bcm63xx_enet.c
+++ b/drivers/net/ethernet/broadcom/bcm63xx_enet.c
@@ -1727,7 +1727,7 @@ static int __devinit bcm_enet_probe(struct platform_device *pdev)
                 bus->priv = priv;
                 bus->read = bcm_enet_mdio_read_phylib;
                 bus->write = bcm_enet_mdio_write_phylib;
-                sprintf(bus->id, "%d", priv->mac_id);
+                sprintf(bus->id, "%s-%d", pdev->name, priv->mac_id);
 
                 /* only probe bus where we think the PHY is, because
                  * the mdio read operation return 0 instead of 0xffff
diff --git a/drivers/net/ethernet/broadcom/sb1250-mac.c b/drivers/net/ethernet/broadcom/sb1250-mac.c
index 8fa7abc53ec6..084904ceaa30 100644
--- a/drivers/net/ethernet/broadcom/sb1250-mac.c
+++ b/drivers/net/ethernet/broadcom/sb1250-mac.c
@@ -2259,7 +2259,8 @@ static int sbmac_init(struct platform_device *pldev, long long base)
         }
 
         sc->mii_bus->name = sbmac_mdio_string;
-        snprintf(sc->mii_bus->id, MII_BUS_ID_SIZE, "%x", idx);
+        snprintf(sc->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                pldev->name, idx);
         sc->mii_bus->priv = sc;
         sc->mii_bus->read = sbmac_mii_read;
         sc->mii_bus->write = sbmac_mii_write;
diff --git a/drivers/net/ethernet/cadence/macb.c b/drivers/net/ethernet/cadence/macb.c
index f3d5c65d99cf..23200680d4c1 100644
--- a/drivers/net/ethernet/cadence/macb.c
+++ b/drivers/net/ethernet/cadence/macb.c
@@ -243,7 +243,8 @@ static int macb_mii_init(struct macb *bp)
         bp->mii_bus->read = &macb_mdio_read;
         bp->mii_bus->write = &macb_mdio_write;
         bp->mii_bus->reset = &macb_mdio_reset;
-        snprintf(bp->mii_bus->id, MII_BUS_ID_SIZE, "%x", bp->pdev->id);
+        snprintf(bp->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                bp->pdev->name, bp->pdev->id);
         bp->mii_bus->priv = bp;
         bp->mii_bus->parent = &bp->dev->dev;
         pdata = bp->pdev->dev.platform_data;
diff --git a/drivers/net/ethernet/dnet.c b/drivers/net/ethernet/dnet.c
index ce88c0f399f6..925c9bafc9b9 100644
--- a/drivers/net/ethernet/dnet.c
+++ b/drivers/net/ethernet/dnet.c
@@ -325,7 +325,8 @@ static int dnet_mii_init(struct dnet *bp)
         bp->mii_bus->write = &dnet_mdio_write;
         bp->mii_bus->reset = &dnet_mdio_reset;
 
-        snprintf(bp->mii_bus->id, MII_BUS_ID_SIZE, "%x", 0);
+        snprintf(bp->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                bp->pdev->name, bp->pdev->id);
 
         bp->mii_bus->priv = bp;
 
diff --git a/drivers/net/ethernet/freescale/fec.c b/drivers/net/ethernet/freescale/fec.c
index ddcbbb34d1b9..7b25e9cf13f6 100644
--- a/drivers/net/ethernet/freescale/fec.c
+++ b/drivers/net/ethernet/freescale/fec.c
@@ -476,6 +476,7 @@ fec_restart(struct net_device *ndev, int duplex)
         } else {
 #ifdef FEC_MIIGSK_ENR
                 if (id_entry->driver_data & FEC_QUIRK_USE_GASKET) {
+                        u32 cfgr;
                         /* disable the gasket and wait */
                         writel(0, fep->hwp + FEC_MIIGSK_ENR);
                         while (readl(fep->hwp + FEC_MIIGSK_ENR) & 4)
@@ -486,9 +487,11 @@ fec_restart(struct net_device *ndev, int duplex)
                          *   RMII, 50 MHz, no loopback, no echo
                          *   MII, 25 MHz, no loopback, no echo
                          */
-                        writel((fep->phy_interface == PHY_INTERFACE_MODE_RMII) ?
-                                        1 : 0, fep->hwp + FEC_MIIGSK_CFGR);
-
+                        cfgr = (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
+                                ? BM_MIIGSK_CFGR_RMII : BM_MIIGSK_CFGR_MII;
+                        if (fep->phy_dev && fep->phy_dev->speed == SPEED_10)
+                                cfgr |= BM_MIIGSK_CFGR_FRCONT_10M;
+                        writel(cfgr, fep->hwp + FEC_MIIGSK_CFGR);
 
                         /* re-enable the gasket */
                         writel(2, fep->hwp + FEC_MIIGSK_ENR);
@@ -1077,7 +1080,8 @@ static int fec_enet_mii_init(struct platform_device *pdev)
         fep->mii_bus->read = fec_enet_mdio_read;
         fep->mii_bus->write = fec_enet_mdio_write;
         fep->mii_bus->reset = fec_enet_mdio_reset;
-        snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%x", fep->dev_id + 1);
+        snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                pdev->name, fep->dev_id + 1);
         fep->mii_bus->priv = fep;
         fep->mii_bus->parent = &pdev->dev;
 
diff --git a/drivers/net/ethernet/freescale/fec.h b/drivers/net/ethernet/freescale/fec.h
index 8b2c6d797e6d..8408c627b195 100644
--- a/drivers/net/ethernet/freescale/fec.h
+++ b/drivers/net/ethernet/freescale/fec.h
@@ -47,6 +47,10 @@
 #define FEC_MIIGSK_CFGR         0x300 /* MIIGSK Configuration reg */
 #define FEC_MIIGSK_ENR          0x308 /* MIIGSK Enable reg */
 
+#define BM_MIIGSK_CFGR_MII              0x00
+#define BM_MIIGSK_CFGR_RMII             0x01
+#define BM_MIIGSK_CFGR_FRCONT_10M       0x40
+
 #else
 
 #define FEC_ECNTRL              0x000 /* Ethernet control reg */
diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
index e01cdaa722a9..39d160d353a4 100644
--- a/drivers/net/ethernet/freescale/gianfar.c
+++ b/drivers/net/ethernet/freescale/gianfar.c
@@ -1984,7 +1984,8 @@ static inline struct txfcb *gfar_add_fcb(struct sk_buff *skb)
         return fcb;
 }
 
-static inline void gfar_tx_checksum(struct sk_buff *skb, struct txfcb *fcb)
+static inline void gfar_tx_checksum(struct sk_buff *skb, struct txfcb *fcb,
+                int fcb_length)
 {
         u8 flags = 0;
 
@@ -2006,7 +2007,7 @@ static inline void gfar_tx_checksum(struct sk_buff *skb, struct txfcb *fcb)
          * frame (skb->data) and the start of the IP hdr.
          * l4os is the distance between the start of the
          * l3 hdr and the l4 hdr */
-        fcb->l3os = (u16)(skb_network_offset(skb) - GMAC_FCB_LEN);
+        fcb->l3os = (u16)(skb_network_offset(skb) - fcb_length);
         fcb->l4os = skb_network_header_len(skb);
 
         fcb->flags = flags;
@@ -2046,7 +2047,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
         int i, rq = 0, do_tstamp = 0;
         u32 bufaddr;
         unsigned long flags;
-        unsigned int nr_frags, nr_txbds, length;
+        unsigned int nr_frags, nr_txbds, length, fcb_length = GMAC_FCB_LEN;
 
         /*
          * TOE=1 frames larger than 2500 bytes may see excess delays
@@ -2070,22 +2071,28 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         /* check if time stamp should be generated */
         if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
-                     priv->hwts_tx_en))
+                        priv->hwts_tx_en)) {
                 do_tstamp = 1;
+                fcb_length = GMAC_FCB_LEN + GMAC_TXPAL_LEN;
+        }
 
         /* make space for additional header when fcb is needed */
         if (((skb->ip_summed == CHECKSUM_PARTIAL) ||
                         vlan_tx_tag_present(skb) ||
                         unlikely(do_tstamp)) &&
-                        (skb_headroom(skb) < GMAC_FCB_LEN)) {
+                        (skb_headroom(skb) < fcb_length)) {
                 struct sk_buff *skb_new;
 
-                skb_new = skb_realloc_headroom(skb, GMAC_FCB_LEN);
+                skb_new = skb_realloc_headroom(skb, fcb_length);
                 if (!skb_new) {
                         dev->stats.tx_errors++;
                         kfree_skb(skb);
                         return NETDEV_TX_OK;
                 }
+
+                /* Steal sock reference for processing TX time stamps */
+                swap(skb_new->sk, skb->sk);
+                swap(skb_new->destructor, skb->destructor);
                 kfree_skb(skb);
                 skb = skb_new;
         }
@@ -2154,6 +2161,12 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 lstatus = txbdp_start->lstatus;
         }
 
+        /* Add TxPAL between FCB and frame if required */
+        if (unlikely(do_tstamp)) {
+                skb_push(skb, GMAC_TXPAL_LEN);
+                memset(skb->data, 0, GMAC_TXPAL_LEN);
+        }
+
         /* Set up checksumming */
         if (CHECKSUM_PARTIAL == skb->ip_summed) {
                 fcb = gfar_add_fcb(skb);
@@ -2164,7 +2177,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
                         skb_checksum_help(skb);
                 } else {
                         lstatus |= BD_LFLAG(TXBD_TOE);
-                        gfar_tx_checksum(skb, fcb);
+                        gfar_tx_checksum(skb, fcb, fcb_length);
                 }
         }
 
@@ -2196,9 +2209,9 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
          * the full frame length.
          */
         if (unlikely(do_tstamp)) {
-                txbdp_tstamp->bufPtr = txbdp_start->bufPtr + GMAC_FCB_LEN;
+                txbdp_tstamp->bufPtr = txbdp_start->bufPtr + fcb_length;
                 txbdp_tstamp->lstatus |= BD_LFLAG(TXBD_READY) |
-                                (skb_headlen(skb) - GMAC_FCB_LEN);
+                                (skb_headlen(skb) - fcb_length);
                 lstatus |= BD_LFLAG(TXBD_CRC | TXBD_READY) | GMAC_FCB_LEN;
         } else {
                 lstatus |= BD_LFLAG(TXBD_CRC | TXBD_READY) | skb_headlen(skb);
@@ -2490,7 +2503,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
 
                 if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)) {
                         next = next_txbd(bdp, base, tx_ring_size);
-                        buflen = next->length + GMAC_FCB_LEN;
+                        buflen = next->length + GMAC_FCB_LEN + GMAC_TXPAL_LEN;
                 } else
                         buflen = bdp->length;
 
@@ -2502,6 +2515,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
                         u64 *ns = (u64*) (((u32)skb->data + 0x10) & ~0x7);
                         memset(&shhwtstamps, 0, sizeof(shhwtstamps));
                         shhwtstamps.hwtstamp = ns_to_ktime(*ns);
+                        skb_pull(skb, GMAC_FCB_LEN + GMAC_TXPAL_LEN);
                         skb_tstamp_tx(skb, &shhwtstamps);
                         bdp->lstatus &= BD_LFLAG(TXBD_WRAP);
                         bdp = next;
diff --git a/drivers/net/ethernet/freescale/gianfar.h b/drivers/net/ethernet/freescale/gianfar.h
index fe7ac3a83194..40c33a7554c0 100644
--- a/drivers/net/ethernet/freescale/gianfar.h
+++ b/drivers/net/ethernet/freescale/gianfar.h
@@ -63,6 +63,9 @@ struct ethtool_rx_list {
 /* Length for FCB */
 #define GMAC_FCB_LEN 8
 
+/* Length for TxPAL */
+#define GMAC_TXPAL_LEN 16
+
 /* Default padding amount */
 #define DEFAULT_PADDING 2
 
diff --git a/drivers/net/ethernet/lantiq_etop.c b/drivers/net/ethernet/lantiq_etop.c
index 0b3567ab8121..85e2c6cd9708 100644
--- a/drivers/net/ethernet/lantiq_etop.c
+++ b/drivers/net/ethernet/lantiq_etop.c
@@ -98,6 +98,7 @@ struct ltq_etop_chan {
 
 struct ltq_etop_priv {
         struct net_device *netdev;
+        struct platform_device *pdev;
         struct ltq_eth_data *pldata;
         struct resource *res;
 
@@ -436,7 +437,8 @@ ltq_etop_mdio_init(struct net_device *dev)
         priv->mii_bus->read = ltq_etop_mdio_rd;
         priv->mii_bus->write = ltq_etop_mdio_wr;
         priv->mii_bus->name = "ltq_mii";
-        snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "%x", 0);
+        snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                priv->pdev->name, priv->pdev->id);
         priv->mii_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
         if (!priv->mii_bus->irq) {
                 err = -ENOMEM;
@@ -734,6 +736,7 @@ ltq_etop_probe(struct platform_device *pdev)
         dev->ethtool_ops = &ltq_etop_ethtool_ops;
         priv = netdev_priv(dev);
         priv->res = res;
+        priv->pdev = pdev;
         priv->pldata = dev_get_platdata(&pdev->dev);
         priv->netdev = dev;
         spin_lock_init(&priv->lock);
diff --git a/drivers/net/ethernet/marvell/mv643xx_eth.c b/drivers/net/ethernet/marvell/mv643xx_eth.c
index 80aab4e5d695..9c049d2cb97d 100644
--- a/drivers/net/ethernet/marvell/mv643xx_eth.c
+++ b/drivers/net/ethernet/marvell/mv643xx_eth.c
@@ -2613,7 +2613,8 @@ static int mv643xx_eth_shared_probe(struct platform_device *pdev)
                 msp->smi_bus->name = "mv643xx_eth smi";
                 msp->smi_bus->read = smi_bus_read;
                 msp->smi_bus->write = smi_bus_write,
-                snprintf(msp->smi_bus->id, MII_BUS_ID_SIZE, "%d", pdev->id);
+                snprintf(msp->smi_bus->id, MII_BUS_ID_SIZE, "%s-%d",
+                        pdev->name, pdev->id);
                 msp->smi_bus->parent = &pdev->dev;
                 msp->smi_bus->phy_mask = 0xffffffff;
                 if (mdiobus_register(msp->smi_bus) < 0)
diff --git a/drivers/net/ethernet/marvell/pxa168_eth.c b/drivers/net/ethernet/marvell/pxa168_eth.c
index 5ec409e3da09..953ba5851f7b 100644
--- a/drivers/net/ethernet/marvell/pxa168_eth.c
+++ b/drivers/net/ethernet/marvell/pxa168_eth.c
@@ -1552,7 +1552,8 @@ static int pxa168_eth_probe(struct platform_device *pdev)
         pep->smi_bus->name = "pxa168_eth smi";
         pep->smi_bus->read = pxa168_smi_read;
         pep->smi_bus->write = pxa168_smi_write;
-        snprintf(pep->smi_bus->id, MII_BUS_ID_SIZE, "%d", pdev->id);
+        snprintf(pep->smi_bus->id, MII_BUS_ID_SIZE, "%s-%d",
+                pdev->name, pdev->id);
         pep->smi_bus->parent = &pdev->dev;
         pep->smi_bus->phy_mask = 0xffffffff;
         err = mdiobus_register(pep->smi_bus);
diff --git a/drivers/net/ethernet/micrel/ksz884x.c b/drivers/net/ethernet/micrel/ksz884x.c
index 6ed09a85f035..e52cd310ae76 100644
--- a/drivers/net/ethernet/micrel/ksz884x.c
+++ b/drivers/net/ethernet/micrel/ksz884x.c
@@ -746,7 +746,7 @@
 #define MAC_ADDR_ORDER(i)               (ETH_ALEN - 1 - (i))
 
 #define MAX_ETHERNET_BODY_SIZE          1500
-#define ETHERNET_HEADER_SIZE            14
+#define ETHERNET_HEADER_SIZE            (14 + VLAN_HLEN)
 
 #define MAX_ETHERNET_PACKET_SIZE        \
         (MAX_ETHERNET_BODY_SIZE + ETHERNET_HEADER_SIZE)
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
index fc9bda9bc36c..6ece4295d78f 100644
--- a/drivers/net/ethernet/renesas/sh_eth.c
+++ b/drivers/net/ethernet/renesas/sh_eth.c
@@ -1702,7 +1702,8 @@ static int sh_mdio_init(struct net_device *ndev, int id,
         /* Hook up MII support for ethtool */
         mdp->mii_bus->name = "sh_mii";
         mdp->mii_bus->parent = &ndev->dev;
-        snprintf(mdp->mii_bus->id, MII_BUS_ID_SIZE, "%x", id);
+        snprintf(mdp->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                mdp->pdev->name, pdid);
 
         /* PHY IRQ */
         mdp->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
diff --git a/drivers/net/ethernet/s6gmac.c b/drivers/net/ethernet/s6gmac.c
index a7ff8ea342b4..22e9c0181ce8 100644
--- a/drivers/net/ethernet/s6gmac.c
+++ b/drivers/net/ethernet/s6gmac.c
@@ -1004,7 +1004,7 @@ static int __devinit s6gmac_probe(struct platform_device *pdev)
         mb->write = s6mii_write;
         mb->reset = s6mii_reset;
         mb->priv = pd;
-        snprintf(mb->id, MII_BUS_ID_SIZE, "0");
+        snprintf(mb->id, MII_BUS_ID_SIZE, "%s-%x", pdev->name, pdev->id);
         mb->phy_mask = ~(1 << 0);
         mb->irq = &pd->mii.irq[0];
         for (i = 0; i < PHY_MAX_ADDR; i++) {
diff --git a/drivers/net/ethernet/smsc/smsc911x.c b/drivers/net/ethernet/smsc/smsc911x.c
index 9d0b8ced0234..24d2df068d71 100644
--- a/drivers/net/ethernet/smsc/smsc911x.c
+++ b/drivers/net/ethernet/smsc/smsc911x.c
@@ -1044,7 +1044,8 @@ static int __devinit smsc911x_mii_init(struct platform_device *pdev,
         }
 
         pdata->mii_bus->name = SMSC_MDIONAME;
-        snprintf(pdata->mii_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id);
+        snprintf(pdata->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                pdev->name, pdev->id);
         pdata->mii_bus->priv = pdata;
         pdata->mii_bus->read = smsc911x_mii_read;
         pdata->mii_bus->write = smsc911x_mii_write;
diff --git a/drivers/net/ethernet/stmicro/stmmac/mmc_core.c b/drivers/net/ethernet/stmicro/stmmac/mmc_core.c
index 41e6b33e1b08..c07cfe989f6e 100644
--- a/drivers/net/ethernet/stmicro/stmmac/mmc_core.c
+++ b/drivers/net/ethernet/stmicro/stmmac/mmc_core.c
@@ -22,6 +22,7 @@
   Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
 *******************************************************************************/
 
+#include <linux/kernel.h>
 #include <linux/io.h>
 #include "mmc.h"
 
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index 3738b4700548..96fa2da30763 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -307,7 +307,7 @@ static int stmmac_init_phy(struct net_device *dev)
         priv->speed = 0;
         priv->oldduplex = -1;
 
-        snprintf(bus_id, MII_BUS_ID_SIZE, "%x", priv->plat->bus_id);
+        snprintf(bus_id, MII_BUS_ID_SIZE, "stmmac-%x", priv->plat->bus_id);
         snprintf(phy_id, MII_BUS_ID_SIZE + 3, PHY_ID_FMT, bus_id,
                  priv->plat->phy_addr);
         pr_debug("stmmac_init_phy:  trying to attach to %s\n", phy_id);
@@ -772,7 +772,7 @@ static void stmmac_mmc_setup(struct stmmac_priv *priv)
                 dwmac_mmc_ctrl(priv->ioaddr, mode);
                 memset(&priv->mmc, 0, sizeof(struct stmmac_counters));
         } else
-                pr_info(" No MAC Management Counters available");
+                pr_info(" No MAC Management Counters available\n");
 }
 
 static u32 stmmac_get_synopsys_id(struct stmmac_priv *priv)
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c
index 51f441233962..da4a1042523a 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c
@@ -158,7 +158,8 @@ int stmmac_mdio_register(struct net_device *ndev)
         new_bus->read = &stmmac_mdio_read;
         new_bus->write = &stmmac_mdio_write;
         new_bus->reset = &stmmac_mdio_reset;
-        snprintf(new_bus->id, MII_BUS_ID_SIZE, "%x", mdio_bus_data->bus_id);
+        snprintf(new_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                new_bus->name, mdio_bus_data->bus_id);
         new_bus->priv = ndev;
         new_bus->irq = irqlist;
         new_bus->phy_mask = mdio_bus_data->phy_mask;
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
index 7b1594f4944e..1ac83243649a 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
@@ -62,7 +62,7 @@ static int stmmac_pltfr_probe(struct platform_device *pdev)
         priv = stmmac_dvr_probe(&(pdev->dev), plat_dat);
         if (!priv) {
                 pr_err("%s: main drivr probe failed", __func__);
-                goto out_release_region;
+                goto out_unmap;
         }
 
         priv->ioaddr = addr;
diff --git a/drivers/net/ethernet/ti/cpmac.c b/drivers/net/ethernet/ti/cpmac.c
index aaac0c7ad111..4d9a28ffd3c3 100644
--- a/drivers/net/ethernet/ti/cpmac.c
+++ b/drivers/net/ethernet/ti/cpmac.c
@@ -1269,7 +1269,7 @@ int __devinit cpmac_init(void)
         }
 
         cpmac_mii->phy_mask = ~(mask | 0x80000000);
-        snprintf(cpmac_mii->id, MII_BUS_ID_SIZE, "1");
+        snprintf(cpmac_mii->id, MII_BUS_ID_SIZE, "cpmac-1");
 
         res = mdiobus_register(cpmac_mii);
         if (res)
diff --git a/drivers/net/ethernet/ti/davinci_mdio.c b/drivers/net/ethernet/ti/davinci_mdio.c
index 7615040df756..ef7c9c17bfff 100644
--- a/drivers/net/ethernet/ti/davinci_mdio.c
+++ b/drivers/net/ethernet/ti/davinci_mdio.c
@@ -313,7 +313,8 @@ static int __devinit davinci_mdio_probe(struct platform_device *pdev)
         data->bus->reset        = davinci_mdio_reset,
         data->bus->parent       = dev;
         data->bus->priv         = data;
-        snprintf(data->bus->id, MII_BUS_ID_SIZE, "%x", pdev->id);
+        snprintf(data->bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                pdev->name, pdev->id);
 
         data->clk = clk_get(dev, NULL);
         if (IS_ERR(data->clk)) {
diff --git a/drivers/net/ethernet/tundra/tsi108_eth.c b/drivers/net/ethernet/tundra/tsi108_eth.c
index a9ce01bafd20..164fb775d7b3 100644
--- a/drivers/net/ethernet/tundra/tsi108_eth.c
+++ b/drivers/net/ethernet/tundra/tsi108_eth.c
@@ -1604,7 +1604,7 @@ tsi108_init_one(struct platform_device *pdev)
         data->phyregs = ioremap(einfo->phyregs, 0x400);
         if (NULL == data->phyregs) {
                 err = -ENOMEM;
-                goto regs_fail;
+                goto phyregs_fail;
         }
 /* MII setup */
         data->mii_if.dev = dev;
@@ -1663,9 +1663,11 @@ tsi108_init_one(struct platform_device *pdev)
         return 0;
 
 register_fail:
-        iounmap(data->regs);
         iounmap(data->phyregs);
 
+phyregs_fail:
+        iounmap(data->regs);
+
 regs_fail:
         free_netdev(dev);
         return err;
diff --git a/drivers/net/ethernet/via/via-rhine.c b/drivers/net/ethernet/via/via-rhine.c
index 5c4983b2870a..10b18eb63d25 100644
--- a/drivers/net/ethernet/via/via-rhine.c
+++ b/drivers/net/ethernet/via/via-rhine.c
@@ -39,10 +39,9 @@
 
 /* A few user-configurable values.
    These may be modified when a driver module is loaded. */
-
-#define DEBUG
-static int debug = 1;   /* 1 normal messages, 0 quiet .. 7 verbose. */
-static int max_interrupt_work = 20;
+static int debug = 0;
+#define RHINE_MSG_DEFAULT \
+        (0x0000)
 
 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
    Setting to > 1518 effectively disables this feature. */
@@ -128,12 +127,10 @@ MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 MODULE_DESCRIPTION("VIA Rhine PCI Fast Ethernet driver");
 MODULE_LICENSE("GPL");
 
-module_param(max_interrupt_work, int, 0);
 module_param(debug, int, 0);
 module_param(rx_copybreak, int, 0);
 module_param(avoid_D3, bool, 0);
-MODULE_PARM_DESC(max_interrupt_work, "VIA Rhine maximum events handled per interrupt");
-MODULE_PARM_DESC(debug, "VIA Rhine debug level (0-7)");
+MODULE_PARM_DESC(debug, "VIA Rhine debug message flags");
 MODULE_PARM_DESC(rx_copybreak, "VIA Rhine copy breakpoint for copy-only-tiny-frames");
 MODULE_PARM_DESC(avoid_D3, "Avoid power state D3 (work-around for broken BIOSes)");
 
@@ -351,16 +348,25 @@ static const int mmio_verify_registers[] = {
 
 /* Bits in the interrupt status/mask registers. */
 enum intr_status_bits {
-        IntrRxDone=0x0001, IntrRxErr=0x0004, IntrRxEmpty=0x0020,
-        IntrTxDone=0x0002, IntrTxError=0x0008, IntrTxUnderrun=0x0210,
-        IntrPCIErr=0x0040,
-        IntrStatsMax=0x0080, IntrRxEarly=0x0100,
-        IntrRxOverflow=0x0400, IntrRxDropped=0x0800, IntrRxNoBuf=0x1000,
-        IntrTxAborted=0x2000, IntrLinkChange=0x4000,
-        IntrRxWakeUp=0x8000,
-        IntrNormalSummary=0x0003, IntrAbnormalSummary=0xC260,
-        IntrTxDescRace=0x080000,        /* mapped from IntrStatus2 */
-        IntrTxErrSummary=0x082218,
+        IntrRxDone      = 0x0001,
+        IntrTxDone      = 0x0002,
+        IntrRxErr       = 0x0004,
+        IntrTxError     = 0x0008,
+        IntrRxEmpty     = 0x0020,
+        IntrPCIErr      = 0x0040,
+        IntrStatsMax    = 0x0080,
+        IntrRxEarly     = 0x0100,
+        IntrTxUnderrun  = 0x0210,
+        IntrRxOverflow  = 0x0400,
+        IntrRxDropped   = 0x0800,
+        IntrRxNoBuf     = 0x1000,
+        IntrTxAborted   = 0x2000,
+        IntrLinkChange  = 0x4000,
+        IntrRxWakeUp    = 0x8000,
+        IntrTxDescRace          = 0x080000,     /* mapped from IntrStatus2 */
+        IntrNormalSummary       = IntrRxDone | IntrTxDone,
+        IntrTxErrSummary        = IntrTxDescRace | IntrTxAborted | IntrTxError |
+                                  IntrTxUnderrun,
 };
 
 /* Bits in WOLcrSet/WOLcrClr and PwrcsrSet/PwrcsrClr */
@@ -439,8 +445,13 @@ struct rhine_private {
         struct net_device *dev;
         struct napi_struct napi;
         spinlock_t lock;
+        struct mutex task_lock;
+        bool task_enable;
+        struct work_struct slow_event_task;
         struct work_struct reset_task;
 
+        u32 msg_enable;
+
         /* Frequently used values: keep some adjacent for cache effect. */
         u32 quirks;
         struct rx_desc *rx_head_desc;
@@ -476,41 +487,50 @@ static int  mdio_read(struct net_device *dev, int phy_id, int location);
 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
 static int  rhine_open(struct net_device *dev);
 static void rhine_reset_task(struct work_struct *work);
+static void rhine_slow_event_task(struct work_struct *work);
 static void rhine_tx_timeout(struct net_device *dev);
 static netdev_tx_t rhine_start_tx(struct sk_buff *skb,
                                   struct net_device *dev);
 static irqreturn_t rhine_interrupt(int irq, void *dev_instance);
 static void rhine_tx(struct net_device *dev);
 static int rhine_rx(struct net_device *dev, int limit);
-static void rhine_error(struct net_device *dev, int intr_status);
 static void rhine_set_rx_mode(struct net_device *dev);
 static struct net_device_stats *rhine_get_stats(struct net_device *dev);
 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 static const struct ethtool_ops netdev_ethtool_ops;
 static int  rhine_close(struct net_device *dev);
-static void rhine_shutdown (struct pci_dev *pdev);
 static int rhine_vlan_rx_add_vid(struct net_device *dev, unsigned short vid);
 static int rhine_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid);
-static void rhine_set_cam(void __iomem *ioaddr, int idx, u8 *addr);
-static void rhine_set_vlan_cam(void __iomem *ioaddr, int idx, u8 *addr);
-static void rhine_set_cam_mask(void __iomem *ioaddr, u32 mask);
-static void rhine_set_vlan_cam_mask(void __iomem *ioaddr, u32 mask);
-static void rhine_init_cam_filter(struct net_device *dev);
-static void rhine_update_vcam(struct net_device *dev);
-
-#define RHINE_WAIT_FOR(condition)                               \
-do {                                                            \
-        int i = 1024;                                           \
-        while (!(condition) && --i)                             \
-                ;                                               \
-        if (debug > 1 && i < 512)                               \
-                pr_info("%4d cycles used @ %s:%d\n",            \
-                        1024 - i, __func__, __LINE__);          \
-} while (0)
-
-static inline u32 get_intr_status(struct net_device *dev)
+static void rhine_restart_tx(struct net_device *dev);
+
+static void rhine_wait_bit(struct rhine_private *rp, u8 reg, u8 mask, bool high)
+{
+        void __iomem *ioaddr = rp->base;
+        int i;
+
+        for (i = 0; i < 1024; i++) {
+                if (high ^ !!(ioread8(ioaddr + reg) & mask))
+                        break;
+                udelay(10);
+        }
+        if (i > 64) {
+                netif_dbg(rp, hw, rp->dev, "%s bit wait (%02x/%02x) cycle "
+                          "count: %04d\n", high ? "high" : "low", reg, mask, i);
+        }
+}
+
+static void rhine_wait_bit_high(struct rhine_private *rp, u8 reg, u8 mask)
+{
+        rhine_wait_bit(rp, reg, mask, true);
+}
+
+static void rhine_wait_bit_low(struct rhine_private *rp, u8 reg, u8 mask)
+{
+        rhine_wait_bit(rp, reg, mask, false);
+}
+
+static u32 rhine_get_events(struct rhine_private *rp)
 {
-        struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
         u32 intr_status;
 
@@ -521,6 +541,16 @@ static inline u32 get_intr_status(struct net_device *dev)
         return intr_status;
 }
 
+static void rhine_ack_events(struct rhine_private *rp, u32 mask)
+{
+        void __iomem *ioaddr = rp->base;
+
+        if (rp->quirks & rqStatusWBRace)
+                iowrite8(mask >> 16, ioaddr + IntrStatus2);
+        iowrite16(mask, ioaddr + IntrStatus);
+        mmiowb();
+}
+
 /*
  * Get power related registers into sane state.
  * Notify user about past WOL event.
@@ -585,6 +615,7 @@ static void rhine_chip_reset(struct net_device *dev)
 {
         struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
+        u8 cmd1;
 
         iowrite8(Cmd1Reset, ioaddr + ChipCmd1);
         IOSYNC;
@@ -597,13 +628,12 @@ static void rhine_chip_reset(struct net_device *dev)
                         iowrite8(0x40, ioaddr + MiscCmd);
 
                 /* Reset can take somewhat longer (rare) */
-                RHINE_WAIT_FOR(!(ioread8(ioaddr + ChipCmd1) & Cmd1Reset));
+                rhine_wait_bit_low(rp, ChipCmd1, Cmd1Reset);
         }
 
-        if (debug > 1)
-                netdev_info(dev, "Reset %s\n",
-                            (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) ?
-                            "failed" : "succeeded");
+        cmd1 = ioread8(ioaddr + ChipCmd1);
+        netif_info(rp, hw, dev, "Reset %s\n", (cmd1 & Cmd1Reset) ?
+                   "failed" : "succeeded");
 }
 
 #ifdef USE_MMIO
@@ -629,9 +659,15 @@ static void __devinit rhine_reload_eeprom(long pioaddr, struct net_device *dev)
 {
         struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
+        int i;
 
         outb(0x20, pioaddr + MACRegEEcsr);
-        RHINE_WAIT_FOR(!(inb(pioaddr + MACRegEEcsr) & 0x20));
+        for (i = 0; i < 1024; i++) {
+                if (!(inb(pioaddr + MACRegEEcsr) & 0x20))
+                        break;
+        }
+        if (i > 512)
+                pr_info("%4d cycles used @ %s:%d\n", i, __func__, __LINE__);
 
 #ifdef USE_MMIO
         /*
@@ -657,23 +693,127 @@ static void rhine_poll(struct net_device *dev)
 }
 #endif
 
+static void rhine_kick_tx_threshold(struct rhine_private *rp)
+{
+        if (rp->tx_thresh < 0xe0) {
+                void __iomem *ioaddr = rp->base;
+
+                rp->tx_thresh += 0x20;
+                BYTE_REG_BITS_SET(rp->tx_thresh, 0x80, ioaddr + TxConfig);
+        }
+}
+
+static void rhine_tx_err(struct rhine_private *rp, u32 status)
+{
+        struct net_device *dev = rp->dev;
+
+        if (status & IntrTxAborted) {
+                netif_info(rp, tx_err, dev,
+                           "Abort %08x, frame dropped\n", status);
+        }
+
+        if (status & IntrTxUnderrun) {
+                rhine_kick_tx_threshold(rp);
+                netif_info(rp, tx_err ,dev, "Transmitter underrun, "
+                           "Tx threshold now %02x\n", rp->tx_thresh);
+        }
+
+        if (status & IntrTxDescRace)
+                netif_info(rp, tx_err, dev, "Tx descriptor write-back race\n");
+
+        if ((status & IntrTxError) &&
+            (status & (IntrTxAborted | IntrTxUnderrun | IntrTxDescRace)) == 0) {
+                rhine_kick_tx_threshold(rp);
+                netif_info(rp, tx_err, dev, "Unspecified error. "
+                           "Tx threshold now %02x\n", rp->tx_thresh);
+        }
+
+        rhine_restart_tx(dev);
+}
+
+static void rhine_update_rx_crc_and_missed_errord(struct rhine_private *rp)
+{
+        void __iomem *ioaddr = rp->base;
+        struct net_device_stats *stats = &rp->dev->stats;
+
+        stats->rx_crc_errors    += ioread16(ioaddr + RxCRCErrs);
+        stats->rx_missed_errors += ioread16(ioaddr + RxMissed);
+
+        /*
+         * Clears the "tally counters" for CRC errors and missed frames(?).
+         * It has been reported that some chips need a write of 0 to clear
+         * these, for others the counters are set to 1 when written to and
+         * instead cleared when read. So we clear them both ways ...
+         */
+        iowrite32(0, ioaddr + RxMissed);
+        ioread16(ioaddr + RxCRCErrs);
+        ioread16(ioaddr + RxMissed);
+}
+
+#define RHINE_EVENT_NAPI_RX     (IntrRxDone | \
+                                 IntrRxErr | \
+                                 IntrRxEmpty | \
+                                 IntrRxOverflow | \
+                                 IntrRxDropped | \
+                                 IntrRxNoBuf | \
+                                 IntrRxWakeUp)
+
+#define RHINE_EVENT_NAPI_TX_ERR (IntrTxError | \
+                                 IntrTxAborted | \
+                                 IntrTxUnderrun | \
+                                 IntrTxDescRace)
+#define RHINE_EVENT_NAPI_TX     (IntrTxDone | RHINE_EVENT_NAPI_TX_ERR)
+
+#define RHINE_EVENT_NAPI        (RHINE_EVENT_NAPI_RX | \
+                                 RHINE_EVENT_NAPI_TX | \
+                                 IntrStatsMax)
+#define RHINE_EVENT_SLOW        (IntrPCIErr | IntrLinkChange)
+#define RHINE_EVENT             (RHINE_EVENT_NAPI | RHINE_EVENT_SLOW)
+
 static int rhine_napipoll(struct napi_struct *napi, int budget)
 {
         struct rhine_private *rp = container_of(napi, struct rhine_private, napi);
         struct net_device *dev = rp->dev;
         void __iomem *ioaddr = rp->base;
-        int work_done;
+        u16 enable_mask = RHINE_EVENT & 0xffff;
+        int work_done = 0;
+        u32 status;
+
+        status = rhine_get_events(rp);
+        rhine_ack_events(rp, status & ~RHINE_EVENT_SLOW);
+
+        if (status & RHINE_EVENT_NAPI_RX)
+                work_done += rhine_rx(dev, budget);
+
+        if (status & RHINE_EVENT_NAPI_TX) {
+                if (status & RHINE_EVENT_NAPI_TX_ERR) {
+                        /* Avoid scavenging before Tx engine turned off */
+                        rhine_wait_bit_low(rp, ChipCmd, CmdTxOn);
+                        if (ioread8(ioaddr + ChipCmd) & CmdTxOn)
+                                netif_warn(rp, tx_err, dev, "Tx still on\n");
+                }
 
-        work_done = rhine_rx(dev, budget);
+                rhine_tx(dev);
+
+                if (status & RHINE_EVENT_NAPI_TX_ERR)
+                        rhine_tx_err(rp, status);
+        }
+
+        if (status & IntrStatsMax) {
+                spin_lock(&rp->lock);
+                rhine_update_rx_crc_and_missed_errord(rp);
+                spin_unlock(&rp->lock);
+        }
+
+        if (status & RHINE_EVENT_SLOW) {
+                enable_mask &= ~RHINE_EVENT_SLOW;
+                schedule_work(&rp->slow_event_task);
+        }
 
         if (work_done < budget) {
                 napi_complete(napi);
-
-                iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
-                          IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
-                          IntrTxDone | IntrTxError | IntrTxUnderrun |
-                          IntrPCIErr | IntrStatsMax | IntrLinkChange,
-                          ioaddr + IntrEnable);
+                iowrite16(enable_mask, ioaddr + IntrEnable);
+                mmiowb();
         }
         return work_done;
 }
@@ -797,6 +937,7 @@ static int __devinit rhine_init_one(struct pci_dev *pdev,
         rp->quirks = quirks;
         rp->pioaddr = pioaddr;
         rp->pdev = pdev;
+        rp->msg_enable = netif_msg_init(debug, RHINE_MSG_DEFAULT);
 
         rc = pci_request_regions(pdev, DRV_NAME);
         if (rc)
@@ -856,7 +997,9 @@ static int __devinit rhine_init_one(struct pci_dev *pdev,
         dev->irq = pdev->irq;
 
         spin_lock_init(&rp->lock);
+        mutex_init(&rp->task_lock);
         INIT_WORK(&rp->reset_task, rhine_reset_task);
+        INIT_WORK(&rp->slow_event_task, rhine_slow_event_task);
 
         rp->mii_if.dev = dev;
         rp->mii_if.mdio_read = mdio_read;
@@ -916,8 +1059,8 @@ static int __devinit rhine_init_one(struct pci_dev *pdev,
                 }
         }
         rp->mii_if.phy_id = phy_id;
-        if (debug > 1 && avoid_D3)
-                netdev_info(dev, "No D3 power state at shutdown\n");
+        if (avoid_D3)
+                netif_info(rp, probe, dev, "No D3 power state at shutdown\n");
 
         return 0;
 
@@ -1093,7 +1236,7 @@ static void rhine_check_media(struct net_device *dev, unsigned int init_media)
         struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
 
-        mii_check_media(&rp->mii_if, debug, init_media);
+        mii_check_media(&rp->mii_if, netif_msg_link(rp), init_media);
 
         if (rp->mii_if.full_duplex)
             iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1FDuplex,
@@ -1101,24 +1244,26 @@ static void rhine_check_media(struct net_device *dev, unsigned int init_media)
         else
             iowrite8(ioread8(ioaddr + ChipCmd1) & ~Cmd1FDuplex,
                    ioaddr + ChipCmd1);
-        if (debug > 1)
-                netdev_info(dev, "force_media %d, carrier %d\n",
-                            rp->mii_if.force_media, netif_carrier_ok(dev));
+
+        netif_info(rp, link, dev, "force_media %d, carrier %d\n",
+                   rp->mii_if.force_media, netif_carrier_ok(dev));
 }
 
 /* Called after status of force_media possibly changed */
 static void rhine_set_carrier(struct mii_if_info *mii)
 {
+        struct net_device *dev = mii->dev;
+        struct rhine_private *rp = netdev_priv(dev);
+
         if (mii->force_media) {
                 /* autoneg is off: Link is always assumed to be up */
-                if (!netif_carrier_ok(mii->dev))
-                        netif_carrier_on(mii->dev);
-        }
-        else    /* Let MMI library update carrier status */
-                rhine_check_media(mii->dev, 0);
-        if (debug > 1)
-                netdev_info(mii->dev, "force_media %d, carrier %d\n",
-                            mii->force_media, netif_carrier_ok(mii->dev));
+                if (!netif_carrier_ok(dev))
+                        netif_carrier_on(dev);
+        } else  /* Let MMI library update carrier status */
+                rhine_check_media(dev, 0);
+
+        netif_info(rp, link, dev, "force_media %d, carrier %d\n",
+                   mii->force_media, netif_carrier_ok(dev));
 }
 
 /**
@@ -1266,10 +1411,10 @@ static int rhine_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
 {
         struct rhine_private *rp = netdev_priv(dev);
 
-        spin_lock_irq(&rp->lock);
+        spin_lock_bh(&rp->lock);
         set_bit(vid, rp->active_vlans);
         rhine_update_vcam(dev);
-        spin_unlock_irq(&rp->lock);
+        spin_unlock_bh(&rp->lock);
         return 0;
 }
 
@@ -1277,10 +1422,10 @@ static int rhine_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
 {
         struct rhine_private *rp = netdev_priv(dev);
 
-        spin_lock_irq(&rp->lock);
+        spin_lock_bh(&rp->lock);
         clear_bit(vid, rp->active_vlans);
         rhine_update_vcam(dev);
-        spin_unlock_irq(&rp->lock);
+        spin_unlock_bh(&rp->lock);
         return 0;
 }
 
@@ -1310,12 +1455,7 @@ static void init_registers(struct net_device *dev)
 
         napi_enable(&rp->napi);
 
-        /* Enable interrupts by setting the interrupt mask. */
-        iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
-               IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
-               IntrTxDone | IntrTxError | IntrTxUnderrun |
-               IntrPCIErr | IntrStatsMax | IntrLinkChange,
-               ioaddr + IntrEnable);
+        iowrite16(RHINE_EVENT & 0xffff, ioaddr + IntrEnable);
 
         iowrite16(CmdStart | CmdTxOn | CmdRxOn | (Cmd1NoTxPoll << 8),
                ioaddr + ChipCmd);
@@ -1323,23 +1463,27 @@ static void init_registers(struct net_device *dev)
 }
 
 /* Enable MII link status auto-polling (required for IntrLinkChange) */
-static void rhine_enable_linkmon(void __iomem *ioaddr)
+static void rhine_enable_linkmon(struct rhine_private *rp)
 {
+        void __iomem *ioaddr = rp->base;
+
         iowrite8(0, ioaddr + MIICmd);
         iowrite8(MII_BMSR, ioaddr + MIIRegAddr);
         iowrite8(0x80, ioaddr + MIICmd);
 
-        RHINE_WAIT_FOR((ioread8(ioaddr + MIIRegAddr) & 0x20));
+        rhine_wait_bit_high(rp, MIIRegAddr, 0x20);
 
         iowrite8(MII_BMSR | 0x40, ioaddr + MIIRegAddr);
 }
 
 /* Disable MII link status auto-polling (required for MDIO access) */
-static void rhine_disable_linkmon(void __iomem *ioaddr, u32 quirks)
+static void rhine_disable_linkmon(struct rhine_private *rp)
 {
+        void __iomem *ioaddr = rp->base;
+
         iowrite8(0, ioaddr + MIICmd);
 
-        if (quirks & rqRhineI) {
+        if (rp->quirks & rqRhineI) {
                 iowrite8(0x01, ioaddr + MIIRegAddr);    // MII_BMSR
 
                 /* Can be called from ISR. Evil. */
@@ -1348,13 +1492,13 @@ static void rhine_disable_linkmon(void __iomem *ioaddr, u32 quirks)
                 /* 0x80 must be set immediately before turning it off */
                 iowrite8(0x80, ioaddr + MIICmd);
 
-                RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x20);
+                rhine_wait_bit_high(rp, MIIRegAddr, 0x20);
 
                 /* Heh. Now clear 0x80 again. */
                 iowrite8(0, ioaddr + MIICmd);
         }
         else
-                RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x80);
+                rhine_wait_bit_high(rp, MIIRegAddr, 0x80);
 }
 
 /* Read and write over the MII Management Data I/O (MDIO) interface. */
@@ -1365,16 +1509,16 @@ static int mdio_read(struct net_device *dev, int phy_id, int regnum)
         void __iomem *ioaddr = rp->base;
         int result;
 
-        rhine_disable_linkmon(ioaddr, rp->quirks);
+        rhine_disable_linkmon(rp);
 
         /* rhine_disable_linkmon already cleared MIICmd */
         iowrite8(phy_id, ioaddr + MIIPhyAddr);
         iowrite8(regnum, ioaddr + MIIRegAddr);
         iowrite8(0x40, ioaddr + MIICmd);                /* Trigger read */
-        RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x40));
+        rhine_wait_bit_low(rp, MIICmd, 0x40);
         result = ioread16(ioaddr + MIIData);
 
-        rhine_enable_linkmon(ioaddr);
+        rhine_enable_linkmon(rp);
         return result;
 }
 
@@ -1383,16 +1527,33 @@ static void mdio_write(struct net_device *dev, int phy_id, int regnum, int value
         struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
 
-        rhine_disable_linkmon(ioaddr, rp->quirks);
+        rhine_disable_linkmon(rp);
 
         /* rhine_disable_linkmon already cleared MIICmd */
         iowrite8(phy_id, ioaddr + MIIPhyAddr);
         iowrite8(regnum, ioaddr + MIIRegAddr);
         iowrite16(value, ioaddr + MIIData);
         iowrite8(0x20, ioaddr + MIICmd);                /* Trigger write */
-        RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x20));
+        rhine_wait_bit_low(rp, MIICmd, 0x20);
 
-        rhine_enable_linkmon(ioaddr);
+        rhine_enable_linkmon(rp);
+}
+
+static void rhine_task_disable(struct rhine_private *rp)
+{
+        mutex_lock(&rp->task_lock);
+        rp->task_enable = false;
+        mutex_unlock(&rp->task_lock);
+
+        cancel_work_sync(&rp->slow_event_task);
+        cancel_work_sync(&rp->reset_task);
+}
+
+static void rhine_task_enable(struct rhine_private *rp)
+{
+        mutex_lock(&rp->task_lock);
+        rp->task_enable = true;
+        mutex_unlock(&rp->task_lock);
 }
 
 static int rhine_open(struct net_device *dev)
@@ -1406,8 +1567,7 @@ static int rhine_open(struct net_device *dev)
         if (rc)
                 return rc;
 
-        if (debug > 1)
-                netdev_dbg(dev, "%s() irq %d\n", __func__, rp->pdev->irq);
+        netif_dbg(rp, ifup, dev, "%s() irq %d\n", __func__, rp->pdev->irq);
 
         rc = alloc_ring(dev);
         if (rc) {
@@ -1417,11 +1577,12 @@ static int rhine_open(struct net_device *dev)
         alloc_rbufs(dev);
         alloc_tbufs(dev);
         rhine_chip_reset(dev);
+        rhine_task_enable(rp);
         init_registers(dev);
-        if (debug > 2)
-                netdev_dbg(dev, "%s() Done - status %04x MII status: %04x\n",
-                           __func__, ioread16(ioaddr + ChipCmd),
-                           mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
+
+        netif_dbg(rp, ifup, dev, "%s() Done - status %04x MII status: %04x\n",
+                  __func__, ioread16(ioaddr + ChipCmd),
+                  mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
 
         netif_start_queue(dev);
 
@@ -1434,11 +1595,12 @@ static void rhine_reset_task(struct work_struct *work)
                                                 reset_task);
         struct net_device *dev = rp->dev;
 
-        /* protect against concurrent rx interrupts */
-        disable_irq(rp->pdev->irq);
+        mutex_lock(&rp->task_lock);
 
-        napi_disable(&rp->napi);
+        if (!rp->task_enable)
+                goto out_unlock;
 
+        napi_disable(&rp->napi);
         spin_lock_bh(&rp->lock);
 
         /* clear all descriptors */
@@ -1452,11 +1614,13 @@ static void rhine_reset_task(struct work_struct *work)
         init_registers(dev);
 
         spin_unlock_bh(&rp->lock);
-        enable_irq(rp->pdev->irq);
 
         dev->trans_start = jiffies; /* prevent tx timeout */
         dev->stats.tx_errors++;
         netif_wake_queue(dev);
+
+out_unlock:
+        mutex_unlock(&rp->task_lock);
 }
 
 static void rhine_tx_timeout(struct net_device *dev)
@@ -1477,7 +1641,6 @@ static netdev_tx_t rhine_start_tx(struct sk_buff *skb,
         struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
         unsigned entry;
-        unsigned long flags;
 
         /* Caution: the write order is important here, set the field
            with the "ownership" bits last. */
@@ -1529,7 +1692,6 @@ static netdev_tx_t rhine_start_tx(struct sk_buff *skb,
                 rp->tx_ring[entry].tx_status = 0;
 
         /* lock eth irq */
-        spin_lock_irqsave(&rp->lock, flags);
         wmb();
         rp->tx_ring[entry].tx_status |= cpu_to_le32(DescOwn);
         wmb();
@@ -1550,78 +1712,43 @@ static netdev_tx_t rhine_start_tx(struct sk_buff *skb,
         if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN)
                 netif_stop_queue(dev);
 
-        spin_unlock_irqrestore(&rp->lock, flags);
+        netif_dbg(rp, tx_queued, dev, "Transmit frame #%d queued in slot %d\n",
+                  rp->cur_tx - 1, entry);
 
-        if (debug > 4) {
-                netdev_dbg(dev, "Transmit frame #%d queued in slot %d\n",
-                           rp->cur_tx-1, entry);
-        }
         return NETDEV_TX_OK;
 }
 
+static void rhine_irq_disable(struct rhine_private *rp)
+{
+        iowrite16(0x0000, rp->base + IntrEnable);
+        mmiowb();
+}
+
 /* The interrupt handler does all of the Rx thread work and cleans up
    after the Tx thread. */
 static irqreturn_t rhine_interrupt(int irq, void *dev_instance)
 {
         struct net_device *dev = dev_instance;
         struct rhine_private *rp = netdev_priv(dev);
-        void __iomem *ioaddr = rp->base;
-        u32 intr_status;
-        int boguscnt = max_interrupt_work;
+        u32 status;
         int handled = 0;
 
-        while ((intr_status = get_intr_status(dev))) {
-                handled = 1;
-
-                /* Acknowledge all of the current interrupt sources ASAP. */
-                if (intr_status & IntrTxDescRace)
-                        iowrite8(0x08, ioaddr + IntrStatus2);
-                iowrite16(intr_status & 0xffff, ioaddr + IntrStatus);
-                IOSYNC;
+        status = rhine_get_events(rp);
 
-                if (debug > 4)
-                        netdev_dbg(dev, "Interrupt, status %08x\n",
-                                   intr_status);
-
-                if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped |
-                                   IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf)) {
-                        iowrite16(IntrTxAborted |
-                                  IntrTxDone | IntrTxError | IntrTxUnderrun |
-                                  IntrPCIErr | IntrStatsMax | IntrLinkChange,
-                                  ioaddr + IntrEnable);
-
-                        napi_schedule(&rp->napi);
-                }
+        netif_dbg(rp, intr, dev, "Interrupt, status %08x\n", status);
 
-                if (intr_status & (IntrTxErrSummary | IntrTxDone)) {
-                        if (intr_status & IntrTxErrSummary) {
-                                /* Avoid scavenging before Tx engine turned off */
-                                RHINE_WAIT_FOR(!(ioread8(ioaddr+ChipCmd) & CmdTxOn));
-                                if (debug > 2 &&
-                                    ioread8(ioaddr+ChipCmd) & CmdTxOn)
-                                        netdev_warn(dev,
-                                                    "%s: Tx engine still on\n",
-                                                    __func__);
-                        }
-                        rhine_tx(dev);
-                }
+        if (status & RHINE_EVENT) {
+                handled = 1;
 
-                /* Abnormal error summary/uncommon events handlers. */
-                if (intr_status & (IntrPCIErr | IntrLinkChange |
-                                   IntrStatsMax | IntrTxError | IntrTxAborted |
-                                   IntrTxUnderrun | IntrTxDescRace))
-                        rhine_error(dev, intr_status);
+                rhine_irq_disable(rp);
+                napi_schedule(&rp->napi);
+        }
 
-                if (--boguscnt < 0) {
-                        netdev_warn(dev, "Too much work at interrupt, status=%#08x\n",
-                                    intr_status);
-                        break;
-                }
+        if (status & ~(IntrLinkChange | IntrStatsMax | RHINE_EVENT_NAPI)) {
+                netif_err(rp, intr, dev, "Something Wicked happened! %08x\n",
+                          status);
         }
 
-        if (debug > 3)
-                netdev_dbg(dev, "exiting interrupt, status=%08x\n",
-                           ioread16(ioaddr + IntrStatus));
         return IRQ_RETVAL(handled);
 }
 
@@ -1632,20 +1759,16 @@ static void rhine_tx(struct net_device *dev)
         struct rhine_private *rp = netdev_priv(dev);
         int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE;
 
-        spin_lock(&rp->lock);
-
         /* find and cleanup dirty tx descriptors */
         while (rp->dirty_tx != rp->cur_tx) {
                 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);
-                if (debug > 6)
-                        netdev_dbg(dev, "Tx scavenge %d status %08x\n",
-                                   entry, txstatus);
+                netif_dbg(rp, tx_done, dev, "Tx scavenge %d status %08x\n",
+                          entry, txstatus);
                 if (txstatus & DescOwn)
                         break;
                 if (txstatus & 0x8000) {
-                        if (debug > 1)
-                                netdev_dbg(dev, "Transmit error, Tx status %08x\n",
-                                           txstatus);
+                        netif_dbg(rp, tx_done, dev,
+                                  "Transmit error, Tx status %08x\n", txstatus);
                         dev->stats.tx_errors++;
                         if (txstatus & 0x0400)
                                 dev->stats.tx_carrier_errors++;
@@ -1667,10 +1790,8 @@ static void rhine_tx(struct net_device *dev)
                                 dev->stats.collisions += (txstatus >> 3) & 0x0F;
                         else
                                 dev->stats.collisions += txstatus & 0x0F;
-                        if (debug > 6)
-                                netdev_dbg(dev, "collisions: %1.1x:%1.1x\n",
-                                           (txstatus >> 3) & 0xF,
-                                           txstatus & 0xF);
+                        netif_dbg(rp, tx_done, dev, "collisions: %1.1x:%1.1x\n",
+                                  (txstatus >> 3) & 0xF, txstatus & 0xF);
                         dev->stats.tx_bytes += rp->tx_skbuff[entry]->len;
                         dev->stats.tx_packets++;
                 }
@@ -1687,8 +1808,6 @@ static void rhine_tx(struct net_device *dev)
         }
         if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4)
                 netif_wake_queue(dev);
-
-        spin_unlock(&rp->lock);
 }
 
 /**
@@ -1713,11 +1832,8 @@ static int rhine_rx(struct net_device *dev, int limit)
         int count;
         int entry = rp->cur_rx % RX_RING_SIZE;
 
-        if (debug > 4) {
-                netdev_dbg(dev, "%s(), entry %d status %08x\n",
-                           __func__, entry,
-                           le32_to_cpu(rp->rx_head_desc->rx_status));
-        }
+        netif_dbg(rp, rx_status, dev, "%s(), entry %d status %08x\n", __func__,
+                  entry, le32_to_cpu(rp->rx_head_desc->rx_status));
 
         /* If EOP is set on the next entry, it's a new packet. Send it up. */
         for (count = 0; count < limit; ++count) {
@@ -1729,9 +1845,8 @@ static int rhine_rx(struct net_device *dev, int limit)
                 if (desc_status & DescOwn)
                         break;
 
-                if (debug > 4)
-                        netdev_dbg(dev, "%s() status is %08x\n",
-                                   __func__, desc_status);
+                netif_dbg(rp, rx_status, dev, "%s() status %08x\n", __func__,
+                          desc_status);
 
                 if ((desc_status & (RxWholePkt | RxErr)) != RxWholePkt) {
                         if ((desc_status & RxWholePkt) != RxWholePkt) {
@@ -1747,9 +1862,9 @@ static int rhine_rx(struct net_device *dev, int limit)
                                 dev->stats.rx_length_errors++;
                         } else if (desc_status & RxErr) {
                                 /* There was a error. */
-                                if (debug > 2)
-                                        netdev_dbg(dev, "%s() Rx error was %08x\n",
-                                                   __func__, desc_status);
+                                netif_dbg(rp, rx_err, dev,
+                                          "%s() Rx error %08x\n", __func__,
+                                          desc_status);
                                 dev->stats.rx_errors++;
                                 if (desc_status & 0x0030)
                                         dev->stats.rx_length_errors++;
@@ -1839,19 +1954,6 @@ static int rhine_rx(struct net_device *dev, int limit)
         return count;
 }
 
-/*
- * Clears the "tally counters" for CRC errors and missed frames(?).
- * It has been reported that some chips need a write of 0 to clear
- * these, for others the counters are set to 1 when written to and
- * instead cleared when read. So we clear them both ways ...
- */
-static inline void clear_tally_counters(void __iomem *ioaddr)
-{
-        iowrite32(0, ioaddr + RxMissed);
-        ioread16(ioaddr + RxCRCErrs);
-        ioread16(ioaddr + RxMissed);
-}
-
 static void rhine_restart_tx(struct net_device *dev) {
         struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
@@ -1862,7 +1964,7 @@ static void rhine_restart_tx(struct net_device *dev) {
          * If new errors occurred, we need to sort them out before doing Tx.
          * In that case the ISR will be back here RSN anyway.
          */
-        intr_status = get_intr_status(dev);
+        intr_status = rhine_get_events(rp);
 
         if ((intr_status & IntrTxErrSummary) == 0) {
 
@@ -1883,79 +1985,50 @@ static void rhine_restart_tx(struct net_device *dev) {
         }
         else {
                 /* This should never happen */
-                if (debug > 1)
-                        netdev_warn(dev, "%s() Another error occurred %08x\n",
-                                   __func__, intr_status);
+                netif_warn(rp, tx_err, dev, "another error occurred %08x\n",
+                           intr_status);
         }
 
 }
 
-static void rhine_error(struct net_device *dev, int intr_status)
+static void rhine_slow_event_task(struct work_struct *work)
 {
-        struct rhine_private *rp = netdev_priv(dev);
-        void __iomem *ioaddr = rp->base;
+        struct rhine_private *rp =
+                container_of(work, struct rhine_private, slow_event_task);
+        struct net_device *dev = rp->dev;
+        u32 intr_status;
 
-        spin_lock(&rp->lock);
+        mutex_lock(&rp->task_lock);
+
+        if (!rp->task_enable)
+                goto out_unlock;
+
+        intr_status = rhine_get_events(rp);
+        rhine_ack_events(rp, intr_status & RHINE_EVENT_SLOW);
 
         if (intr_status & IntrLinkChange)
                 rhine_check_media(dev, 0);
-        if (intr_status & IntrStatsMax) {
-                dev->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
-                dev->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
-                clear_tally_counters(ioaddr);
-        }
-        if (intr_status & IntrTxAborted) {
-                if (debug > 1)
-                        netdev_info(dev, "Abort %08x, frame dropped\n",
-                                    intr_status);
-        }
-        if (intr_status & IntrTxUnderrun) {
-                if (rp->tx_thresh < 0xE0)
-                        BYTE_REG_BITS_SET((rp->tx_thresh += 0x20), 0x80, ioaddr + TxConfig);
-                if (debug > 1)
-                        netdev_info(dev, "Transmitter underrun, Tx threshold now %02x\n",
-                                    rp->tx_thresh);
-        }
-        if (intr_status & IntrTxDescRace) {
-                if (debug > 2)
-                        netdev_info(dev, "Tx descriptor write-back race\n");
-        }
-        if ((intr_status & IntrTxError) &&
-            (intr_status & (IntrTxAborted |
-             IntrTxUnderrun | IntrTxDescRace)) == 0) {
-                if (rp->tx_thresh < 0xE0) {
-                        BYTE_REG_BITS_SET((rp->tx_thresh += 0x20), 0x80, ioaddr + TxConfig);
-                }
-                if (debug > 1)
-                        netdev_info(dev, "Unspecified error. Tx threshold now %02x\n",
-                                    rp->tx_thresh);
-        }
-        if (intr_status & (IntrTxAborted | IntrTxUnderrun | IntrTxDescRace |
-                           IntrTxError))
-                rhine_restart_tx(dev);
-
-        if (intr_status & ~(IntrLinkChange | IntrStatsMax | IntrTxUnderrun |
-                            IntrTxError | IntrTxAborted | IntrNormalSummary |
-                            IntrTxDescRace)) {
-                if (debug > 1)
-                        netdev_err(dev, "Something Wicked happened! %08x\n",
-                                   intr_status);
-        }
 
-        spin_unlock(&rp->lock);
+        if (intr_status & IntrPCIErr)
+                netif_warn(rp, hw, dev, "PCI error\n");
+
+        napi_disable(&rp->napi);
+        rhine_irq_disable(rp);
+        /* Slow and safe. Consider __napi_schedule as a replacement ? */
+        napi_enable(&rp->napi);
+        napi_schedule(&rp->napi);
+
+out_unlock:
+        mutex_unlock(&rp->task_lock);
 }
 
 static struct net_device_stats *rhine_get_stats(struct net_device *dev)
 {
         struct rhine_private *rp = netdev_priv(dev);
-        void __iomem *ioaddr = rp->base;
-        unsigned long flags;
 
-        spin_lock_irqsave(&rp->lock, flags);
-        dev->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
-        dev->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
-        clear_tally_counters(ioaddr);
-        spin_unlock_irqrestore(&rp->lock, flags);
+        spin_lock_bh(&rp->lock);
+        rhine_update_rx_crc_and_missed_errord(rp);
+        spin_unlock_bh(&rp->lock);
 
         return &dev->stats;
 }
@@ -2022,9 +2095,9 @@ static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
         struct rhine_private *rp = netdev_priv(dev);
         int rc;
 
-        spin_lock_irq(&rp->lock);
+        mutex_lock(&rp->task_lock);
         rc = mii_ethtool_gset(&rp->mii_if, cmd);
-        spin_unlock_irq(&rp->lock);
+        mutex_unlock(&rp->task_lock);
 
         return rc;
 }
@@ -2034,10 +2107,10 @@ static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
         struct rhine_private *rp = netdev_priv(dev);
         int rc;
 
-        spin_lock_irq(&rp->lock);
+        mutex_lock(&rp->task_lock);
         rc = mii_ethtool_sset(&rp->mii_if, cmd);
-        spin_unlock_irq(&rp->lock);
         rhine_set_carrier(&rp->mii_if);
+        mutex_unlock(&rp->task_lock);
 
         return rc;
 }
@@ -2058,12 +2131,16 @@ static u32 netdev_get_link(struct net_device *dev)
 
 static u32 netdev_get_msglevel(struct net_device *dev)
 {
-        return debug;
+        struct rhine_private *rp = netdev_priv(dev);
+
+        return rp->msg_enable;
 }
 
 static void netdev_set_msglevel(struct net_device *dev, u32 value)
 {
-        debug = value;
+        struct rhine_private *rp = netdev_priv(dev);
+
+        rp->msg_enable = value;
 }
 
 static void rhine_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
@@ -2119,10 +2196,10 @@ static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
         if (!netif_running(dev))
                 return -EINVAL;
 
-        spin_lock_irq(&rp->lock);
+        mutex_lock(&rp->task_lock);
         rc = generic_mii_ioctl(&rp->mii_if, if_mii(rq), cmd, NULL);
-        spin_unlock_irq(&rp->lock);
         rhine_set_carrier(&rp->mii_if);
+        mutex_unlock(&rp->task_lock);
 
         return rc;
 }
@@ -2132,27 +2209,21 @@ static int rhine_close(struct net_device *dev)
         struct rhine_private *rp = netdev_priv(dev);
         void __iomem *ioaddr = rp->base;
 
+        rhine_task_disable(rp);
         napi_disable(&rp->napi);
-        cancel_work_sync(&rp->reset_task);
         netif_stop_queue(dev);
 
-        spin_lock_irq(&rp->lock);
-
-        if (debug > 1)
-                netdev_dbg(dev, "Shutting down ethercard, status was %04x\n",
-                           ioread16(ioaddr + ChipCmd));
+        netif_dbg(rp, ifdown, dev, "Shutting down ethercard, status was %04x\n",
+                  ioread16(ioaddr + ChipCmd));
 
         /* Switch to loopback mode to avoid hardware races. */
         iowrite8(rp->tx_thresh | 0x02, ioaddr + TxConfig);
 
-        /* Disable interrupts by clearing the interrupt mask. */
-        iowrite16(0x0000, ioaddr + IntrEnable);
+        rhine_irq_disable(rp);
 
         /* Stop the chip's Tx and Rx processes. */
         iowrite16(CmdStop, ioaddr + ChipCmd);
 
-        spin_unlock_irq(&rp->lock);
-
         free_irq(rp->pdev->irq, dev);
         free_rbufs(dev);
         free_tbufs(dev);
@@ -2192,6 +2263,8 @@ static void rhine_shutdown (struct pci_dev *pdev)
         if (rp->quirks & rq6patterns)
                 iowrite8(0x04, ioaddr + WOLcgClr);
 
+        spin_lock(&rp->lock);
+
         if (rp->wolopts & WAKE_MAGIC) {
                 iowrite8(WOLmagic, ioaddr + WOLcrSet);
                 /*
@@ -2216,58 +2289,46 @@ static void rhine_shutdown (struct pci_dev *pdev)
                 iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW);
         }
 
-        /* Hit power state D3 (sleep) */
-        if (!avoid_D3)
-                iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW);
+        spin_unlock(&rp->lock);
 
-        /* TODO: Check use of pci_enable_wake() */
+        if (system_state == SYSTEM_POWER_OFF && !avoid_D3) {
+                iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW);
 
+                pci_wake_from_d3(pdev, true);
+                pci_set_power_state(pdev, PCI_D3hot);
+        }
 }
 
-#ifdef CONFIG_PM
-static int rhine_suspend(struct pci_dev *pdev, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int rhine_suspend(struct device *device)
 {
+        struct pci_dev *pdev = to_pci_dev(device);
         struct net_device *dev = pci_get_drvdata(pdev);
         struct rhine_private *rp = netdev_priv(dev);
-        unsigned long flags;
 
         if (!netif_running(dev))
                 return 0;
 
+        rhine_task_disable(rp);
+        rhine_irq_disable(rp);
         napi_disable(&rp->napi);
 
         netif_device_detach(dev);
-        pci_save_state(pdev);
 
-        spin_lock_irqsave(&rp->lock, flags);
         rhine_shutdown(pdev);
-        spin_unlock_irqrestore(&rp->lock, flags);
 
-        free_irq(dev->irq, dev);
         return 0;
 }
 
-static int rhine_resume(struct pci_dev *pdev)
+static int rhine_resume(struct device *device)
 {
+        struct pci_dev *pdev = to_pci_dev(device);
         struct net_device *dev = pci_get_drvdata(pdev);
         struct rhine_private *rp = netdev_priv(dev);
-        unsigned long flags;
-        int ret;
 
         if (!netif_running(dev))
                 return 0;
 
-        if (request_irq(dev->irq, rhine_interrupt, IRQF_SHARED, dev->name, dev))
-                netdev_err(dev, "request_irq failed\n");
-
-        ret = pci_set_power_state(pdev, PCI_D0);
-        if (debug > 1)
-                netdev_info(dev, "Entering power state D0 %s (%d)\n",
-                            ret ? "failed" : "succeeded", ret);
-
-        pci_restore_state(pdev);
-
-        spin_lock_irqsave(&rp->lock, flags);
 #ifdef USE_MMIO
         enable_mmio(rp->pioaddr, rp->quirks);
 #endif
@@ -2276,25 +2337,32 @@ static int rhine_resume(struct pci_dev *pdev)
         free_rbufs(dev);
         alloc_tbufs(dev);
         alloc_rbufs(dev);
+        rhine_task_enable(rp);
+        spin_lock_bh(&rp->lock);
         init_registers(dev);
-        spin_unlock_irqrestore(&rp->lock, flags);
+        spin_unlock_bh(&rp->lock);
 
         netif_device_attach(dev);
 
         return 0;
 }
-#endif /* CONFIG_PM */
+
+static SIMPLE_DEV_PM_OPS(rhine_pm_ops, rhine_suspend, rhine_resume);
+#define RHINE_PM_OPS    (&rhine_pm_ops)
+
+#else
+
+#define RHINE_PM_OPS    NULL
+
+#endif /* !CONFIG_PM_SLEEP */
 
 static struct pci_driver rhine_driver = {
         .name           = DRV_NAME,
         .id_table       = rhine_pci_tbl,
         .probe          = rhine_init_one,
         .remove         = __devexit_p(rhine_remove_one),
-#ifdef CONFIG_PM
-        .suspend        = rhine_suspend,
-        .resume         = rhine_resume,
-#endif /* CONFIG_PM */
-        .shutdown =     rhine_shutdown,
+        .shutdown       = rhine_shutdown,
+        .driver.pm      = RHINE_PM_OPS,
 };
 
 static struct dmi_system_id __initdata rhine_dmi_table[] = {
diff --git a/drivers/net/ethernet/xscale/ixp4xx_eth.c b/drivers/net/ethernet/xscale/ixp4xx_eth.c
index f45c85a84261..72a854f05bb8 100644
--- a/drivers/net/ethernet/xscale/ixp4xx_eth.c
+++ b/drivers/net/ethernet/xscale/ixp4xx_eth.c
@@ -529,7 +529,7 @@ static int ixp4xx_mdio_register(void)
         mdio_bus->name = "IXP4xx MII Bus";
         mdio_bus->read = &ixp4xx_mdio_read;
         mdio_bus->write = &ixp4xx_mdio_write;
-        strcpy(mdio_bus->id, "0");
+        snprintf(mdio_bus->id, MII_BUS_ID_SIZE, "ixp4xx-eth-0");
 
         if ((err = mdiobus_register(mdio_bus)))
                 mdiobus_free(mdio_bus);
diff --git a/drivers/net/phy/dp83640.c b/drivers/net/phy/dp83640.c
index 9663e0ba6003..ba3c59147aa7 100644
--- a/drivers/net/phy/dp83640.c
+++ b/drivers/net/phy/dp83640.c
@@ -1159,7 +1159,7 @@ static void rx_timestamp_work(struct work_struct *work)
                         }
                 }
                 spin_unlock_irqrestore(&dp83640->rx_lock, flags);
-                netif_rx(skb);
+                netif_rx_ni(skb);
         }
 
         /* Clear out expired time stamps. */
diff --git a/drivers/net/phy/fixed.c b/drivers/net/phy/fixed.c
index 1fa4d73c3cca..633680d0828e 100644
--- a/drivers/net/phy/fixed.c
+++ b/drivers/net/phy/fixed.c
@@ -220,7 +220,7 @@ static int __init fixed_mdio_bus_init(void)
                 goto err_mdiobus_reg;
         }
 
-        snprintf(fmb->mii_bus->id, MII_BUS_ID_SIZE, "0");
+        snprintf(fmb->mii_bus->id, MII_BUS_ID_SIZE, "fixed-0");
         fmb->mii_bus->name = "Fixed MDIO Bus";
         fmb->mii_bus->priv = fmb;
         fmb->mii_bus->parent = &pdev->dev;
diff --git a/drivers/net/phy/mdio-gpio.c b/drivers/net/phy/mdio-gpio.c
index 89c5a3eccc12..50e8e5e74465 100644
--- a/drivers/net/phy/mdio-gpio.c
+++ b/drivers/net/phy/mdio-gpio.c
@@ -116,7 +116,7 @@ static struct mii_bus * __devinit mdio_gpio_bus_init(struct device *dev,
                 if (!new_bus->irq[i])
                         new_bus->irq[i] = PHY_POLL;
 
-        snprintf(new_bus->id, MII_BUS_ID_SIZE, "%x", bus_id);
+        snprintf(new_bus->id, MII_BUS_ID_SIZE, "gpio-%x", bus_id);
 
         if (gpio_request(bitbang->mdc, "mdc"))
                 goto out_free_bus;
diff --git a/drivers/net/phy/mdio-octeon.c b/drivers/net/phy/mdio-octeon.c
index bd12ba941be5..826d961f39f7 100644
--- a/drivers/net/phy/mdio-octeon.c
+++ b/drivers/net/phy/mdio-octeon.c
@@ -118,7 +118,8 @@ static int __devinit octeon_mdiobus_probe(struct platform_device *pdev)
         bus->mii_bus->priv = bus;
         bus->mii_bus->irq = bus->phy_irq;
         bus->mii_bus->name = "mdio-octeon";
-        snprintf(bus->mii_bus->id, MII_BUS_ID_SIZE, "%x", bus->unit);
+        snprintf(bus->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+                bus->mii_bus->name, bus->unit);
         bus->mii_bus->parent = &pdev->dev;
 
         bus->mii_bus->read = octeon_mdiobus_read;
diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
index 6c58da2b882c..88cc5db9affd 100644
--- a/drivers/net/phy/mdio_bus.c
+++ b/drivers/net/phy/mdio_bus.c
@@ -37,22 +37,36 @@
 #include <asm/uaccess.h>
 
 /**
- * mdiobus_alloc - allocate a mii_bus structure
+ * mdiobus_alloc_size - allocate a mii_bus structure
  *
  * Description: called by a bus driver to allocate an mii_bus
  * structure to fill in.
+ *
+ * 'size' is an an extra amount of memory to allocate for private storage.
+ * If non-zero, then bus->priv is points to that memory.
  */
-struct mii_bus *mdiobus_alloc(void)
+struct mii_bus *mdiobus_alloc_size(size_t size)
 {
         struct mii_bus *bus;
+        size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN);
+        size_t alloc_size;
+
+        /* If we alloc extra space, it should be aligned */
+        if (size)
+                alloc_size = aligned_size + size;
+        else
+                alloc_size = sizeof(*bus);
 
-        bus = kzalloc(sizeof(*bus), GFP_KERNEL);
-        if (bus != NULL)
+        bus = kzalloc(alloc_size, GFP_KERNEL);
+        if (bus) {
                 bus->state = MDIOBUS_ALLOCATED;
+                if (size)
+                        bus->priv = (void *)bus + aligned_size;
+        }
 
         return bus;
 }
-EXPORT_SYMBOL(mdiobus_alloc);
+EXPORT_SYMBOL(mdiobus_alloc_size);
 
 /**
  * mdiobus_release - mii_bus device release callback
diff --git a/drivers/net/ppp/pptp.c b/drivers/net/ppp/pptp.c
index c1c9293c2bbf..df884dde2a51 100644
--- a/drivers/net/ppp/pptp.c
+++ b/drivers/net/ppp/pptp.c
@@ -585,8 +585,8 @@ static int pptp_create(struct net *net, struct socket *sock)
         po = pppox_sk(sk);
         opt = &po->proto.pptp;
 
-        opt->seq_sent = 0; opt->seq_recv = 0;
-        opt->ack_recv = 0; opt->ack_sent = 0;
+        opt->seq_sent = 0; opt->seq_recv = 0xffffffff;
+        opt->ack_recv = 0; opt->ack_sent = 0xffffffff;
 
         error = 0;
 out:
diff --git a/drivers/net/usb/asix.c b/drivers/net/usb/asix.c
index d0937c4634c9..8e84f5bdd6ca 100644
--- a/drivers/net/usb/asix.c
+++ b/drivers/net/usb/asix.c
@@ -978,6 +978,7 @@ static int ax88772_link_reset(struct usbnet *dev)
 
 static int ax88772_reset(struct usbnet *dev)
 {
+        struct asix_data *data = (struct asix_data *)&dev->data;
         int ret, embd_phy;
         u16 rx_ctl;
 
@@ -1055,6 +1056,13 @@ static int ax88772_reset(struct usbnet *dev)
                 goto out;
         }
 
+        /* Rewrite MAC address */
+        memcpy(data->mac_addr, dev->net->dev_addr, ETH_ALEN);
+        ret = asix_write_cmd(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
+                                                        data->mac_addr);
+        if (ret < 0)
+                goto out;
+
         /* Set RX_CTL to default values with 2k buffer, and enable cactus */
         ret = asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL);
         if (ret < 0)
@@ -1320,6 +1328,13 @@ static int ax88178_reset(struct usbnet *dev)
         if (ret < 0)
                 return ret;
 
+        /* Rewrite MAC address */
+        memcpy(data->mac_addr, dev->net->dev_addr, ETH_ALEN);
+        ret = asix_write_cmd(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
+                                                        data->mac_addr);
+        if (ret < 0)
+                return ret;
+
         ret = asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL);
         if (ret < 0)
                 return ret;
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_phy.c b/drivers/net/wireless/ath/ath9k/ar9003_phy.c
index 2589b38b689a..2b0bfb8cca02 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_phy.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c
@@ -46,7 +46,7 @@ static const int m2ThreshExt_off = 127;
  * @chan:
  *
  * This is the function to change channel on single-chip devices, that is
- * all devices after ar9280.
+ * for AR9300 family of chipsets.
  *
  * This function takes the channel value in MHz and sets
  * hardware channel value. Assumes writes have been enabled to analog bus.
diff --git a/drivers/net/wireless/ath/ath9k/ath9k.h b/drivers/net/wireless/ath/ath9k/ath9k.h
index b30e9fc6433f..171ccf7c972f 100644
--- a/drivers/net/wireless/ath/ath9k/ath9k.h
+++ b/drivers/net/wireless/ath/ath9k/ath9k.h
@@ -679,7 +679,6 @@ void ath9k_deinit_device(struct ath_softc *sc);
 void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw);
 void ath9k_reload_chainmask_settings(struct ath_softc *sc);
 
-void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw);
 bool ath9k_uses_beacons(int type);
 
 #ifdef CONFIG_ATH9K_PCI
diff --git a/drivers/net/wireless/ath/ath9k/calib.c b/drivers/net/wireless/ath/ath9k/calib.c
index 172e33db7f4c..2f4b48e6fb03 100644
--- a/drivers/net/wireless/ath/ath9k/calib.c
+++ b/drivers/net/wireless/ath/ath9k/calib.c
@@ -400,6 +400,7 @@ bool ath9k_hw_getnf(struct ath_hw *ah, struct ath9k_channel *chan)
         ah->noise = ath9k_hw_getchan_noise(ah, chan);
         return true;
 }
+EXPORT_SYMBOL(ath9k_hw_getnf);
 
 void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah,
                                   struct ath9k_channel *chan)
diff --git a/drivers/net/wireless/ath/ath9k/calib.h b/drivers/net/wireless/ath/ath9k/calib.h
index 05b9dbf81850..3b33996d97df 100644
--- a/drivers/net/wireless/ath/ath9k/calib.h
+++ b/drivers/net/wireless/ath/ath9k/calib.h
@@ -19,7 +19,6 @@
 
 #include "hw.h"
 
-#define AR_PHY_CCA_FILTERWINDOW_LENGTH_INIT     3
 #define AR_PHY_CCA_FILTERWINDOW_LENGTH          5
 
 #define NUM_NF_READINGS       6
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index e267c92dbfb8..4a00806e2852 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -1629,7 +1629,6 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
 
         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
                 struct ieee80211_channel *curchan = hw->conf.channel;
-                struct ath9k_channel old_chan;
                 int pos = curchan->hw_value;
                 int old_pos = -1;
                 unsigned long flags;
@@ -1654,11 +1653,8 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
                  * Preserve the current channel values, before updating
                  * the same channel
                  */
-                if (old_pos == pos) {
-                        memcpy(&old_chan, &sc->sc_ah->channels[pos],
-                                sizeof(struct ath9k_channel));
-                        ah->curchan = &old_chan;
-                }
+                if (ah->curchan && (old_pos == pos))
+                        ath9k_hw_getnf(ah, ah->curchan);
 
                 ath9k_cmn_update_ichannel(&sc->sc_ah->channels[pos],
                                           curchan, conf->channel_type);
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c b/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c
index 5a002a21f108..f7eeee1dcdb6 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c
@@ -3119,8 +3119,10 @@ static int brcmf_sdbrcm_write_vars(struct brcmf_sdio *bus)
                 /* Verify NVRAM bytes */
                 brcmf_dbg(INFO, "Compare NVRAM dl & ul; varsize=%d\n", varsize);
                 nvram_ularray = kmalloc(varsize, GFP_ATOMIC);
-                if (!nvram_ularray)
+                if (!nvram_ularray) {
+                        kfree(vbuffer);
                         return -ENOMEM;
+                }
 
                 /* Upload image to verify downloaded contents. */
                 memset(nvram_ularray, 0xaa, varsize);
diff --git a/drivers/net/wireless/rtlwifi/rtl8192se/fw.c b/drivers/net/wireless/rtlwifi/rtl8192se/fw.c
index 6f91a148c222..3fda6b1dcf46 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192se/fw.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192se/fw.c
@@ -196,6 +196,8 @@ static bool _rtl92s_firmware_downloadcode(struct ieee80211_hw *hw,
                 /* Allocate skb buffer to contain firmware */
                 /* info and tx descriptor info. */
                 skb = dev_alloc_skb(frag_length);
+                if (!skb)
+                        return false;
                 skb_reserve(skb, extra_descoffset);
                 seg_ptr = (u8 *)skb_put(skb, (u32)(frag_length -
                                         extra_descoffset));
@@ -573,6 +575,8 @@ static bool _rtl92s_firmware_set_h2c_cmd(struct ieee80211_hw *hw, u8 h2c_cmd,
 
         len = _rtl92s_get_h2c_cmdlen(MAX_TRANSMIT_BUFFER_SIZE, 1, &cmd_len);
         skb = dev_alloc_skb(len);
+        if (!skb)
+                return false;
         cb_desc = (struct rtl_tcb_desc *)(skb->cb);
         cb_desc->queue_index = TXCMD_QUEUE;
         cb_desc->cmd_or_init = DESC_PACKET_TYPE_NORMAL;
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index d0b597b50398..0cb64f50cecd 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -3404,8 +3404,8 @@ static int __init parport_init_mode_setup(char *str)
 #endif
 
 #ifdef MODULE
-static const char *irq[PARPORT_PC_MAX_PORTS];
-static const char *dma[PARPORT_PC_MAX_PORTS];
+static char *irq[PARPORT_PC_MAX_PORTS];
+static char *dma[PARPORT_PC_MAX_PORTS];
 
 MODULE_PARM_DESC(io, "Base I/O address (SPP regs)");
 module_param_array(io, int, NULL, 0);
diff --git a/drivers/regulator/ab8500.c b/drivers/regulator/ab8500.c
index e91b8ddc2793..c9b92531ae60 100644
--- a/drivers/regulator/ab8500.c
+++ b/drivers/regulator/ab8500.c
@@ -16,8 +16,8 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
-#include <linux/mfd/ab8500.h>
 #include <linux/mfd/abx500.h>
+#include <linux/mfd/abx500/ab8500.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
 #include <linux/regulator/ab8500.h>
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
index a0a9810adf0b..4bcf9ca2818a 100644
--- a/drivers/rtc/rtc-ab8500.c
+++ b/drivers/rtc/rtc-ab8500.c
@@ -15,7 +15,7 @@
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
 #include <linux/mfd/abx500.h>
-#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500/ab8500.h>
 #include <linux/delay.h>
 
 #define AB8500_RTC_SOFF_STAT_REG        0x00
diff --git a/drivers/rtc/rtc-max8925.c b/drivers/rtc/rtc-max8925.c
index 4a5529346b47..2d71943bc436 100644
--- a/drivers/rtc/rtc-max8925.c
+++ b/drivers/rtc/rtc-max8925.c
@@ -261,6 +261,8 @@ static int __devinit max8925_rtc_probe(struct platform_device *pdev)
         /* XXX - isn't this redundant? */
         platform_set_drvdata(pdev, info);
 
+        device_init_wakeup(&pdev->dev, 1);
+
         info->rtc_dev = rtc_device_register("max8925-rtc", &pdev->dev,
                                         &max8925_rtc_ops, THIS_MODULE);
         ret = PTR_ERR(info->rtc_dev);
@@ -290,10 +292,34 @@ static int __devexit max8925_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
+static int max8925_rtc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+
+        if (device_may_wakeup(dev))
+                chip->wakeup_flag |= 1 << MAX8925_IRQ_RTC_ALARM0;
+        return 0;
+}
+static int max8925_rtc_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+
+        if (device_may_wakeup(dev))
+                chip->wakeup_flag &= ~(1 << MAX8925_IRQ_RTC_ALARM0);
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(max8925_rtc_pm_ops, max8925_rtc_suspend, max8925_rtc_resume);
+
 static struct platform_driver max8925_rtc_driver = {
         .driver         = {
                 .name   = "max8925-rtc",
                 .owner  = THIS_MODULE,
+                .pm     = &max8925_rtc_pm_ops,
         },
         .probe          = max8925_rtc_probe,
         .remove         = __devexit_p(max8925_rtc_remove),
diff --git a/drivers/usb/otg/ab8500-usb.c b/drivers/usb/otg/ab8500-usb.c
index 07ccea9ada40..74fe6e62e0f7 100644
--- a/drivers/usb/otg/ab8500-usb.c
+++ b/drivers/usb/otg/ab8500-usb.c
@@ -30,7 +30,7 @@
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/mfd/abx500.h>
-#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500/ab8500.h>
 
 #define AB8500_MAIN_WD_CTRL_REG 0x01
 #define AB8500_USB_LINE_STAT_REG 0x80
diff --git a/drivers/video/nvidia/nvidia.c b/drivers/video/nvidia/nvidia.c
index 081dc4745274..fe13ac567d54 100644
--- a/drivers/video/nvidia/nvidia.c
+++ b/drivers/video/nvidia/nvidia.c
@@ -81,7 +81,7 @@ static int vram __devinitdata = 0;
 static int bpp __devinitdata = 8;
 static int reverse_i2c __devinitdata;
 #ifdef CONFIG_MTRR
-static int nomtrr __devinitdata = 0;
+static bool nomtrr __devinitdata = false;
 #endif
 #ifdef CONFIG_PMAC_BACKLIGHT
 static int backlight __devinitdata = 1;
@@ -1509,7 +1509,7 @@ static int __devinit nvidiafb_setup(char *options)
                         backlight = simple_strtoul(this_opt+10, NULL, 0);
 #ifdef CONFIG_MTRR
                 } else if (!strncmp(this_opt, "nomtrr", 6)) {
-                        nomtrr = 1;
+                        nomtrr = true;
 #endif
                 } else if (!strncmp(this_opt, "fpdither:", 9)) {
                         fpdither = simple_strtol(this_opt+9, NULL, 0);
@@ -1599,7 +1599,7 @@ MODULE_PARM_DESC(bpp, "pixel width in bits"
 module_param(reverse_i2c, int, 0);
 MODULE_PARM_DESC(reverse_i2c, "reverse port assignment of the i2c bus");
 #ifdef CONFIG_MTRR
-module_param(nomtrr, bool, 0);
+module_param(nomtrr, bool, false);
 MODULE_PARM_DESC(nomtrr, "Disables MTRR support (0 or 1=disabled) "
                  "(default=0)");
 #endif