372 files changed, 11255 insertions, 7442 deletions

diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c
index 6512b20aeccd..ff9f6bd48301 100644
--- a/drivers/acpi/ac.c
+++ b/drivers/acpi/ac.c
@@ -61,7 +61,6 @@ static int acpi_ac_open_fs(struct inode *inode, struct file *file);
 
 static int acpi_ac_add(struct acpi_device *device);
 static int acpi_ac_remove(struct acpi_device *device, int type);
-static int acpi_ac_resume(struct acpi_device *device);
 static void acpi_ac_notify(struct acpi_device *device, u32 event);
 
 static const struct acpi_device_id ac_device_ids[] = {
@@ -70,6 +69,9 @@ static const struct acpi_device_id ac_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, ac_device_ids);
 
+static int acpi_ac_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_ac_pm, NULL, acpi_ac_resume);
+
 static struct acpi_driver acpi_ac_driver = {
         .name = "ac",
         .class = ACPI_AC_CLASS,
@@ -78,9 +80,9 @@ static struct acpi_driver acpi_ac_driver = {
         .ops = {
                 .add = acpi_ac_add,
                 .remove = acpi_ac_remove,
-                .resume = acpi_ac_resume,
                 .notify = acpi_ac_notify,
                 },
+        .drv.pm = &acpi_ac_pm,
 };
 
 struct acpi_ac {
@@ -309,13 +311,18 @@ static int acpi_ac_add(struct acpi_device *device)
         return result;
 }
 
-static int acpi_ac_resume(struct acpi_device *device)
+static int acpi_ac_resume(struct device *dev)
 {
         struct acpi_ac *ac;
         unsigned old_state;
-        if (!device || !acpi_driver_data(device))
+
+        if (!dev)
                 return -EINVAL;
-        ac = acpi_driver_data(device);
+
+        ac = acpi_driver_data(to_acpi_device(dev));
+        if (!ac)
+                return -EINVAL;
+
         old_state = ac->state;
         if (acpi_ac_get_state(ac))
                 return 0;
diff --git a/drivers/acpi/acpica/hwsleep.c b/drivers/acpi/acpica/hwsleep.c
index 0ed85cac3231..615996a36bed 100644
--- a/drivers/acpi/acpica/hwsleep.c
+++ b/drivers/acpi/acpica/hwsleep.c
@@ -95,18 +95,6 @@ acpi_status acpi_hw_legacy_sleep(u8 sleep_state, u8 flags)
                 return_ACPI_STATUS(status);
         }
 
-        if (sleep_state != ACPI_STATE_S5) {
-                /*
-                 * Disable BM arbitration. This feature is contained within an
-                 * optional register (PM2 Control), so ignore a BAD_ADDRESS
-                 * exception.
-                 */
-                status = acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1);
-                if (ACPI_FAILURE(status) && (status != AE_BAD_ADDRESS)) {
-                        return_ACPI_STATUS(status);
-                }
-        }
-
         /*
          * 1) Disable/Clear all GPEs
          * 2) Enable all wakeup GPEs
@@ -364,16 +352,6 @@ acpi_status acpi_hw_legacy_wake(u8 sleep_state, u8 flags)
                                     [ACPI_EVENT_POWER_BUTTON].
                                     status_register_id, ACPI_CLEAR_STATUS);
 
-        /*
-         * Enable BM arbitration. This feature is contained within an
-         * optional register (PM2 Control), so ignore a BAD_ADDRESS
-         * exception.
-         */
-        status = acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0);
-        if (ACPI_FAILURE(status) && (status != AE_BAD_ADDRESS)) {
-                return_ACPI_STATUS(status);
-        }
-
         acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WORKING);
         return_ACPI_STATUS(status);
 }
diff --git a/drivers/acpi/acpica/nspredef.c b/drivers/acpi/acpica/nspredef.c
index 23ce09686418..fe6626035495 100644
--- a/drivers/acpi/acpica/nspredef.c
+++ b/drivers/acpi/acpica/nspredef.c
@@ -638,7 +638,7 @@ acpi_ns_check_package(struct acpi_predefined_data *data,
                         /* Create the new outer package and populate it */
 
                         status =
-                            acpi_ns_wrap_with_package(data, *elements,
+                            acpi_ns_wrap_with_package(data, return_object,
                                                       return_object_ptr);
                         if (ACPI_FAILURE(status)) {
                                 return (status);
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 7dd3f9fb9f3f..023f9c8534d0 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -1044,17 +1044,24 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
 }
 
 /* this is needed to learn about changes made in suspended state */
-static int acpi_battery_resume(struct acpi_device *device)
+static int acpi_battery_resume(struct device *dev)
 {
         struct acpi_battery *battery;
-        if (!device)
+
+        if (!dev)
                 return -EINVAL;
-        battery = acpi_driver_data(device);
+
+        battery = acpi_driver_data(to_acpi_device(dev));
+        if (!battery)
+                return -EINVAL;
+
         battery->update_time = 0;
         acpi_battery_update(battery);
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
+
 static struct acpi_driver acpi_battery_driver = {
         .name = "battery",
         .class = ACPI_BATTERY_CLASS,
@@ -1062,10 +1069,10 @@ static struct acpi_driver acpi_battery_driver = {
         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
         .ops = {
                 .add = acpi_battery_add,
-                .resume = acpi_battery_resume,
                 .remove = acpi_battery_remove,
                 .notify = acpi_battery_notify,
                 },
+        .drv.pm = &acpi_battery_pm,
 };
 
 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index d27d072472f9..79d4c22f7a6d 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -76,19 +76,21 @@ MODULE_DEVICE_TABLE(acpi, button_device_ids);
 
 static int acpi_button_add(struct acpi_device *device);
 static int acpi_button_remove(struct acpi_device *device, int type);
-static int acpi_button_resume(struct acpi_device *device);
 static void acpi_button_notify(struct acpi_device *device, u32 event);
 
+static int acpi_button_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_button_pm, NULL, acpi_button_resume);
+
 static struct acpi_driver acpi_button_driver = {
         .name = "button",
         .class = ACPI_BUTTON_CLASS,
         .ids = button_device_ids,
         .ops = {
                 .add = acpi_button_add,
-                .resume = acpi_button_resume,
                 .remove = acpi_button_remove,
                 .notify = acpi_button_notify,
         },
+        .drv.pm = &acpi_button_pm,
 };
 
 struct acpi_button {
@@ -308,8 +310,9 @@ static void acpi_button_notify(struct acpi_device *device, u32 event)
         }
 }
 
-static int acpi_button_resume(struct acpi_device *device)
+static int acpi_button_resume(struct device *dev)
 {
+        struct acpi_device *device = to_acpi_device(dev);
         struct acpi_button *button = acpi_driver_data(device);
 
         if (button->type == ACPI_BUTTON_TYPE_LID)
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 0f0356ca1a9e..669d9ee80d16 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -46,8 +46,6 @@ MODULE_LICENSE("GPL");
 
 static int acpi_fan_add(struct acpi_device *device);
 static int acpi_fan_remove(struct acpi_device *device, int type);
-static int acpi_fan_suspend(struct acpi_device *device, pm_message_t state);
-static int acpi_fan_resume(struct acpi_device *device);
 
 static const struct acpi_device_id fan_device_ids[] = {
         {"PNP0C0B", 0},
@@ -55,6 +53,10 @@ static const struct acpi_device_id fan_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, fan_device_ids);
 
+static int acpi_fan_suspend(struct device *dev);
+static int acpi_fan_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_fan_pm, acpi_fan_suspend, acpi_fan_resume);
+
 static struct acpi_driver acpi_fan_driver = {
         .name = "fan",
         .class = ACPI_FAN_CLASS,
@@ -62,9 +64,8 @@ static struct acpi_driver acpi_fan_driver = {
         .ops = {
                 .add = acpi_fan_add,
                 .remove = acpi_fan_remove,
-                .suspend = acpi_fan_suspend,
-                .resume = acpi_fan_resume,
                 },
+        .drv.pm = &acpi_fan_pm,
 };
 
 /* thermal cooling device callbacks */
@@ -183,24 +184,24 @@ static int acpi_fan_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static int acpi_fan_suspend(struct acpi_device *device, pm_message_t state)
+static int acpi_fan_suspend(struct device *dev)
 {
-        if (!device)
+        if (!dev)
                 return -EINVAL;
 
-        acpi_bus_set_power(device->handle, ACPI_STATE_D0);
+        acpi_bus_set_power(to_acpi_device(dev)->handle, ACPI_STATE_D0);
 
         return AE_OK;
 }
 
-static int acpi_fan_resume(struct acpi_device *device)
+static int acpi_fan_resume(struct device *dev)
 {
         int result;
 
-        if (!device)
+        if (!dev)
                 return -EINVAL;
 
-        result = acpi_bus_update_power(device->handle, NULL);
+        result = acpi_bus_update_power(to_acpi_device(dev)->handle, NULL);
         if (result)
                 printk(KERN_ERR PREFIX "Error updating fan power state\n");
 
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index dd6d6a3c6780..894d45c6bc67 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -60,7 +60,6 @@ ACPI_MODULE_NAME("power");
 
 static int acpi_power_add(struct acpi_device *device);
 static int acpi_power_remove(struct acpi_device *device, int type);
-static int acpi_power_resume(struct acpi_device *device);
 
 static const struct acpi_device_id power_device_ids[] = {
         {ACPI_POWER_HID, 0},
@@ -68,6 +67,9 @@ static const struct acpi_device_id power_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, power_device_ids);
 
+static int acpi_power_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_power_pm, NULL, acpi_power_resume);
+
 static struct acpi_driver acpi_power_driver = {
         .name = "power",
         .class = ACPI_POWER_CLASS,
@@ -75,8 +77,8 @@ static struct acpi_driver acpi_power_driver = {
         .ops = {
                 .add = acpi_power_add,
                 .remove = acpi_power_remove,
-                .resume = acpi_power_resume,
                 },
+        .drv.pm = &acpi_power_pm,
 };
 
 /*
@@ -771,14 +773,16 @@ static int acpi_power_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static int acpi_power_resume(struct acpi_device *device)
+static int acpi_power_resume(struct device *dev)
 {
         int result = 0, state;
+        struct acpi_device *device;
         struct acpi_power_resource *resource;
 
-        if (!device)
+        if (!dev)
                 return -EINVAL;
 
+        device = to_acpi_device(dev);
         resource = acpi_driver_data(device);
         if (!resource)
                 return -EINVAL;
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index c850de4c9a14..eff722278ff5 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -189,10 +189,12 @@ int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
                  *     Processor (CPU3, 0x03, 0x00000410, 0x06) {}
                  * }
                  *
-                 * Ignores apic_id and always return 0 for CPU0's handle.
+                 * Ignores apic_id and always returns 0 for the processor
+                 * handle with acpi id 0 if nr_cpu_ids is 1.
+                 * This should be the case if SMP tables are not found.
                  * Return -1 for other CPU's handle.
                  */
-                if (acpi_id == 0)
+                if (nr_cpu_ids <= 1 && acpi_id == 0)
                         return acpi_id;
                 else
                         return apic_id;
diff --git a/drivers/acpi/processor_driver.c b/drivers/acpi/processor_driver.c
index 0734086537b8..7048b97853e0 100644
--- a/drivers/acpi/processor_driver.c
+++ b/drivers/acpi/processor_driver.c
@@ -93,6 +93,9 @@ static const struct acpi_device_id processor_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, processor_device_ids);
 
+static SIMPLE_DEV_PM_OPS(acpi_processor_pm,
+                         acpi_processor_suspend, acpi_processor_resume);
+
 static struct acpi_driver acpi_processor_driver = {
         .name = "processor",
         .class = ACPI_PROCESSOR_CLASS,
@@ -100,10 +103,9 @@ static struct acpi_driver acpi_processor_driver = {
         .ops = {
                 .add = acpi_processor_add,
                 .remove = acpi_processor_remove,
-                .suspend = acpi_processor_suspend,
-                .resume = acpi_processor_resume,
                 .notify = acpi_processor_notify,
                 },
+        .drv.pm = &acpi_processor_pm,
 };
 
 #define INSTALL_NOTIFY_HANDLER          1
@@ -427,18 +429,11 @@ static int acpi_cpu_soft_notify(struct notifier_block *nfb,
                  * Initialize missing things
                  */
                 if (pr->flags.need_hotplug_init) {
-                        struct cpuidle_driver *idle_driver =
-                                cpuidle_get_driver();
-
                         printk(KERN_INFO "Will online and init hotplugged "
                                "CPU: %d\n", pr->id);
                         WARN(acpi_processor_start(pr), "Failed to start CPU:"
                                 " %d\n", pr->id);
                         pr->flags.need_hotplug_init = 0;
-                        if (idle_driver && !strcmp(idle_driver->name,
-                                                   "intel_idle")) {
-                                intel_idle_cpu_init(pr->id);
-                        }
                 /* Normal CPU soft online event */
                 } else {
                         acpi_processor_ppc_has_changed(pr, 0);
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 47a8caa89dbe..e589c1985248 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -221,10 +221,6 @@ static void lapic_timer_state_broadcast(struct acpi_processor *pr,
 
 #endif
 
-/*
- * Suspend / resume control
- */
-static int acpi_idle_suspend;
 static u32 saved_bm_rld;
 
 static void acpi_idle_bm_rld_save(void)
@@ -241,23 +237,15 @@ static void acpi_idle_bm_rld_restore(void)
                 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
 }
 
-int acpi_processor_suspend(struct acpi_device * device, pm_message_t state)
+int acpi_processor_suspend(struct device *dev)
 {
-        if (acpi_idle_suspend == 1)
-                return 0;
-
         acpi_idle_bm_rld_save();
-        acpi_idle_suspend = 1;
         return 0;
 }
 
-int acpi_processor_resume(struct acpi_device * device)
+int acpi_processor_resume(struct device *dev)
 {
-        if (acpi_idle_suspend == 0)
-                return 0;
-
         acpi_idle_bm_rld_restore();
-        acpi_idle_suspend = 0;
         return 0;
 }
 
@@ -595,7 +583,6 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
          */
         cx->valid = 1;
 
-        cx->latency_ticks = cx->latency;
         /*
          * On older chipsets, BM_RLD needs to be set
          * in order for Bus Master activity to wake the
@@ -628,7 +615,6 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)
                         if (!cx->address)
                                 break;
                         cx->valid = 1; 
-                        cx->latency_ticks = cx->latency; /* Normalize latency */
                         break;
 
                 case ACPI_STATE_C3:
@@ -763,11 +749,6 @@ static int acpi_idle_enter_c1(struct cpuidle_device *dev,
 
         local_irq_disable();
 
-        if (acpi_idle_suspend) {
-                local_irq_enable();
-                cpu_relax();
-                return -EBUSY;
-        }
 
         lapic_timer_state_broadcast(pr, cx, 1);
         kt1 = ktime_get_real();
@@ -779,7 +760,6 @@ static int acpi_idle_enter_c1(struct cpuidle_device *dev,
         dev->last_residency = (int)idle_time;
 
         local_irq_enable();
-        cx->usage++;
         lapic_timer_state_broadcast(pr, cx, 0);
 
         return index;
@@ -838,11 +818,6 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
 
         local_irq_disable();
 
-        if (acpi_idle_suspend) {
-                local_irq_enable();
-                cpu_relax();
-                return -EBUSY;
-        }
 
         if (cx->entry_method != ACPI_CSTATE_FFH) {
                 current_thread_info()->status &= ~TS_POLLING;
@@ -887,10 +862,7 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
         if (cx->entry_method != ACPI_CSTATE_FFH)
                 current_thread_info()->status |= TS_POLLING;
 
-        cx->usage++;
-
         lapic_timer_state_broadcast(pr, cx, 0);
-        cx->time += idle_time;
         return index;
 }
 
@@ -928,8 +900,7 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
                                                 drv, drv->safe_state_index);
                 } else {
                         local_irq_disable();
-                        if (!acpi_idle_suspend)
-                                acpi_safe_halt();
+                        acpi_safe_halt();
                         local_irq_enable();
                         return -EBUSY;
                 }
@@ -937,11 +908,6 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
 
         local_irq_disable();
 
-        if (acpi_idle_suspend) {
-                local_irq_enable();
-                cpu_relax();
-                return -EBUSY;
-        }
 
         if (cx->entry_method != ACPI_CSTATE_FFH) {
                 current_thread_info()->status &= ~TS_POLLING;
@@ -1014,10 +980,7 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
         if (cx->entry_method != ACPI_CSTATE_FFH)
                 current_thread_info()->status |= TS_POLLING;
 
-        cx->usage++;
-
         lapic_timer_state_broadcast(pr, cx, 0);
-        cx->time += idle_time;
         return index;
 }
 
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index 6e36d0c0057c..c0b9aa5faf4c 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -988,16 +988,18 @@ static void acpi_sbs_rmdirs(void)
 #endif
 }
 
-static int acpi_sbs_resume(struct acpi_device *device)
+static int acpi_sbs_resume(struct device *dev)
 {
         struct acpi_sbs *sbs;
-        if (!device)
+        if (!dev)
                 return -EINVAL;
-        sbs = device->driver_data;
+        sbs = to_acpi_device(dev)->driver_data;
         acpi_sbs_callback(sbs);
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(acpi_sbs_pm, NULL, acpi_sbs_resume);
+
 static struct acpi_driver acpi_sbs_driver = {
         .name = "sbs",
         .class = ACPI_SBS_CLASS,
@@ -1005,8 +1007,8 @@ static struct acpi_driver acpi_sbs_driver = {
         .ops = {
                 .add = acpi_sbs_add,
                 .remove = acpi_sbs_remove,
-                .resume = acpi_sbs_resume,
                 },
+        .drv.pm = &acpi_sbs_pm,
 };
 
 static int __init acpi_sbs_init(void)
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index c8a1f3b68110..fdda49336560 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -290,26 +290,6 @@ static void acpi_device_release(struct device *dev)
         kfree(acpi_dev);
 }
 
-static int acpi_device_suspend(struct device *dev, pm_message_t state)
-{
-        struct acpi_device *acpi_dev = to_acpi_device(dev);
-        struct acpi_driver *acpi_drv = acpi_dev->driver;
-
-        if (acpi_drv && acpi_drv->ops.suspend)
-                return acpi_drv->ops.suspend(acpi_dev, state);
-        return 0;
-}
-
-static int acpi_device_resume(struct device *dev)
-{
-        struct acpi_device *acpi_dev = to_acpi_device(dev);
-        struct acpi_driver *acpi_drv = acpi_dev->driver;
-
-        if (acpi_drv && acpi_drv->ops.resume)
-                return acpi_drv->ops.resume(acpi_dev);
-        return 0;
-}
-
 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
 {
         struct acpi_device *acpi_dev = to_acpi_device(dev);
@@ -441,8 +421,6 @@ static int acpi_device_remove(struct device * dev)
 
 struct bus_type acpi_bus_type = {
         .name           = "acpi",
-        .suspend        = acpi_device_suspend,
-        .resume         = acpi_device_resume,
         .match          = acpi_bus_match,
         .probe          = acpi_device_probe,
         .remove         = acpi_device_remove,
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 7dbebea1ec31..21dd4c268aef 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -98,7 +98,6 @@ MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
 
 static int acpi_thermal_add(struct acpi_device *device);
 static int acpi_thermal_remove(struct acpi_device *device, int type);
-static int acpi_thermal_resume(struct acpi_device *device);
 static void acpi_thermal_notify(struct acpi_device *device, u32 event);
 
 static const struct acpi_device_id  thermal_device_ids[] = {
@@ -107,6 +106,9 @@ static const struct acpi_device_id  thermal_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
 
+static int acpi_thermal_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_thermal_pm, NULL, acpi_thermal_resume);
+
 static struct acpi_driver acpi_thermal_driver = {
         .name = "thermal",
         .class = ACPI_THERMAL_CLASS,
@@ -114,9 +116,9 @@ static struct acpi_driver acpi_thermal_driver = {
         .ops = {
                 .add = acpi_thermal_add,
                 .remove = acpi_thermal_remove,
-                .resume = acpi_thermal_resume,
                 .notify = acpi_thermal_notify,
                 },
+        .drv.pm = &acpi_thermal_pm,
 };
 
 struct acpi_thermal_state {
@@ -1041,16 +1043,17 @@ static int acpi_thermal_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static int acpi_thermal_resume(struct acpi_device *device)
+static int acpi_thermal_resume(struct device *dev)
 {
-        struct acpi_thermal *tz = NULL;
+        struct acpi_thermal *tz;
         int i, j, power_state, result;
 
-
-        if (!device || !acpi_driver_data(device))
+        if (!dev)
                 return -EINVAL;
 
-        tz = acpi_driver_data(device);
+        tz = acpi_driver_data(to_acpi_device(dev));
+        if (!tz)
+                return -EINVAL;
 
         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
                 if (!(&tz->trips.active[i]))
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index dcb8a6e48692..4b01ab3d2c24 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -24,6 +24,7 @@
 #include <linux/wait.h>
 #include <linux/async.h>
 #include <linux/pm_runtime.h>
+#include <scsi/scsi_scan.h>
 
 #include "base.h"
 #include "power/power.h"
@@ -332,6 +333,7 @@ void wait_for_device_probe(void)
         /* wait for the known devices to complete their probing */
         wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
         async_synchronize_full();
+        scsi_complete_async_scans();
 }
 EXPORT_SYMBOL_GPL(wait_for_device_probe);
 
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 765c3a28077a..d91a3a0b2325 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -227,33 +227,24 @@ static int handle_create(const char *nodename, umode_t mode, struct device *dev)
 
 static int dev_rmdir(const char *name)
 {
-        struct nameidata nd;
+        struct path parent;
         struct dentry *dentry;
         int err;
 
-        err = kern_path_parent(name, &nd);
-        if (err)
-                return err;
-
-        mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
-        dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
-        if (!IS_ERR(dentry)) {
-                if (dentry->d_inode) {
-                        if (dentry->d_inode->i_private == &thread)
-                                err = vfs_rmdir(nd.path.dentry->d_inode,
-                                                dentry);
-                        else
-                                err = -EPERM;
-                } else {
-                        err = -ENOENT;
-                }
-                dput(dentry);
+        dentry = kern_path_locked(name, &parent);
+        if (IS_ERR(dentry))
+                return PTR_ERR(dentry);
+        if (dentry->d_inode) {
+                if (dentry->d_inode->i_private == &thread)
+                        err = vfs_rmdir(parent.dentry->d_inode, dentry);
+                else
+                        err = -EPERM;
         } else {
-                err = PTR_ERR(dentry);
+                err = -ENOENT;
         }
-
-        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
-        path_put(&nd.path);
+        dput(dentry);
+        mutex_unlock(&parent.dentry->d_inode->i_mutex);
+        path_put(&parent);
         return err;
 }
 
@@ -305,50 +296,43 @@ static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *sta
 
 static int handle_remove(const char *nodename, struct device *dev)
 {
-        struct nameidata nd;
+        struct path parent;
         struct dentry *dentry;
-        struct kstat stat;
         int deleted = 1;
         int err;
 
-        err = kern_path_parent(nodename, &nd);
-        if (err)
-                return err;
+        dentry = kern_path_locked(nodename, &parent);
+        if (IS_ERR(dentry))
+                return PTR_ERR(dentry);
 
-        mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
-        dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
-        if (!IS_ERR(dentry)) {
-                if (dentry->d_inode) {
-                        err = vfs_getattr(nd.path.mnt, dentry, &stat);
-                        if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
-                                struct iattr newattrs;
-                                /*
-                                 * before unlinking this node, reset permissions
-                                 * of possible references like hardlinks
-                                 */
-                                newattrs.ia_uid = 0;
-                                newattrs.ia_gid = 0;
-                                newattrs.ia_mode = stat.mode & ~0777;
-                                newattrs.ia_valid =
-                                        ATTR_UID|ATTR_GID|ATTR_MODE;
-                                mutex_lock(&dentry->d_inode->i_mutex);
-                                notify_change(dentry, &newattrs);
-                                mutex_unlock(&dentry->d_inode->i_mutex);
-                                err = vfs_unlink(nd.path.dentry->d_inode,
-                                                 dentry);
-                                if (!err || err == -ENOENT)
-                                        deleted = 1;
-                        }
-                } else {
-                        err = -ENOENT;
+        if (dentry->d_inode) {
+                struct kstat stat;
+                err = vfs_getattr(parent.mnt, dentry, &stat);
+                if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
+                        struct iattr newattrs;
+                        /*
+                         * before unlinking this node, reset permissions
+                         * of possible references like hardlinks
+                         */
+                        newattrs.ia_uid = 0;
+                        newattrs.ia_gid = 0;
+                        newattrs.ia_mode = stat.mode & ~0777;
+                        newattrs.ia_valid =
+                                ATTR_UID|ATTR_GID|ATTR_MODE;
+                        mutex_lock(&dentry->d_inode->i_mutex);
+                        notify_change(dentry, &newattrs);
+                        mutex_unlock(&dentry->d_inode->i_mutex);
+                        err = vfs_unlink(parent.dentry->d_inode, dentry);
+                        if (!err || err == -ENOENT)
+                                deleted = 1;
                 }
-                dput(dentry);
         } else {
-                err = PTR_ERR(dentry);
+                err = -ENOENT;
         }
-        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
+        dput(dentry);
+        mutex_unlock(&parent.dentry->d_inode->i_mutex);
 
-        path_put(&nd.path);
+        path_put(&parent);
         if (deleted && strchr(nodename, '/'))
                 delete_path(nodename);
         return err;
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index 83aa694a8efe..ba3487c9835b 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -75,19 +75,6 @@ static int genpd_start_dev(struct generic_pm_domain *genpd, struct device *dev)
                                         start_latency_ns, "start");
 }
 
-static int genpd_save_dev(struct generic_pm_domain *genpd, struct device *dev)
-{
-        return GENPD_DEV_TIMED_CALLBACK(genpd, int, save_state, dev,
-                                        save_state_latency_ns, "state save");
-}
-
-static int genpd_restore_dev(struct generic_pm_domain *genpd, struct device *dev)
-{
-        return GENPD_DEV_TIMED_CALLBACK(genpd, int, restore_state, dev,
-                                        restore_state_latency_ns,
-                                        "state restore");
-}
-
 static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd)
 {
         bool ret = false;
@@ -139,6 +126,19 @@ static void genpd_set_active(struct generic_pm_domain *genpd)
                 genpd->status = GPD_STATE_ACTIVE;
 }
 
+static void genpd_recalc_cpu_exit_latency(struct generic_pm_domain *genpd)
+{
+        s64 usecs64;
+
+        if (!genpd->cpu_data)
+                return;
+
+        usecs64 = genpd->power_on_latency_ns;
+        do_div(usecs64, NSEC_PER_USEC);
+        usecs64 += genpd->cpu_data->saved_exit_latency;
+        genpd->cpu_data->idle_state->exit_latency = usecs64;
+}
+
 /**
  * __pm_genpd_poweron - Restore power to a given PM domain and its masters.
  * @genpd: PM domain to power up.
@@ -146,7 +146,7 @@ static void genpd_set_active(struct generic_pm_domain *genpd)
  * Restore power to @genpd and all of its masters so that it is possible to
  * resume a device belonging to it.
  */
-int __pm_genpd_poweron(struct generic_pm_domain *genpd)
+static int __pm_genpd_poweron(struct generic_pm_domain *genpd)
         __releases(&genpd->lock) __acquires(&genpd->lock)
 {
         struct gpd_link *link;
@@ -176,6 +176,13 @@ int __pm_genpd_poweron(struct generic_pm_domain *genpd)
                 return 0;
         }
 
+        if (genpd->cpu_data) {
+                cpuidle_pause_and_lock();
+                genpd->cpu_data->idle_state->disabled = true;
+                cpuidle_resume_and_unlock();
+                goto out;
+        }
+
         /*
          * The list is guaranteed not to change while the loop below is being
          * executed, unless one of the masters' .power_on() callbacks fiddles
@@ -215,6 +222,7 @@ int __pm_genpd_poweron(struct generic_pm_domain *genpd)
                 if (elapsed_ns > genpd->power_on_latency_ns) {
                         genpd->power_on_latency_ns = elapsed_ns;
                         genpd->max_off_time_changed = true;
+                        genpd_recalc_cpu_exit_latency(genpd);
                         if (genpd->name)
                                 pr_warning("%s: Power-on latency exceeded, "
                                         "new value %lld ns\n", genpd->name,
@@ -222,6 +230,7 @@ int __pm_genpd_poweron(struct generic_pm_domain *genpd)
                 }
         }
 
+ out:
         genpd_set_active(genpd);
 
         return 0;
@@ -251,6 +260,19 @@ int pm_genpd_poweron(struct generic_pm_domain *genpd)
 
 #ifdef CONFIG_PM_RUNTIME
 
+static int genpd_save_dev(struct generic_pm_domain *genpd, struct device *dev)
+{
+        return GENPD_DEV_TIMED_CALLBACK(genpd, int, save_state, dev,
+                                        save_state_latency_ns, "state save");
+}
+
+static int genpd_restore_dev(struct generic_pm_domain *genpd, struct device *dev)
+{
+        return GENPD_DEV_TIMED_CALLBACK(genpd, int, restore_state, dev,
+                                        restore_state_latency_ns,
+                                        "state restore");
+}
+
 static int genpd_dev_pm_qos_notifier(struct notifier_block *nb,
                                      unsigned long val, void *ptr)
 {
@@ -275,7 +297,7 @@ static int genpd_dev_pm_qos_notifier(struct notifier_block *nb,
 
                 pdd = dev->power.subsys_data ?
                                 dev->power.subsys_data->domain_data : NULL;
-                if (pdd) {
+                if (pdd && pdd->dev) {
                         to_gpd_data(pdd)->td.constraint_changed = true;
                         genpd = dev_to_genpd(dev);
                 } else {
@@ -339,19 +361,16 @@ static void __pm_genpd_restore_device(struct pm_domain_data *pdd,
 {
         struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
         struct device *dev = pdd->dev;
+        bool need_restore = gpd_data->need_restore;
 
-        if (!gpd_data->need_restore)
-                return;
-
+        gpd_data->need_restore = false;
         mutex_unlock(&genpd->lock);
 
         genpd_start_dev(genpd, dev);
-        genpd_restore_dev(genpd, dev);
-        genpd_stop_dev(genpd, dev);
+        if (need_restore)
+                genpd_restore_dev(genpd, dev);
 
         mutex_lock(&genpd->lock);
-
-        gpd_data->need_restore = false;
 }
 
 /**
@@ -458,6 +477,21 @@ static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
                 }
         }
 
+        if (genpd->cpu_data) {
+                /*
+                 * If cpu_data is set, cpuidle should turn the domain off when
+                 * the CPU in it is idle.  In that case we don't decrement the
+                 * subdomain counts of the master domains, so that power is not
+                 * removed from the current domain prematurely as a result of
+                 * cutting off the masters' power.
+                 */
+                genpd->status = GPD_STATE_POWER_OFF;
+                cpuidle_pause_and_lock();
+                genpd->cpu_data->idle_state->disabled = false;
+                cpuidle_resume_and_unlock();
+                goto out;
+        }
+
         if (genpd->power_off) {
                 ktime_t time_start;
                 s64 elapsed_ns;
@@ -595,7 +629,7 @@ static int pm_genpd_runtime_resume(struct device *dev)
 
         /* If power.irq_safe, the PM domain is never powered off. */
         if (dev->power.irq_safe)
-                goto out;
+                return genpd_start_dev(genpd, dev);
 
         mutex_lock(&genpd->lock);
         ret = __pm_genpd_poweron(genpd);
@@ -628,9 +662,6 @@ static int pm_genpd_runtime_resume(struct device *dev)
         wake_up_all(&genpd->status_wait_queue);
         mutex_unlock(&genpd->lock);
 
- out:
-        genpd_start_dev(genpd, dev);
-
         return 0;
 }
 
@@ -1235,6 +1266,27 @@ static void pm_genpd_complete(struct device *dev)
 
 #endif /* CONFIG_PM_SLEEP */
 
+static struct generic_pm_domain_data *__pm_genpd_alloc_dev_data(struct device *dev)
+{
+        struct generic_pm_domain_data *gpd_data;
+
+        gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL);
+        if (!gpd_data)
+                return NULL;
+
+        mutex_init(&gpd_data->lock);
+        gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier;
+        dev_pm_qos_add_notifier(dev, &gpd_data->nb);
+        return gpd_data;
+}
+
+static void __pm_genpd_free_dev_data(struct device *dev,
+                                     struct generic_pm_domain_data *gpd_data)
+{
+        dev_pm_qos_remove_notifier(dev, &gpd_data->nb);
+        kfree(gpd_data);
+}
+
 /**
  * __pm_genpd_add_device - Add a device to an I/O PM domain.
  * @genpd: PM domain to add the device to.
@@ -1244,7 +1296,7 @@ static void pm_genpd_complete(struct device *dev)
 int __pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
                           struct gpd_timing_data *td)
 {
-        struct generic_pm_domain_data *gpd_data;
+        struct generic_pm_domain_data *gpd_data_new, *gpd_data = NULL;
         struct pm_domain_data *pdd;
         int ret = 0;
 
@@ -1253,14 +1305,10 @@ int __pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
         if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
                 return -EINVAL;
 
-        gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL);
-        if (!gpd_data)
+        gpd_data_new = __pm_genpd_alloc_dev_data(dev);
+        if (!gpd_data_new)
                 return -ENOMEM;
 
-        mutex_init(&gpd_data->lock);
-        gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier;
-        dev_pm_qos_add_notifier(dev, &gpd_data->nb);
-
         genpd_acquire_lock(genpd);
 
         if (genpd->prepared_count > 0) {
@@ -1274,35 +1322,42 @@ int __pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
                         goto out;
                 }
 
+        ret = dev_pm_get_subsys_data(dev);
+        if (ret)
+                goto out;
+
         genpd->device_count++;
         genpd->max_off_time_changed = true;
 
-        dev_pm_get_subsys_data(dev);
-
-        mutex_lock(&gpd_data->lock);
         spin_lock_irq(&dev->power.lock);
+
         dev->pm_domain = &genpd->domain;
-        dev->power.subsys_data->domain_data = &gpd_data->base;
-        gpd_data->base.dev = dev;
-        list_add_tail(&gpd_data->base.list_node, &genpd->dev_list);
-        gpd_data->need_restore = genpd->status == GPD_STATE_POWER_OFF;
+        if (dev->power.subsys_data->domain_data) {
+                gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
+        } else {
+                gpd_data = gpd_data_new;
+                dev->power.subsys_data->domain_data = &gpd_data->base;
+        }
+        gpd_data->refcount++;
         if (td)
                 gpd_data->td = *td;
 
+        spin_unlock_irq(&dev->power.lock);
+
+        mutex_lock(&gpd_data->lock);
+        gpd_data->base.dev = dev;
+        list_add_tail(&gpd_data->base.list_node, &genpd->dev_list);
+        gpd_data->need_restore = genpd->status == GPD_STATE_POWER_OFF;
         gpd_data->td.constraint_changed = true;
         gpd_data->td.effective_constraint_ns = -1;
-        spin_unlock_irq(&dev->power.lock);
         mutex_unlock(&gpd_data->lock);
 
-        genpd_release_lock(genpd);
-
-        return 0;
-
  out:
         genpd_release_lock(genpd);
 
-        dev_pm_qos_remove_notifier(dev, &gpd_data->nb);
-        kfree(gpd_data);
+        if (gpd_data != gpd_data_new)
+                __pm_genpd_free_dev_data(dev, gpd_data_new);
+
         return ret;
 }
 
@@ -1348,6 +1403,7 @@ int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 {
         struct generic_pm_domain_data *gpd_data;
         struct pm_domain_data *pdd;
+        bool remove = false;
         int ret = 0;
 
         dev_dbg(dev, "%s()\n", __func__);
@@ -1368,22 +1424,28 @@ int pm_genpd_remove_device(struct generic_pm_domain *genpd,
         genpd->max_off_time_changed = true;
 
         spin_lock_irq(&dev->power.lock);
+
         dev->pm_domain = NULL;
         pdd = dev->power.subsys_data->domain_data;
         list_del_init(&pdd->list_node);
-        dev->power.subsys_data->domain_data = NULL;
+        gpd_data = to_gpd_data(pdd);
+        if (--gpd_data->refcount == 0) {
+                dev->power.subsys_data->domain_data = NULL;
+                remove = true;
+        }
+
         spin_unlock_irq(&dev->power.lock);
 
-        gpd_data = to_gpd_data(pdd);
         mutex_lock(&gpd_data->lock);
         pdd->dev = NULL;
         mutex_unlock(&gpd_data->lock);
 
         genpd_release_lock(genpd);
 
-        dev_pm_qos_remove_notifier(dev, &gpd_data->nb);
-        kfree(gpd_data);
         dev_pm_put_subsys_data(dev);
+        if (remove)
+                __pm_genpd_free_dev_data(dev, gpd_data);
+
         return 0;
 
  out:
@@ -1541,33 +1603,52 @@ int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
  * @dev: Device to add the callbacks to.
  * @ops: Set of callbacks to add.
  * @td: Timing data to add to the device along with the callbacks (optional).
+ *
+ * Every call to this routine should be balanced with a call to
+ * __pm_genpd_remove_callbacks() and they must not be nested.
  */
 int pm_genpd_add_callbacks(struct device *dev, struct gpd_dev_ops *ops,
                            struct gpd_timing_data *td)
 {
-        struct pm_domain_data *pdd;
+        struct generic_pm_domain_data *gpd_data_new, *gpd_data = NULL;
         int ret = 0;
 
-        if (!(dev && dev->power.subsys_data && ops))
+        if (!(dev && ops))
                 return -EINVAL;
 
+        gpd_data_new = __pm_genpd_alloc_dev_data(dev);
+        if (!gpd_data_new)
+                return -ENOMEM;
+
         pm_runtime_disable(dev);
         device_pm_lock();
 
-        pdd = dev->power.subsys_data->domain_data;
-        if (pdd) {
-                struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
+        ret = dev_pm_get_subsys_data(dev);
+        if (ret)
+                goto out;
 
-                gpd_data->ops = *ops;
-                if (td)
-                        gpd_data->td = *td;
+        spin_lock_irq(&dev->power.lock);
+
+        if (dev->power.subsys_data->domain_data) {
+                gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
         } else {
-                ret = -EINVAL;
+                gpd_data = gpd_data_new;
+                dev->power.subsys_data->domain_data = &gpd_data->base;
         }
+        gpd_data->refcount++;
+        gpd_data->ops = *ops;
+        if (td)
+                gpd_data->td = *td;
+
+        spin_unlock_irq(&dev->power.lock);
 
+ out:
         device_pm_unlock();
         pm_runtime_enable(dev);
 
+        if (gpd_data != gpd_data_new)
+                __pm_genpd_free_dev_data(dev, gpd_data_new);
+
         return ret;
 }
 EXPORT_SYMBOL_GPL(pm_genpd_add_callbacks);
@@ -1576,10 +1657,13 @@ EXPORT_SYMBOL_GPL(pm_genpd_add_callbacks);
  * __pm_genpd_remove_callbacks - Remove PM domain callbacks from a given device.
  * @dev: Device to remove the callbacks from.
  * @clear_td: If set, clear the device's timing data too.
+ *
+ * This routine can only be called after pm_genpd_add_callbacks().
  */
 int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
 {
-        struct pm_domain_data *pdd;
+        struct generic_pm_domain_data *gpd_data = NULL;
+        bool remove = false;
         int ret = 0;
 
         if (!(dev && dev->power.subsys_data))
@@ -1588,24 +1672,118 @@ int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
         pm_runtime_disable(dev);
         device_pm_lock();
 
-        pdd = dev->power.subsys_data->domain_data;
-        if (pdd) {
-                struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
+        spin_lock_irq(&dev->power.lock);
 
-                gpd_data->ops = (struct gpd_dev_ops){ 0 };
+        if (dev->power.subsys_data->domain_data) {
+                gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
+                gpd_data->ops = (struct gpd_dev_ops){ NULL };
                 if (clear_td)
                         gpd_data->td = (struct gpd_timing_data){ 0 };
+
+                if (--gpd_data->refcount == 0) {
+                        dev->power.subsys_data->domain_data = NULL;
+                        remove = true;
+                }
         } else {
                 ret = -EINVAL;
         }
 
+        spin_unlock_irq(&dev->power.lock);
+
         device_pm_unlock();
         pm_runtime_enable(dev);
 
-        return ret;
+        if (ret)
+                return ret;
+
+        dev_pm_put_subsys_data(dev);
+        if (remove)
+                __pm_genpd_free_dev_data(dev, gpd_data);
+
+        return 0;
 }
 EXPORT_SYMBOL_GPL(__pm_genpd_remove_callbacks);
 
+int genpd_attach_cpuidle(struct generic_pm_domain *genpd, int state)
+{
+        struct cpuidle_driver *cpuidle_drv;
+        struct gpd_cpu_data *cpu_data;
+        struct cpuidle_state *idle_state;
+        int ret = 0;
+
+        if (IS_ERR_OR_NULL(genpd) || state < 0)
+                return -EINVAL;
+
+        genpd_acquire_lock(genpd);
+
+        if (genpd->cpu_data) {
+                ret = -EEXIST;
+                goto out;
+        }
+        cpu_data = kzalloc(sizeof(*cpu_data), GFP_KERNEL);
+        if (!cpu_data) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        cpuidle_drv = cpuidle_driver_ref();
+        if (!cpuidle_drv) {
+                ret = -ENODEV;
+                goto out;
+        }
+        if (cpuidle_drv->state_count <= state) {
+                ret = -EINVAL;
+                goto err;
+        }
+        idle_state = &cpuidle_drv->states[state];
+        if (!idle_state->disabled) {
+                ret = -EAGAIN;
+                goto err;
+        }
+        cpu_data->idle_state = idle_state;
+        cpu_data->saved_exit_latency = idle_state->exit_latency;
+        genpd->cpu_data = cpu_data;
+        genpd_recalc_cpu_exit_latency(genpd);
+
+ out:
+        genpd_release_lock(genpd);
+        return ret;
+
+ err:
+        cpuidle_driver_unref();
+        goto out;
+}
+
+int genpd_detach_cpuidle(struct generic_pm_domain *genpd)
+{
+        struct gpd_cpu_data *cpu_data;
+        struct cpuidle_state *idle_state;
+        int ret = 0;
+
+        if (IS_ERR_OR_NULL(genpd))
+                return -EINVAL;
+
+        genpd_acquire_lock(genpd);
+
+        cpu_data = genpd->cpu_data;
+        if (!cpu_data) {
+                ret = -ENODEV;
+                goto out;
+        }
+        idle_state = cpu_data->idle_state;
+        if (!idle_state->disabled) {
+                ret = -EAGAIN;
+                goto out;
+        }
+        idle_state->exit_latency = cpu_data->saved_exit_latency;
+        cpuidle_driver_unref();
+        genpd->cpu_data = NULL;
+        kfree(cpu_data);
+
+ out:
+        genpd_release_lock(genpd);
+        return ret;
+}
+
 /* Default device callbacks for generic PM domains. */
 
 /**
@@ -1615,16 +1793,24 @@ EXPORT_SYMBOL_GPL(__pm_genpd_remove_callbacks);
 static int pm_genpd_default_save_state(struct device *dev)
 {
         int (*cb)(struct device *__dev);
-        struct device_driver *drv = dev->driver;
 
         cb = dev_gpd_data(dev)->ops.save_state;
         if (cb)
                 return cb(dev);
 
-        if (drv && drv->pm && drv->pm->runtime_suspend)
-                return drv->pm->runtime_suspend(dev);
+        if (dev->type && dev->type->pm)
+                cb = dev->type->pm->runtime_suspend;
+        else if (dev->class && dev->class->pm)
+                cb = dev->class->pm->runtime_suspend;
+        else if (dev->bus && dev->bus->pm)
+                cb = dev->bus->pm->runtime_suspend;
+        else
+                cb = NULL;
 
-        return 0;
+        if (!cb && dev->driver && dev->driver->pm)
+                cb = dev->driver->pm->runtime_suspend;
+
+        return cb ? cb(dev) : 0;
 }
 
 /**
@@ -1634,16 +1820,24 @@ static int pm_genpd_default_save_state(struct device *dev)
 static int pm_genpd_default_restore_state(struct device *dev)
 {
         int (*cb)(struct device *__dev);
-        struct device_driver *drv = dev->driver;
 
         cb = dev_gpd_data(dev)->ops.restore_state;
         if (cb)
                 return cb(dev);
 
-        if (drv && drv->pm && drv->pm->runtime_resume)
-                return drv->pm->runtime_resume(dev);
+        if (dev->type && dev->type->pm)
+                cb = dev->type->pm->runtime_resume;
+        else if (dev->class && dev->class->pm)
+                cb = dev->class->pm->runtime_resume;
+        else if (dev->bus && dev->bus->pm)
+                cb = dev->bus->pm->runtime_resume;
+        else
+                cb = NULL;
 
-        return 0;
+        if (!cb && dev->driver && dev->driver->pm)
+                cb = dev->driver->pm->runtime_resume;
+
+        return cb ? cb(dev) : 0;
 }
 
 #ifdef CONFIG_PM_SLEEP
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 9cb845e49334..0113adc310dc 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -28,7 +28,7 @@
 #include <linux/sched.h>
 #include <linux/async.h>
 #include <linux/suspend.h>
-
+#include <linux/cpuidle.h>
 #include "../base.h"
 #include "power.h"
 
@@ -45,10 +45,10 @@ typedef int (*pm_callback_t)(struct device *);
  */
 
 LIST_HEAD(dpm_list);
-LIST_HEAD(dpm_prepared_list);
-LIST_HEAD(dpm_suspended_list);
-LIST_HEAD(dpm_late_early_list);
-LIST_HEAD(dpm_noirq_list);
+static LIST_HEAD(dpm_prepared_list);
+static LIST_HEAD(dpm_suspended_list);
+static LIST_HEAD(dpm_late_early_list);
+static LIST_HEAD(dpm_noirq_list);
 
 struct suspend_stats suspend_stats;
 static DEFINE_MUTEX(dpm_list_mtx);
@@ -166,7 +166,7 @@ static ktime_t initcall_debug_start(struct device *dev)
 {
         ktime_t calltime = ktime_set(0, 0);
 
-        if (initcall_debug) {
+        if (pm_print_times_enabled) {
                 pr_info("calling  %s+ @ %i, parent: %s\n",
                         dev_name(dev), task_pid_nr(current),
                         dev->parent ? dev_name(dev->parent) : "none");
@@ -181,7 +181,7 @@ static void initcall_debug_report(struct device *dev, ktime_t calltime,
 {
         ktime_t delta, rettime;
 
-        if (initcall_debug) {
+        if (pm_print_times_enabled) {
                 rettime = ktime_get();
                 delta = ktime_sub(rettime, calltime);
                 pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev),
@@ -467,6 +467,7 @@ static void dpm_resume_noirq(pm_message_t state)
         mutex_unlock(&dpm_list_mtx);
         dpm_show_time(starttime, state, "noirq");
         resume_device_irqs();
+        cpuidle_resume();
 }
 
 /**
@@ -867,6 +868,7 @@ static int dpm_suspend_noirq(pm_message_t state)
         ktime_t starttime = ktime_get();
         int error = 0;
 
+        cpuidle_pause();
         suspend_device_irqs();
         mutex_lock(&dpm_list_mtx);
         while (!list_empty(&dpm_late_early_list)) {
@@ -989,8 +991,16 @@ static int dpm_suspend_late(pm_message_t state)
 int dpm_suspend_end(pm_message_t state)
 {
         int error = dpm_suspend_late(state);
+        if (error)
+                return error;
+
+        error = dpm_suspend_noirq(state);
+        if (error) {
+                dpm_resume_early(state);
+                return error;
+        }
 
-        return error ? : dpm_suspend_noirq(state);
+        return 0;
 }
 EXPORT_SYMBOL_GPL(dpm_suspend_end);
 
diff --git a/drivers/base/power/qos.c b/drivers/base/power/qos.c
index fd849a2c4fa8..74a67e0019a2 100644
--- a/drivers/base/power/qos.c
+++ b/drivers/base/power/qos.c
@@ -462,7 +462,7 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_add_ancestor_request);
 static void __dev_pm_qos_drop_user_request(struct device *dev)
 {
         dev_pm_qos_remove_request(dev->power.pq_req);
-        dev->power.pq_req = 0;
+        dev->power.pq_req = NULL;
 }
 
 /**
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index 48be2ad4dd2c..b91dc6f1e914 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -474,6 +474,8 @@ static DEVICE_ATTR(runtime_enabled, 0444, rtpm_enabled_show, NULL);
 
 #endif
 
+#ifdef CONFIG_PM_SLEEP
+
 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
                           char *buf)
 {
@@ -500,6 +502,8 @@ static ssize_t async_store(struct device *dev, struct device_attribute *attr,
 }
 
 static DEVICE_ATTR(async, 0644, async_show, async_store);
+
+#endif
 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 
 static struct attribute *power_attrs[] = {
diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index b986b8660b0c..80f9ab9c3aa4 100644
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -95,6 +95,9 @@ struct regmap {
 
         /* if set, converts bulk rw to single rw */
         bool use_single_rw;
+
+        struct rb_root range_tree;
+        void *selector_work_buf;        /* Scratch buffer used for selector */
 };
 
 struct regcache_ops {
@@ -115,6 +118,20 @@ bool regmap_precious(struct regmap *map, unsigned int reg);
 int _regmap_write(struct regmap *map, unsigned int reg,
                   unsigned int val);
 
+struct regmap_range_node {
+        struct rb_node node;
+
+        unsigned int range_min;
+        unsigned int range_max;
+
+        unsigned int selector_reg;
+        unsigned int selector_mask;
+        int selector_shift;
+
+        unsigned int window_start;
+        unsigned int window_len;
+};
+
 #ifdef CONFIG_DEBUG_FS
 extern void regmap_debugfs_initcall(void);
 extern void regmap_debugfs_init(struct regmap *map, const char *name);
diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index 4fac4b9be88f..a89734621e51 100644
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -24,14 +24,18 @@ struct regmap_irq_chip_data {
         struct mutex lock;
 
         struct regmap *map;
-        struct regmap_irq_chip *chip;
+        const struct regmap_irq_chip *chip;
 
         int irq_base;
         struct irq_domain *domain;
 
+        int irq;
+        int wake_count;
+
         unsigned int *status_buf;
         unsigned int *mask_buf;
         unsigned int *mask_buf_def;
+        unsigned int *wake_buf;
 
         unsigned int irq_reg_stride;
 };
@@ -71,6 +75,16 @@ static void regmap_irq_sync_unlock(struct irq_data *data)
                                 d->chip->mask_base + (i * map->reg_stride));
         }
 
+        /* If we've changed our wakeup count propagate it to the parent */
+        if (d->wake_count < 0)
+                for (i = d->wake_count; i < 0; i++)
+                        irq_set_irq_wake(d->irq, 0);
+        else if (d->wake_count > 0)
+                for (i = 0; i < d->wake_count; i++)
+                        irq_set_irq_wake(d->irq, 1);
+
+        d->wake_count = 0;
+
         mutex_unlock(&d->lock);
 }
 
@@ -92,18 +106,41 @@ static void regmap_irq_disable(struct irq_data *data)
         d->mask_buf[irq_data->reg_offset / map->reg_stride] |= irq_data->mask;
 }
 
+static int regmap_irq_set_wake(struct irq_data *data, unsigned int on)
+{
+        struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data);
+        struct regmap *map = d->map;
+        const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->hwirq);
+
+        if (!d->chip->wake_base)
+                return -EINVAL;
+
+        if (on) {
+                d->wake_buf[irq_data->reg_offset / map->reg_stride]
+                        &= ~irq_data->mask;
+                d->wake_count++;
+        } else {
+                d->wake_buf[irq_data->reg_offset / map->reg_stride]
+                        |= irq_data->mask;
+                d->wake_count--;
+        }
+
+        return 0;
+}
+
 static struct irq_chip regmap_irq_chip = {
         .name                   = "regmap",
         .irq_bus_lock           = regmap_irq_lock,
         .irq_bus_sync_unlock    = regmap_irq_sync_unlock,
         .irq_disable            = regmap_irq_disable,
         .irq_enable             = regmap_irq_enable,
+        .irq_set_wake           = regmap_irq_set_wake,
 };
 
 static irqreturn_t regmap_irq_thread(int irq, void *d)
 {
         struct regmap_irq_chip_data *data = d;
-        struct regmap_irq_chip *chip = data->chip;
+        const struct regmap_irq_chip *chip = data->chip;
         struct regmap *map = data->map;
         int ret, i;
         bool handled = false;
@@ -195,7 +232,7 @@ static struct irq_domain_ops regmap_domain_ops = {
  * register values used by the IRQ controller over suspend and resume.
  */
 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
-                        int irq_base, struct regmap_irq_chip *chip,
+                        int irq_base, const struct regmap_irq_chip *chip,
                         struct regmap_irq_chip_data **data)
 {
         struct regmap_irq_chip_data *d;
@@ -240,6 +277,14 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
         if (!d->mask_buf_def)
                 goto err_alloc;
 
+        if (chip->wake_base) {
+                d->wake_buf = kzalloc(sizeof(unsigned int) * chip->num_regs,
+                                      GFP_KERNEL);
+                if (!d->wake_buf)
+                        goto err_alloc;
+        }
+
+        d->irq = irq;
         d->map = map;
         d->chip = chip;
         d->irq_base = irq_base;
@@ -294,6 +339,7 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
 err_domain:
         /* Should really dispose of the domain but... */
 err_alloc:
+        kfree(d->wake_buf);
         kfree(d->mask_buf_def);
         kfree(d->mask_buf);
         kfree(d->status_buf);
@@ -315,6 +361,7 @@ void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *d)
 
         free_irq(irq, d);
         /* We should unmap the domain but... */
+        kfree(d->wake_buf);
         kfree(d->mask_buf_def);
         kfree(d->mask_buf);
         kfree(d->status_buf);
@@ -346,6 +393,10 @@ EXPORT_SYMBOL_GPL(regmap_irq_chip_get_base);
  */
 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq)
 {
+        /* Handle holes in the IRQ list */
+        if (!data->chip->irqs[irq].mask)
+                return -EINVAL;
+
         return irq_create_mapping(data->domain, irq);
 }
 EXPORT_SYMBOL_GPL(regmap_irq_get_virq);
diff --git a/drivers/base/regmap/regmap-mmio.c b/drivers/base/regmap/regmap-mmio.c
index febd6de6c8ac..f05fc74dd84a 100644
--- a/drivers/base/regmap/regmap-mmio.c
+++ b/drivers/base/regmap/regmap-mmio.c
@@ -37,7 +37,7 @@ static int regmap_mmio_gather_write(void *context,
 
         BUG_ON(reg_size != 4);
 
-        offset = be32_to_cpup(reg);
+        offset = *(u32 *)reg;
 
         while (val_size) {
                 switch (ctx->val_bytes) {
@@ -45,14 +45,14 @@ static int regmap_mmio_gather_write(void *context,
                         writeb(*(u8 *)val, ctx->regs + offset);
                         break;
                 case 2:
-                        writew(be16_to_cpup(val), ctx->regs + offset);
+                        writew(*(u16 *)val, ctx->regs + offset);
                         break;
                 case 4:
-                        writel(be32_to_cpup(val), ctx->regs + offset);
+                        writel(*(u32 *)val, ctx->regs + offset);
                         break;
 #ifdef CONFIG_64BIT
                 case 8:
-                        writeq(be64_to_cpup(val), ctx->regs + offset);
+                        writeq(*(u64 *)val, ctx->regs + offset);
                         break;
 #endif
                 default:
@@ -83,7 +83,7 @@ static int regmap_mmio_read(void *context,
 
         BUG_ON(reg_size != 4);
 
-        offset = be32_to_cpup(reg);
+        offset = *(u32 *)reg;
 
         while (val_size) {
                 switch (ctx->val_bytes) {
@@ -91,14 +91,14 @@ static int regmap_mmio_read(void *context,
                         *(u8 *)val = readb(ctx->regs + offset);
                         break;
                 case 2:
-                        *(u16 *)val = cpu_to_be16(readw(ctx->regs + offset));
+                        *(u16 *)val = readw(ctx->regs + offset);
                         break;
                 case 4:
-                        *(u32 *)val = cpu_to_be32(readl(ctx->regs + offset));
+                        *(u32 *)val = readl(ctx->regs + offset);
                         break;
 #ifdef CONFIG_64BIT
                 case 8:
-                        *(u64 *)val = cpu_to_be32(readq(ctx->regs + offset));
+                        *(u64 *)val = readq(ctx->regs + offset);
                         break;
 #endif
                 default:
@@ -124,9 +124,11 @@ static struct regmap_bus regmap_mmio = {
         .gather_write = regmap_mmio_gather_write,
         .read = regmap_mmio_read,
         .free_context = regmap_mmio_free_context,
+        .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
+        .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
 };
 
-struct regmap_mmio_context *regmap_mmio_gen_context(void __iomem *regs,
+static struct regmap_mmio_context *regmap_mmio_gen_context(void __iomem *regs,
                                         const struct regmap_config *config)
 {
         struct regmap_mmio_context *ctx;
@@ -162,7 +164,15 @@ struct regmap_mmio_context *regmap_mmio_gen_context(void __iomem *regs,
         if (config->reg_stride < min_stride)
                 return ERR_PTR(-EINVAL);
 
-        ctx = kzalloc(GFP_KERNEL, sizeof(*ctx));
+        switch (config->reg_format_endian) {
+        case REGMAP_ENDIAN_DEFAULT:
+        case REGMAP_ENDIAN_NATIVE:
+                break;
+        default:
+                return ERR_PTR(-EINVAL);
+        }
+
+        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
         if (!ctx)
                 return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index c89aa01fb1de..c241ae2f2f10 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -15,12 +15,25 @@
 #include <linux/export.h>
 #include <linux/mutex.h>
 #include <linux/err.h>
+#include <linux/rbtree.h>
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/regmap.h>
 
 #include "internal.h"
 
+/*
+ * Sometimes for failures during very early init the trace
+ * infrastructure isn't available early enough to be used.  For this
+ * sort of problem defining LOG_DEVICE will add printks for basic
+ * register I/O on a specific device.
+ */
+#undef LOG_DEVICE
+
+static int _regmap_update_bits(struct regmap *map, unsigned int reg,
+                               unsigned int mask, unsigned int val,
+                               bool *change);
+
 bool regmap_writeable(struct regmap *map, unsigned int reg)
 {
         if (map->max_register && reg > map->max_register)
@@ -119,13 +132,19 @@ static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
         b[0] = val << shift;
 }
 
-static void regmap_format_16(void *buf, unsigned int val, unsigned int shift)
+static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
 {
         __be16 *b = buf;
 
         b[0] = cpu_to_be16(val << shift);
 }
 
+static void regmap_format_16_native(void *buf, unsigned int val,
+                                    unsigned int shift)
+{
+        *(u16 *)buf = val << shift;
+}
+
 static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
 {
         u8 *b = buf;
@@ -137,13 +156,19 @@ static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
         b[2] = val;
 }
 
-static void regmap_format_32(void *buf, unsigned int val, unsigned int shift)
+static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
 {
         __be32 *b = buf;
 
         b[0] = cpu_to_be32(val << shift);
 }
 
+static void regmap_format_32_native(void *buf, unsigned int val,
+                                    unsigned int shift)
+{
+        *(u32 *)buf = val << shift;
+}
+
 static unsigned int regmap_parse_8(void *buf)
 {
         u8 *b = buf;
@@ -151,7 +176,7 @@ static unsigned int regmap_parse_8(void *buf)
         return b[0];
 }
 
-static unsigned int regmap_parse_16(void *buf)
+static unsigned int regmap_parse_16_be(void *buf)
 {
         __be16 *b = buf;
 
@@ -160,6 +185,11 @@ static unsigned int regmap_parse_16(void *buf)
         return b[0];
 }
 
+static unsigned int regmap_parse_16_native(void *buf)
+{
+        return *(u16 *)buf;
+}
+
 static unsigned int regmap_parse_24(void *buf)
 {
         u8 *b = buf;
@@ -170,7 +200,7 @@ static unsigned int regmap_parse_24(void *buf)
         return ret;
 }
 
-static unsigned int regmap_parse_32(void *buf)
+static unsigned int regmap_parse_32_be(void *buf)
 {
         __be32 *b = buf;
 
@@ -179,6 +209,11 @@ static unsigned int regmap_parse_32(void *buf)
         return b[0];
 }
 
+static unsigned int regmap_parse_32_native(void *buf)
+{
+        return *(u32 *)buf;
+}
+
 static void regmap_lock_mutex(struct regmap *map)
 {
         mutex_lock(&map->mutex);
@@ -208,6 +243,67 @@ static void dev_get_regmap_release(struct device *dev, void *res)
          */
 }
 
+static bool _regmap_range_add(struct regmap *map,
+                              struct regmap_range_node *data)
+{
+        struct rb_root *root = &map->range_tree;
+        struct rb_node **new = &(root->rb_node), *parent = NULL;
+
+        while (*new) {
+                struct regmap_range_node *this =
+                        container_of(*new, struct regmap_range_node, node);
+
+                parent = *new;
+                if (data->range_max < this->range_min)
+                        new = &((*new)->rb_left);
+                else if (data->range_min > this->range_max)
+                        new = &((*new)->rb_right);
+                else
+                        return false;
+        }
+
+        rb_link_node(&data->node, parent, new);
+        rb_insert_color(&data->node, root);
+
+        return true;
+}
+
+static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
+                                                      unsigned int reg)
+{
+        struct rb_node *node = map->range_tree.rb_node;
+
+        while (node) {
+                struct regmap_range_node *this =
+                        container_of(node, struct regmap_range_node, node);
+
+                if (reg < this->range_min)
+                        node = node->rb_left;
+                else if (reg > this->range_max)
+                        node = node->rb_right;
+                else
+                        return this;
+        }
+
+        return NULL;
+}
+
+static void regmap_range_exit(struct regmap *map)
+{
+        struct rb_node *next;
+        struct regmap_range_node *range_node;
+
+        next = rb_first(&map->range_tree);
+        while (next) {
+                range_node = rb_entry(next, struct regmap_range_node, node);
+                next = rb_next(&range_node->node);
+                rb_erase(&range_node->node, &map->range_tree);
+                kfree(range_node);
+        }
+
+        kfree(map->selector_work_buf);
+}
+
 /**
  * regmap_init(): Initialise register map
  *
@@ -227,6 +323,8 @@ struct regmap *regmap_init(struct device *dev,
 {
         struct regmap *map, **m;
         int ret = -EINVAL;
+        enum regmap_endian reg_endian, val_endian;
+        int i, j;
 
         if (!bus || !config)
                 goto err;
@@ -275,6 +373,18 @@ struct regmap *regmap_init(struct device *dev,
                 map->read_flag_mask = bus->read_flag_mask;
         }
 
+        reg_endian = config->reg_format_endian;
+        if (reg_endian == REGMAP_ENDIAN_DEFAULT)
+                reg_endian = bus->reg_format_endian_default;
+        if (reg_endian == REGMAP_ENDIAN_DEFAULT)
+                reg_endian = REGMAP_ENDIAN_BIG;
+
+        val_endian = config->val_format_endian;
+        if (val_endian == REGMAP_ENDIAN_DEFAULT)
+                val_endian = bus->val_format_endian_default;
+        if (val_endian == REGMAP_ENDIAN_DEFAULT)
+                val_endian = REGMAP_ENDIAN_BIG;
+
         switch (config->reg_bits + map->reg_shift) {
         case 2:
                 switch (config->val_bits) {
@@ -321,11 +431,29 @@ struct regmap *regmap_init(struct device *dev,
                 break;
 
         case 16:
-                map->format.format_reg = regmap_format_16;
+                switch (reg_endian) {
+                case REGMAP_ENDIAN_BIG:
+                        map->format.format_reg = regmap_format_16_be;
+                        break;
+                case REGMAP_ENDIAN_NATIVE:
+                        map->format.format_reg = regmap_format_16_native;
+                        break;
+                default:
+                        goto err_map;
+                }
                 break;
 
         case 32:
-                map->format.format_reg = regmap_format_32;
+                switch (reg_endian) {
+                case REGMAP_ENDIAN_BIG:
+                        map->format.format_reg = regmap_format_32_be;
+                        break;
+                case REGMAP_ENDIAN_NATIVE:
+                        map->format.format_reg = regmap_format_32_native;
+                        break;
+                default:
+                        goto err_map;
+                }
                 break;
 
         default:
@@ -338,21 +466,47 @@ struct regmap *regmap_init(struct device *dev,
                 map->format.parse_val = regmap_parse_8;
                 break;
         case 16:
-                map->format.format_val = regmap_format_16;
-                map->format.parse_val = regmap_parse_16;
+                switch (val_endian) {
+                case REGMAP_ENDIAN_BIG:
+                        map->format.format_val = regmap_format_16_be;
+                        map->format.parse_val = regmap_parse_16_be;
+                        break;
+                case REGMAP_ENDIAN_NATIVE:
+                        map->format.format_val = regmap_format_16_native;
+                        map->format.parse_val = regmap_parse_16_native;
+                        break;
+                default:
+                        goto err_map;
+                }
                 break;
         case 24:
+                if (val_endian != REGMAP_ENDIAN_BIG)
+                        goto err_map;
                 map->format.format_val = regmap_format_24;
                 map->format.parse_val = regmap_parse_24;
                 break;
         case 32:
-                map->format.format_val = regmap_format_32;
-                map->format.parse_val = regmap_parse_32;
+                switch (val_endian) {
+                case REGMAP_ENDIAN_BIG:
+                        map->format.format_val = regmap_format_32_be;
+                        map->format.parse_val = regmap_parse_32_be;
+                        break;
+                case REGMAP_ENDIAN_NATIVE:
+                        map->format.format_val = regmap_format_32_native;
+                        map->format.parse_val = regmap_parse_32_native;
+                        break;
+                default:
+                        goto err_map;
+                }
                 break;
         }
 
-        if (map->format.format_write)
+        if (map->format.format_write) {
+                if ((reg_endian != REGMAP_ENDIAN_BIG) ||
+                    (val_endian != REGMAP_ENDIAN_BIG))
+                        goto err_map;
                 map->use_single_rw = true;
+        }
 
         if (!map->format.format_write &&
             !(map->format.format_reg && map->format.format_val))
@@ -364,27 +518,88 @@ struct regmap *regmap_init(struct device *dev,
                 goto err_map;
         }
 
-        regmap_debugfs_init(map, config->name);
+        map->range_tree = RB_ROOT;
+        for (i = 0; i < config->n_ranges; i++) {
+                const struct regmap_range_cfg *range_cfg = &config->ranges[i];
+                struct regmap_range_node *new;
+
+                /* Sanity check */
+                if (range_cfg->range_max < range_cfg->range_min ||
+                    range_cfg->range_max > map->max_register ||
+                    range_cfg->selector_reg > map->max_register ||
+                    range_cfg->window_len == 0)
+                        goto err_range;
+
+                /* Make sure, that this register range has no selector
+                   or data window within its boundary */
+                for (j = 0; j < config->n_ranges; j++) {
+                        unsigned sel_reg = config->ranges[j].selector_reg;
+                        unsigned win_min = config->ranges[j].window_start;
+                        unsigned win_max = win_min +
+                                           config->ranges[j].window_len - 1;
+
+                        if (range_cfg->range_min <= sel_reg &&
+                            sel_reg <= range_cfg->range_max) {
+                                goto err_range;
+                        }
+
+                        if (!(win_max < range_cfg->range_min ||
+                              win_min > range_cfg->range_max)) {
+                                goto err_range;
+                        }
+                }
+
+                new = kzalloc(sizeof(*new), GFP_KERNEL);
+                if (new == NULL) {
+                        ret = -ENOMEM;
+                        goto err_range;
+                }
+
+                new->range_min = range_cfg->range_min;
+                new->range_max = range_cfg->range_max;
+                new->selector_reg = range_cfg->selector_reg;
+                new->selector_mask = range_cfg->selector_mask;
+                new->selector_shift = range_cfg->selector_shift;
+                new->window_start = range_cfg->window_start;
+                new->window_len = range_cfg->window_len;
+
+                if (_regmap_range_add(map, new) == false) {
+                        kfree(new);
+                        goto err_range;
+                }
+
+                if (map->selector_work_buf == NULL) {
+                        map->selector_work_buf =
+                                kzalloc(map->format.buf_size, GFP_KERNEL);
+                        if (map->selector_work_buf == NULL) {
+                                ret = -ENOMEM;
+                                goto err_range;
+                        }
+                }
+        }
 
         ret = regcache_init(map, config);
         if (ret < 0)
-                goto err_debugfs;
+                goto err_range;
+
+        regmap_debugfs_init(map, config->name);
 
         /* Add a devres resource for dev_get_regmap() */
         m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
         if (!m) {
                 ret = -ENOMEM;
-                goto err_cache;
+                goto err_debugfs;
         }
         *m = map;
         devres_add(dev, m);
 
         return map;
 
-err_cache:
-        regcache_exit(map);
 err_debugfs:
         regmap_debugfs_exit(map);
+        regcache_exit(map);
+err_range:
+        regmap_range_exit(map);
         kfree(map->work_buf);
 err_map:
         kfree(map);
@@ -481,6 +696,7 @@ void regmap_exit(struct regmap *map)
 {
         regcache_exit(map);
         regmap_debugfs_exit(map);
+        regmap_range_exit(map);
         if (map->bus->free_context)
                 map->bus->free_context(map->bus_context);
         kfree(map->work_buf);
@@ -526,6 +742,57 @@ struct regmap *dev_get_regmap(struct device *dev, const char *name)
 }
 EXPORT_SYMBOL_GPL(dev_get_regmap);
 
+static int _regmap_select_page(struct regmap *map, unsigned int *reg,
+                               unsigned int val_num)
+{
+        struct regmap_range_node *range;
+        void *orig_work_buf;
+        unsigned int win_offset;
+        unsigned int win_page;
+        bool page_chg;
+        int ret;
+
+        range = _regmap_range_lookup(map, *reg);
+        if (range) {
+                win_offset = (*reg - range->range_min) % range->window_len;
+                win_page = (*reg - range->range_min) / range->window_len;
+
+                if (val_num > 1) {
+                        /* Bulk write shouldn't cross range boundary */
+                        if (*reg + val_num - 1 > range->range_max)
+                                return -EINVAL;
+
+                        /* ... or single page boundary */
+                        if (val_num > range->window_len - win_offset)
+                                return -EINVAL;
+                }
+
+                /* It is possible to have selector register inside data window.
+                   In that case, selector register is located on every page and
+                   it needs no page switching, when accessed alone. */
+                if (val_num > 1 ||
+                    range->window_start + win_offset != range->selector_reg) {
+                        /* Use separate work_buf during page switching */
+                        orig_work_buf = map->work_buf;
+                        map->work_buf = map->selector_work_buf;
+
+                        ret = _regmap_update_bits(map, range->selector_reg,
+                                        range->selector_mask,
+                                        win_page << range->selector_shift,
+                                        &page_chg);
+
+                        map->work_buf = orig_work_buf;
+
+                        if (ret < 0)
+                                return ret;
+                }
+
+                *reg = range->window_start + win_offset;
+        }
+
+        return 0;
+}
+
 static int _regmap_raw_write(struct regmap *map, unsigned int reg,
                              const void *val, size_t val_len)
 {
@@ -563,6 +830,10 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
                 }
         }
 
+        ret = _regmap_select_page(map, &reg, val_len / map->format.val_bytes);
+        if (ret < 0)
+                return ret;
+
         map->format.format_reg(map->work_buf, reg, map->reg_shift);
 
         u8[0] |= map->write_flag_mask;
@@ -623,9 +894,18 @@ int _regmap_write(struct regmap *map, unsigned int reg,
                 }
         }
 
+#ifdef LOG_DEVICE
+        if (strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
+                dev_info(map->dev, "%x <= %x\n", reg, val);
+#endif
+
         trace_regmap_reg_write(map->dev, reg, val);
 
         if (map->format.format_write) {
+                ret = _regmap_select_page(map, &reg, 1);
+                if (ret < 0)
+                        return ret;
+
                 map->format.format_write(map, reg, val);
 
                 trace_regmap_hw_write_start(map->dev, reg, 1);
@@ -783,6 +1063,10 @@ static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
         u8 *u8 = map->work_buf;
         int ret;
 
+        ret = _regmap_select_page(map, &reg, val_len / map->format.val_bytes);
+        if (ret < 0)
+                return ret;
+
         map->format.format_reg(map->work_buf, reg, map->reg_shift);
 
         /*
@@ -826,6 +1110,12 @@ static int _regmap_read(struct regmap *map, unsigned int reg,
         ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
         if (ret == 0) {
                 *val = map->format.parse_val(map->work_buf);
+
+#ifdef LOG_DEVICE
+                if (strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
+                        dev_info(map->dev, "%x => %x\n", reg, *val);
+#endif
+
                 trace_regmap_reg_read(map->dev, reg, *val);
         }
 
@@ -982,11 +1272,9 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
         int ret;
         unsigned int tmp, orig;
 
-        map->lock(map);
-
         ret = _regmap_read(map, reg, &orig);
         if (ret != 0)
-                goto out;
+                return ret;
 
         tmp = orig & ~mask;
         tmp |= val & mask;
@@ -998,9 +1286,6 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
                 *change = false;
         }
 
-out:
-        map->unlock(map);
-
         return ret;
 }
 
@@ -1018,7 +1303,13 @@ int regmap_update_bits(struct regmap *map, unsigned int reg,
                        unsigned int mask, unsigned int val)
 {
         bool change;
-        return _regmap_update_bits(map, reg, mask, val, &change);
+        int ret;
+
+        map->lock(map);
+        ret = _regmap_update_bits(map, reg, mask, val, &change);
+        map->unlock(map);
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(regmap_update_bits);
 
@@ -1038,7 +1329,12 @@ int regmap_update_bits_check(struct regmap *map, unsigned int reg,
                              unsigned int mask, unsigned int val,
                              bool *change)
 {
-        return _regmap_update_bits(map, reg, mask, val, change);
+        int ret;
+
+        map->lock(map);
+        ret = _regmap_update_bits(map, reg, mask, val, change);
+        map->unlock(map);
+        return ret;
 }
 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
 
diff --git a/drivers/block/drbd/drbd_bitmap.c b/drivers/block/drbd/drbd_bitmap.c
index b5c5ff53cb57..fcb956bb4b4c 100644
--- a/drivers/block/drbd/drbd_bitmap.c
+++ b/drivers/block/drbd/drbd_bitmap.c
@@ -1475,10 +1475,17 @@ void _drbd_bm_set_bits(struct drbd_conf *mdev, const unsigned long s, const unsi
                 first_word = 0;
                 spin_lock_irq(&b->bm_lock);
         }
-
         /* last page (respectively only page, for first page == last page) */
         last_word = MLPP(el >> LN2_BPL);
-        bm_set_full_words_within_one_page(mdev->bitmap, last_page, first_word, last_word);
+
+        /* consider bitmap->bm_bits = 32768, bitmap->bm_number_of_pages = 1. (or multiples).
+         * ==> e = 32767, el = 32768, last_page = 2,
+         * and now last_word = 0.
+         * We do not want to touch last_page in this case,
+         * as we did not allocate it, it is not present in bitmap->bm_pages.
+         */
+        if (last_word)
+                bm_set_full_words_within_one_page(mdev->bitmap, last_page, first_word, last_word);
 
         /* possibly trailing bits.
          * example: (e & 63) == 63, el will be e+1.
diff --git a/drivers/block/drbd/drbd_req.c b/drivers/block/drbd/drbd_req.c
index 9c5c84946b05..8e93a6ac9bb6 100644
--- a/drivers/block/drbd/drbd_req.c
+++ b/drivers/block/drbd/drbd_req.c
@@ -472,12 +472,17 @@ int __req_mod(struct drbd_request *req, enum drbd_req_event what,
                 req->rq_state |= RQ_LOCAL_COMPLETED;
                 req->rq_state &= ~RQ_LOCAL_PENDING;
 
-                D_ASSERT(!(req->rq_state & RQ_NET_MASK));
+                if (req->rq_state & RQ_LOCAL_ABORTED) {
+                        _req_may_be_done(req, m);
+                        break;
+                }
 
                 __drbd_chk_io_error(mdev, false);
 
         goto_queue_for_net_read:
 
+                D_ASSERT(!(req->rq_state & RQ_NET_MASK));
+
                 /* no point in retrying if there is no good remote data,
                  * or we have no connection. */
                 if (mdev->state.pdsk != D_UP_TO_DATE) {
@@ -765,6 +770,40 @@ static int drbd_may_do_local_read(struct drbd_conf *mdev, sector_t sector, int s
         return 0 == drbd_bm_count_bits(mdev, sbnr, ebnr);
 }
 
+static void maybe_pull_ahead(struct drbd_conf *mdev)
+{
+        int congested = 0;
+
+        /* If I don't even have good local storage, we can not reasonably try
+         * to pull ahead of the peer. We also need the local reference to make
+         * sure mdev->act_log is there.
+         * Note: caller has to make sure that net_conf is there.
+         */
+        if (!get_ldev_if_state(mdev, D_UP_TO_DATE))
+                return;
+
+        if (mdev->net_conf->cong_fill &&
+            atomic_read(&mdev->ap_in_flight) >= mdev->net_conf->cong_fill) {
+                dev_info(DEV, "Congestion-fill threshold reached\n");
+                congested = 1;
+        }
+
+        if (mdev->act_log->used >= mdev->net_conf->cong_extents) {
+                dev_info(DEV, "Congestion-extents threshold reached\n");
+                congested = 1;
+        }
+
+        if (congested) {
+                queue_barrier(mdev); /* last barrier, after mirrored writes */
+
+                if (mdev->net_conf->on_congestion == OC_PULL_AHEAD)
+                        _drbd_set_state(_NS(mdev, conn, C_AHEAD), 0, NULL);
+                else  /*mdev->net_conf->on_congestion == OC_DISCONNECT */
+                        _drbd_set_state(_NS(mdev, conn, C_DISCONNECTING), 0, NULL);
+        }
+        put_ldev(mdev);
+}
+
 static int drbd_make_request_common(struct drbd_conf *mdev, struct bio *bio, unsigned long start_time)
 {
         const int rw = bio_rw(bio);
@@ -972,29 +1011,8 @@ allocate_barrier:
                 _req_mod(req, queue_for_send_oos);
 
         if (remote &&
-            mdev->net_conf->on_congestion != OC_BLOCK && mdev->agreed_pro_version >= 96) {
-                int congested = 0;
-
-                if (mdev->net_conf->cong_fill &&
-                    atomic_read(&mdev->ap_in_flight) >= mdev->net_conf->cong_fill) {
-                        dev_info(DEV, "Congestion-fill threshold reached\n");
-                        congested = 1;
-                }
-
-                if (mdev->act_log->used >= mdev->net_conf->cong_extents) {
-                        dev_info(DEV, "Congestion-extents threshold reached\n");
-                        congested = 1;
-                }
-
-                if (congested) {
-                        queue_barrier(mdev); /* last barrier, after mirrored writes */
-
-                        if (mdev->net_conf->on_congestion == OC_PULL_AHEAD)
-                                _drbd_set_state(_NS(mdev, conn, C_AHEAD), 0, NULL);
-                        else  /*mdev->net_conf->on_congestion == OC_DISCONNECT */
-                                _drbd_set_state(_NS(mdev, conn, C_DISCONNECTING), 0, NULL);
-                }
-        }
+            mdev->net_conf->on_congestion != OC_BLOCK && mdev->agreed_pro_version >= 96)
+                maybe_pull_ahead(mdev);
 
         spin_unlock_irq(&mdev->req_lock);
         kfree(b); /* if someone else has beaten us to it... */
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index cce7df367b79..553f43a90953 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -671,6 +671,7 @@ static void __reschedule_timeout(int drive, const char *message)
 
         if (drive == current_reqD)
                 drive = current_drive;
+        __cancel_delayed_work(&fd_timeout);
 
         if (drive < 0 || drive >= N_DRIVE) {
                 delay = 20UL * HZ;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index bbca966f8f66..3bba65510d23 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -1597,14 +1597,12 @@ static int loop_add(struct loop_device **l, int i)
         struct gendisk *disk;
         int err;
 
+        err = -ENOMEM;
         lo = kzalloc(sizeof(*lo), GFP_KERNEL);
-        if (!lo) {
-                err = -ENOMEM;
+        if (!lo)
                 goto out;
-        }
 
-        err = idr_pre_get(&loop_index_idr, GFP_KERNEL);
-        if (err < 0)
+        if (!idr_pre_get(&loop_index_idr, GFP_KERNEL))
                 goto out_free_dev;
 
         if (i >= 0) {
diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
index 76fa3deaee84..1788f491e0fb 100644
--- a/drivers/block/mg_disk.c
+++ b/drivers/block/mg_disk.c
@@ -780,9 +780,9 @@ static const struct block_device_operations mg_disk_ops = {
         .getgeo = mg_getgeo
 };
 
-static int mg_suspend(struct platform_device *plat_dev, pm_message_t state)
+static int mg_suspend(struct device *dev)
 {
-        struct mg_drv_data *prv_data = plat_dev->dev.platform_data;
+        struct mg_drv_data *prv_data = dev->platform_data;
         struct mg_host *host = prv_data->host;
 
         if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD))
@@ -804,9 +804,9 @@ static int mg_suspend(struct platform_device *plat_dev, pm_message_t state)
         return 0;
 }
 
-static int mg_resume(struct platform_device *plat_dev)
+static int mg_resume(struct device *dev)
 {
-        struct mg_drv_data *prv_data = plat_dev->dev.platform_data;
+        struct mg_drv_data *prv_data = dev->platform_data;
         struct mg_host *host = prv_data->host;
 
         if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD))
@@ -825,6 +825,8 @@ static int mg_resume(struct platform_device *plat_dev)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(mg_pm, mg_suspend, mg_resume);
+
 static int mg_probe(struct platform_device *plat_dev)
 {
         struct mg_host *host;
@@ -1074,11 +1076,10 @@ static int mg_remove(struct platform_device *plat_dev)
 static struct platform_driver mg_disk_driver = {
         .probe = mg_probe,
         .remove = mg_remove,
-        .suspend = mg_suspend,
-        .resume = mg_resume,
         .driver = {
                 .name = MG_DEV_NAME,
                 .owner = THIS_MODULE,
+                .pm = &mg_pm,
         }
 };
 
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 264bc77dcb91..a8fddeb3d638 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -37,6 +37,7 @@
 #include <linux/kthread.h>
 #include <../drivers/ata/ahci.h>
 #include <linux/export.h>
+#include <linux/debugfs.h>
 #include "mtip32xx.h"
 
 #define HW_CMD_SLOT_SZ          (MTIP_MAX_COMMAND_SLOTS * 32)
@@ -85,6 +86,7 @@ static int instance;
  * allocated in mtip_init().
  */
 static int mtip_major;
+static struct dentry *dfs_parent;
 
 static DEFINE_SPINLOCK(rssd_index_lock);
 static DEFINE_IDA(rssd_index_ida);
@@ -2546,7 +2548,7 @@ static struct scatterlist *mtip_hw_get_scatterlist(struct driver_data *dd,
 }
 
 /*
- * Sysfs register/status dump.
+ * Sysfs status dump.
  *
  * @dev  Pointer to the device structure, passed by the kernrel.
  * @attr Pointer to the device_attribute structure passed by the kernel.
@@ -2555,45 +2557,68 @@ static struct scatterlist *mtip_hw_get_scatterlist(struct driver_data *dd,
  * return value
  *      The size, in bytes, of the data copied into buf.
  */
-static ssize_t mtip_hw_show_registers(struct device *dev,
+static ssize_t mtip_hw_show_status(struct device *dev,
                                 struct device_attribute *attr,
                                 char *buf)
 {
-        u32 group_allocated;
         struct driver_data *dd = dev_to_disk(dev)->private_data;
         int size = 0;
+
+        if (test_bit(MTIP_DDF_OVER_TEMP_BIT, &dd->dd_flag))
+                size += sprintf(buf, "%s", "thermal_shutdown\n");
+        else if (test_bit(MTIP_DDF_WRITE_PROTECT_BIT, &dd->dd_flag))
+                size += sprintf(buf, "%s", "write_protect\n");
+        else
+                size += sprintf(buf, "%s", "online\n");
+
+        return size;
+}
+
+static DEVICE_ATTR(status, S_IRUGO, mtip_hw_show_status, NULL);
+
+static ssize_t mtip_hw_read_registers(struct file *f, char __user *ubuf,
+                                  size_t len, loff_t *offset)
+{
+        struct driver_data *dd =  (struct driver_data *)f->private_data;
+        char buf[MTIP_DFS_MAX_BUF_SIZE];
+        u32 group_allocated;
+        int size = *offset;
         int n;
 
-        size += sprintf(&buf[size], "Hardware\n--------\n");
-        size += sprintf(&buf[size], "S ACTive      : [ 0x");
+        if (!len || size)
+                return 0;
+
+        if (size < 0)
+                return -EINVAL;
+
+        size += sprintf(&buf[size], "H/ S ACTive      : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--)
                 size += sprintf(&buf[size], "%08X ",
                                          readl(dd->port->s_active[n]));
 
         size += sprintf(&buf[size], "]\n");
-        size += sprintf(&buf[size], "Command Issue : [ 0x");
+        size += sprintf(&buf[size], "H/ Command Issue : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--)
                 size += sprintf(&buf[size], "%08X ",
                                         readl(dd->port->cmd_issue[n]));
 
         size += sprintf(&buf[size], "]\n");
-        size += sprintf(&buf[size], "Completed     : [ 0x");
+        size += sprintf(&buf[size], "H/ Completed     : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--)
                 size += sprintf(&buf[size], "%08X ",
                                 readl(dd->port->completed[n]));
 
         size += sprintf(&buf[size], "]\n");
-        size += sprintf(&buf[size], "PORT IRQ STAT : [ 0x%08X ]\n",
+        size += sprintf(&buf[size], "H/ PORT IRQ STAT : [ 0x%08X ]\n",
                                 readl(dd->port->mmio + PORT_IRQ_STAT));
-        size += sprintf(&buf[size], "HOST IRQ STAT : [ 0x%08X ]\n",
+        size += sprintf(&buf[size], "H/ HOST IRQ STAT : [ 0x%08X ]\n",
                                 readl(dd->mmio + HOST_IRQ_STAT));
         size += sprintf(&buf[size], "\n");
 
-        size += sprintf(&buf[size], "Local\n-----\n");
-        size += sprintf(&buf[size], "Allocated    : [ 0x");
+        size += sprintf(&buf[size], "L/ Allocated     : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--) {
                 if (sizeof(long) > sizeof(u32))
@@ -2605,7 +2630,7 @@ static ssize_t mtip_hw_show_registers(struct device *dev,
         }
         size += sprintf(&buf[size], "]\n");
 
-        size += sprintf(&buf[size], "Commands in Q: [ 0x");
+        size += sprintf(&buf[size], "L/ Commands in Q : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--) {
                 if (sizeof(long) > sizeof(u32))
@@ -2617,44 +2642,53 @@ static ssize_t mtip_hw_show_registers(struct device *dev,
         }
         size += sprintf(&buf[size], "]\n");
 
-        return size;
+        *offset = size <= len ? size : len;
+        size = copy_to_user(ubuf, buf, *offset);
+        if (size)
+                return -EFAULT;
+
+        return *offset;
 }
 
-static ssize_t mtip_hw_show_status(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
+static ssize_t mtip_hw_read_flags(struct file *f, char __user *ubuf,
+                                  size_t len, loff_t *offset)
 {
-        struct driver_data *dd = dev_to_disk(dev)->private_data;
-        int size = 0;
+        struct driver_data *dd =  (struct driver_data *)f->private_data;
+        char buf[MTIP_DFS_MAX_BUF_SIZE];
+        int size = *offset;
 
-        if (test_bit(MTIP_DDF_OVER_TEMP_BIT, &dd->dd_flag))
-                size += sprintf(buf, "%s", "thermal_shutdown\n");
-        else if (test_bit(MTIP_DDF_WRITE_PROTECT_BIT, &dd->dd_flag))
-                size += sprintf(buf, "%s", "write_protect\n");
-        else
-                size += sprintf(buf, "%s", "online\n");
-
-        return size;
-}
+        if (!len || size)
+                return 0;
 
-static ssize_t mtip_hw_show_flags(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
-{
-        struct driver_data *dd = dev_to_disk(dev)->private_data;
-        int size = 0;
+        if (size < 0)
+                return -EINVAL;
 
-        size += sprintf(&buf[size], "Flag in port struct : [ %08lX ]\n",
+        size += sprintf(&buf[size], "Flag-port : [ %08lX ]\n",
                                                         dd->port->flags);
-        size += sprintf(&buf[size], "Flag in dd struct   : [ %08lX ]\n",
+        size += sprintf(&buf[size], "Flag-dd   : [ %08lX ]\n",
                                                         dd->dd_flag);
 
-        return size;
+        *offset = size <= len ? size : len;
+        size = copy_to_user(ubuf, buf, *offset);
+        if (size)
+                return -EFAULT;
+
+        return *offset;
 }
 
-static DEVICE_ATTR(registers, S_IRUGO, mtip_hw_show_registers, NULL);
-static DEVICE_ATTR(status, S_IRUGO, mtip_hw_show_status, NULL);
-static DEVICE_ATTR(flags, S_IRUGO, mtip_hw_show_flags, NULL);
+static const struct file_operations mtip_regs_fops = {
+        .owner  = THIS_MODULE,
+        .open   = simple_open,
+        .read   = mtip_hw_read_registers,
+        .llseek = no_llseek,
+};
+
+static const struct file_operations mtip_flags_fops = {
+        .owner  = THIS_MODULE,
+        .open   = simple_open,
+        .read   = mtip_hw_read_flags,
+        .llseek = no_llseek,
+};
 
 /*
  * Create the sysfs related attributes.
@@ -2671,15 +2705,9 @@ static int mtip_hw_sysfs_init(struct driver_data *dd, struct kobject *kobj)
         if (!kobj || !dd)
                 return -EINVAL;
 
-        if (sysfs_create_file(kobj, &dev_attr_registers.attr))
-                dev_warn(&dd->pdev->dev,
-                        "Error creating 'registers' sysfs entry\n");
         if (sysfs_create_file(kobj, &dev_attr_status.attr))
                 dev_warn(&dd->pdev->dev,
                         "Error creating 'status' sysfs entry\n");
-        if (sysfs_create_file(kobj, &dev_attr_flags.attr))
-                dev_warn(&dd->pdev->dev,
-                        "Error creating 'flags' sysfs entry\n");
         return 0;
 }
 
@@ -2698,13 +2726,39 @@ static int mtip_hw_sysfs_exit(struct driver_data *dd, struct kobject *kobj)
         if (!kobj || !dd)
                 return -EINVAL;
 
-        sysfs_remove_file(kobj, &dev_attr_registers.attr);
         sysfs_remove_file(kobj, &dev_attr_status.attr);
-        sysfs_remove_file(kobj, &dev_attr_flags.attr);
 
         return 0;
 }
 
+static int mtip_hw_debugfs_init(struct driver_data *dd)
+{
+        if (!dfs_parent)
+                return -1;
+
+        dd->dfs_node = debugfs_create_dir(dd->disk->disk_name, dfs_parent);
+        if (IS_ERR_OR_NULL(dd->dfs_node)) {
+                dev_warn(&dd->pdev->dev,
+                        "Error creating node %s under debugfs\n",
+                                                dd->disk->disk_name);
+                dd->dfs_node = NULL;
+                return -1;
+        }
+
+        debugfs_create_file("flags", S_IRUGO, dd->dfs_node, dd,
+                                                        &mtip_flags_fops);
+        debugfs_create_file("registers", S_IRUGO, dd->dfs_node, dd,
+                                                        &mtip_regs_fops);
+
+        return 0;
+}
+
+static void mtip_hw_debugfs_exit(struct driver_data *dd)
+{
+        debugfs_remove_recursive(dd->dfs_node);
+}
+
+
 /*
  * Perform any init/resume time hardware setup
  *
@@ -3730,6 +3784,7 @@ skip_create_disk:
                 mtip_hw_sysfs_init(dd, kobj);
                 kobject_put(kobj);
         }
+        mtip_hw_debugfs_init(dd);
 
         if (dd->mtip_svc_handler) {
                 set_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag);
@@ -3755,6 +3810,8 @@ start_service_thread:
         return rv;
 
 kthread_run_error:
+        mtip_hw_debugfs_exit(dd);
+
         /* Delete our gendisk. This also removes the device from /dev */
         del_gendisk(dd->disk);
 
@@ -3805,6 +3862,7 @@ static int mtip_block_remove(struct driver_data *dd)
                         kobject_put(kobj);
                 }
         }
+        mtip_hw_debugfs_exit(dd);
 
         /*
          * Delete our gendisk structure. This also removes the device
@@ -4152,10 +4210,20 @@ static int __init mtip_init(void)
         }
         mtip_major = error;
 
+        if (!dfs_parent) {
+                dfs_parent = debugfs_create_dir("rssd", NULL);
+                if (IS_ERR_OR_NULL(dfs_parent)) {
+                        printk(KERN_WARNING "Error creating debugfs parent\n");
+                        dfs_parent = NULL;
+                }
+        }
+
         /* Register our PCI operations. */
         error = pci_register_driver(&mtip_pci_driver);
-        if (error)
+        if (error) {
+                debugfs_remove(dfs_parent);
                 unregister_blkdev(mtip_major, MTIP_DRV_NAME);
+        }
 
         return error;
 }
@@ -4172,6 +4240,8 @@ static int __init mtip_init(void)
  */
 static void __exit mtip_exit(void)
 {
+        debugfs_remove_recursive(dfs_parent);
+
         /* Release the allocated major block device number. */
         unregister_blkdev(mtip_major, MTIP_DRV_NAME);
 
diff --git a/drivers/block/mtip32xx/mtip32xx.h b/drivers/block/mtip32xx/mtip32xx.h
index b2c88da26b2a..f51fc23d17bb 100644
--- a/drivers/block/mtip32xx/mtip32xx.h
+++ b/drivers/block/mtip32xx/mtip32xx.h
@@ -26,7 +26,6 @@
 #include <linux/ata.h>
 #include <linux/interrupt.h>
 #include <linux/genhd.h>
-#include <linux/version.h>
 
 /* Offset of Subsystem Device ID in pci confoguration space */
 #define PCI_SUBSYSTEM_DEVICEID  0x2E
@@ -111,6 +110,8 @@
  #define dbg_printk(format, arg...)
 #endif
 
+#define MTIP_DFS_MAX_BUF_SIZE 1024
+
 #define __force_bit2int (unsigned int __force)
 
 enum {
@@ -447,6 +448,8 @@ struct driver_data {
         unsigned long dd_flag; /* NOTE: use atomic bit operations on this */
 
         struct task_struct *mtip_svc_handler; /* task_struct of svc thd */
+
+        struct dentry *dfs_node;
 };
 
 #endif
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 65665c9c42c6..8f428a8ab003 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -499,7 +499,7 @@ static int rbd_header_from_disk(struct rbd_image_header *header,
                          / sizeof (*ondisk))
                 return -EINVAL;
         header->snapc = kmalloc(sizeof(struct ceph_snap_context) +
-                                snap_count * sizeof (*ondisk),
+                                snap_count * sizeof(u64),
                                 gfp_flags);
         if (!header->snapc)
                 return -ENOMEM;
@@ -977,7 +977,7 @@ static void rbd_req_cb(struct ceph_osd_request *req, struct ceph_msg *msg)
         op = (void *)(replyhead + 1);
         rc = le32_to_cpu(replyhead->result);
         bytes = le64_to_cpu(op->extent.length);
-        read_op = (le32_to_cpu(op->op) == CEPH_OSD_OP_READ);
+        read_op = (le16_to_cpu(op->op) == CEPH_OSD_OP_READ);
 
         dout("rbd_req_cb bytes=%lld readop=%d rc=%d\n", bytes, read_op, rc);
 
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index aa2712060bfb..9a72277a31df 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -513,6 +513,44 @@ static void process_page(unsigned long data)
         }
 }
 
+struct mm_plug_cb {
+        struct blk_plug_cb cb;
+        struct cardinfo *card;
+};
+
+static void mm_unplug(struct blk_plug_cb *cb)
+{
+        struct mm_plug_cb *mmcb = container_of(cb, struct mm_plug_cb, cb);
+
+        spin_lock_irq(&mmcb->card->lock);
+        activate(mmcb->card);
+        spin_unlock_irq(&mmcb->card->lock);
+        kfree(mmcb);
+}
+
+static int mm_check_plugged(struct cardinfo *card)
+{
+        struct blk_plug *plug = current->plug;
+        struct mm_plug_cb *mmcb;
+
+        if (!plug)
+                return 0;
+
+        list_for_each_entry(mmcb, &plug->cb_list, cb.list) {
+                if (mmcb->cb.callback == mm_unplug && mmcb->card == card)
+                        return 1;
+        }
+        /* Not currently on the callback list */
+        mmcb = kmalloc(sizeof(*mmcb), GFP_ATOMIC);
+        if (!mmcb)
+                return 0;
+
+        mmcb->card = card;
+        mmcb->cb.callback = mm_unplug;
+        list_add(&mmcb->cb.list, &plug->cb_list);
+        return 1;
+}
+
 static void mm_make_request(struct request_queue *q, struct bio *bio)
 {
         struct cardinfo *card = q->queuedata;
@@ -523,6 +561,8 @@ static void mm_make_request(struct request_queue *q, struct bio *bio)
         *card->biotail = bio;
         bio->bi_next = NULL;
         card->biotail = &bio->bi_next;
+        if (bio->bi_rw & REQ_SYNC || !mm_check_plugged(card))
+                activate(card);
         spin_unlock_irq(&card->lock);
 
         return;
diff --git a/drivers/block/xen-blkback/common.h b/drivers/block/xen-blkback/common.h
index 773cf27dc23f..9ad3b5ec1dc1 100644
--- a/drivers/block/xen-blkback/common.h
+++ b/drivers/block/xen-blkback/common.h
@@ -257,6 +257,7 @@ static inline void blkif_get_x86_32_req(struct blkif_request *dst,
                 break;
         case BLKIF_OP_DISCARD:
                 dst->u.discard.flag = src->u.discard.flag;
+                dst->u.discard.id = src->u.discard.id;
                 dst->u.discard.sector_number = src->u.discard.sector_number;
                 dst->u.discard.nr_sectors = src->u.discard.nr_sectors;
                 break;
@@ -287,6 +288,7 @@ static inline void blkif_get_x86_64_req(struct blkif_request *dst,
                 break;
         case BLKIF_OP_DISCARD:
                 dst->u.discard.flag = src->u.discard.flag;
+                dst->u.discard.id = src->u.discard.id;
                 dst->u.discard.sector_number = src->u.discard.sector_number;
                 dst->u.discard.nr_sectors = src->u.discard.nr_sectors;
                 break;
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 60eed4bdd2e4..e4fb3374dcd2 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -141,14 +141,36 @@ static int get_id_from_freelist(struct blkfront_info *info)
         return free;
 }
 
-static void add_id_to_freelist(struct blkfront_info *info,
+static int add_id_to_freelist(struct blkfront_info *info,
                                unsigned long id)
 {
+        if (info->shadow[id].req.u.rw.id != id)
+                return -EINVAL;
+        if (info->shadow[id].request == NULL)
+                return -EINVAL;
         info->shadow[id].req.u.rw.id  = info->shadow_free;
         info->shadow[id].request = NULL;
         info->shadow_free = id;
+        return 0;
 }
 
+static const char *op_name(int op)
+{
+        static const char *const names[] = {
+                [BLKIF_OP_READ] = "read",
+                [BLKIF_OP_WRITE] = "write",
+                [BLKIF_OP_WRITE_BARRIER] = "barrier",
+                [BLKIF_OP_FLUSH_DISKCACHE] = "flush",
+                [BLKIF_OP_DISCARD] = "discard" };
+
+        if (op < 0 || op >= ARRAY_SIZE(names))
+                return "unknown";
+
+        if (!names[op])
+                return "reserved";
+
+        return names[op];
+}
 static int xlbd_reserve_minors(unsigned int minor, unsigned int nr)
 {
         unsigned int end = minor + nr;
@@ -746,20 +768,36 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
 
                 bret = RING_GET_RESPONSE(&info->ring, i);
                 id   = bret->id;
+                /*
+                 * The backend has messed up and given us an id that we would
+                 * never have given to it (we stamp it up to BLK_RING_SIZE -
+                 * look in get_id_from_freelist.
+                 */
+                if (id >= BLK_RING_SIZE) {
+                        WARN(1, "%s: response to %s has incorrect id (%ld)\n",
+                             info->gd->disk_name, op_name(bret->operation), id);
+                        /* We can't safely get the 'struct request' as
+                         * the id is busted. */
+                        continue;
+                }
                 req  = info->shadow[id].request;
 
                 if (bret->operation != BLKIF_OP_DISCARD)
                         blkif_completion(&info->shadow[id]);
 
-                add_id_to_freelist(info, id);
+                if (add_id_to_freelist(info, id)) {
+                        WARN(1, "%s: response to %s (id %ld) couldn't be recycled!\n",
+                             info->gd->disk_name, op_name(bret->operation), id);
+                        continue;
+                }
 
                 error = (bret->status == BLKIF_RSP_OKAY) ? 0 : -EIO;
                 switch (bret->operation) {
                 case BLKIF_OP_DISCARD:
                         if (unlikely(bret->status == BLKIF_RSP_EOPNOTSUPP)) {
                                 struct request_queue *rq = info->rq;
-                                printk(KERN_WARNING "blkfront: %s: discard op failed\n",
-                                           info->gd->disk_name);
+                                printk(KERN_WARNING "blkfront: %s: %s op failed\n",
+                                           info->gd->disk_name, op_name(bret->operation));
                                 error = -EOPNOTSUPP;
                                 info->feature_discard = 0;
                                 info->feature_secdiscard = 0;
@@ -771,18 +809,14 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
                 case BLKIF_OP_FLUSH_DISKCACHE:
                 case BLKIF_OP_WRITE_BARRIER:
                         if (unlikely(bret->status == BLKIF_RSP_EOPNOTSUPP)) {
-                                printk(KERN_WARNING "blkfront: %s: write %s op failed\n",
-                                       info->flush_op == BLKIF_OP_WRITE_BARRIER ?
-                                       "barrier" :  "flush disk cache",
-                                       info->gd->disk_name);
+                                printk(KERN_WARNING "blkfront: %s: %s op failed\n",
+                                       info->gd->disk_name, op_name(bret->operation));
                                 error = -EOPNOTSUPP;
                         }
                         if (unlikely(bret->status == BLKIF_RSP_ERROR &&
                                      info->shadow[id].req.u.rw.nr_segments == 0)) {
-                                printk(KERN_WARNING "blkfront: %s: empty write %s op failed\n",
-                                       info->flush_op == BLKIF_OP_WRITE_BARRIER ?
-                                       "barrier" :  "flush disk cache",
-                                       info->gd->disk_name);
+                                printk(KERN_WARNING "blkfront: %s: empty %s op failed\n",
+                                       info->gd->disk_name, op_name(bret->operation));
                                 error = -EOPNOTSUPP;
                         }
                         if (unlikely(error)) {
diff --git a/drivers/char/hw_random/omap-rng.c b/drivers/char/hw_random/omap-rng.c
index 1412565c01af..d706bd0e9e80 100644
--- a/drivers/char/hw_random/omap-rng.c
+++ b/drivers/char/hw_random/omap-rng.c
@@ -162,22 +162,24 @@ static int __exit omap_rng_remove(struct platform_device *pdev)
 
 #ifdef CONFIG_PM
 
-static int omap_rng_suspend(struct platform_device *pdev, pm_message_t message)
+static int omap_rng_suspend(struct device *dev)
 {
         omap_rng_write_reg(RNG_MASK_REG, 0x0);
         return 0;
 }
 
-static int omap_rng_resume(struct platform_device *pdev)
+static int omap_rng_resume(struct device *dev)
 {
         omap_rng_write_reg(RNG_MASK_REG, 0x1);
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(omap_rng_pm, omap_rng_suspend, omap_rng_resume);
+#define OMAP_RNG_PM     (&omap_rng_pm)
+
 #else
 
-#define omap_rng_suspend        NULL
-#define omap_rng_resume         NULL
+#define OMAP_RNG_PM     NULL
 
 #endif
 
@@ -188,11 +190,10 @@ static struct platform_driver omap_rng_driver = {
         .driver = {
                 .name           = "omap_rng",
                 .owner          = THIS_MODULE,
+                .pm             = OMAP_RNG_PM,
         },
         .probe          = omap_rng_probe,
         .remove         = __exit_p(omap_rng_remove),
-        .suspend        = omap_rng_suspend,
-        .resume         = omap_rng_resume
 };
 
 static int __init omap_rng_init(void)
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 1e638fff40ea..83f85cf7fb1b 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -2503,18 +2503,6 @@ static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
         cleanup_one_si(info);
 }
 
-#ifdef CONFIG_PM
-static int ipmi_pci_suspend(struct pci_dev *pdev, pm_message_t state)
-{
-        return 0;
-}
-
-static int ipmi_pci_resume(struct pci_dev *pdev)
-{
-        return 0;
-}
-#endif
-
 static struct pci_device_id ipmi_pci_devices[] = {
         { PCI_DEVICE(PCI_HP_VENDOR_ID, PCI_MMC_DEVICE_ID) },
         { PCI_DEVICE_CLASS(PCI_ERMC_CLASSCODE, PCI_ERMC_CLASSCODE_MASK) },
@@ -2527,10 +2515,6 @@ static struct pci_driver ipmi_pci_driver = {
         .id_table =     ipmi_pci_devices,
         .probe =        ipmi_pci_probe,
         .remove =       __devexit_p(ipmi_pci_remove),
-#ifdef CONFIG_PM
-        .suspend =      ipmi_pci_suspend,
-        .resume =       ipmi_pci_resume,
-#endif
 };
 #endif /* CONFIG_PCI */
 
diff --git a/drivers/char/sonypi.c b/drivers/char/sonypi.c
index 45713f0e7d61..f87780502b41 100644
--- a/drivers/char/sonypi.c
+++ b/drivers/char/sonypi.c
@@ -1459,7 +1459,7 @@ static int __devexit sonypi_remove(struct platform_device *dev)
 #ifdef CONFIG_PM
 static int old_camera_power;
 
-static int sonypi_suspend(struct platform_device *dev, pm_message_t state)
+static int sonypi_suspend(struct device *dev)
 {
         old_camera_power = sonypi_device.camera_power;
         sonypi_disable();
@@ -1467,14 +1467,16 @@ static int sonypi_suspend(struct platform_device *dev, pm_message_t state)
         return 0;
 }
 
-static int sonypi_resume(struct platform_device *dev)
+static int sonypi_resume(struct device *dev)
 {
         sonypi_enable(old_camera_power);
         return 0;
 }
+
+static SIMPLE_DEV_PM_OPS(sonypi_pm, sonypi_suspend, sonypi_resume);
+#define SONYPI_PM       (&sonypi_pm)
 #else
-#define sonypi_suspend  NULL
-#define sonypi_resume   NULL
+#define SONYPI_PM       NULL
 #endif
 
 static void sonypi_shutdown(struct platform_device *dev)
@@ -1486,12 +1488,11 @@ static struct platform_driver sonypi_driver = {
         .driver         = {
                 .name   = "sonypi",
                 .owner  = THIS_MODULE,
+                .pm     = SONYPI_PM,
         },
         .probe          = sonypi_probe,
         .remove         = __devexit_p(sonypi_remove),
         .shutdown       = sonypi_shutdown,
-        .suspend        = sonypi_suspend,
-        .resume         = sonypi_resume,
 };
 
 static struct platform_device *sonypi_platform_device;
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index ad7c7320dd1b..ae43ac55fc1e 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -1274,7 +1274,7 @@ static struct tpm_input_header savestate_header = {
  * We are about to suspend. Save the TPM state
  * so that it can be restored.
  */
-int tpm_pm_suspend(struct device *dev, pm_message_t pm_state)
+int tpm_pm_suspend(struct device *dev)
 {
         struct tpm_chip *chip = dev_get_drvdata(dev);
         struct tpm_cmd_t cmd;
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index b1c5280ac159..917f727e6740 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -299,7 +299,7 @@ extern ssize_t tpm_write(struct file *, const char __user *, size_t,
                          loff_t *);
 extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *);
 extern void tpm_remove_hardware(struct device *);
-extern int tpm_pm_suspend(struct device *, pm_message_t);
+extern int tpm_pm_suspend(struct device *);
 extern int tpm_pm_resume(struct device *);
 extern int wait_for_tpm_stat(struct tpm_chip *, u8, unsigned long,
                              wait_queue_head_t *);
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index c64a1bc65349..678d57019dc4 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -168,22 +168,14 @@ static void atml_plat_remove(void)
         }
 }
 
-static int tpm_atml_suspend(struct platform_device *dev, pm_message_t msg)
-{
-        return tpm_pm_suspend(&dev->dev, msg);
-}
+static SIMPLE_DEV_PM_OPS(tpm_atml_pm, tpm_pm_suspend, tpm_pm_resume);
 
-static int tpm_atml_resume(struct platform_device *dev)
-{
-        return tpm_pm_resume(&dev->dev);
-}
 static struct platform_driver atml_drv = {
         .driver = {
                 .name = "tpm_atmel",
                 .owner          = THIS_MODULE,
+                .pm             = &tpm_atml_pm,
         },
-        .suspend = tpm_atml_suspend,
-        .resume = tpm_atml_resume,
 };
 
 static int __init init_atmel(void)
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index 4d2464871ada..640c9a427b59 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -274,22 +274,13 @@ static void tpm_nsc_remove(struct device *dev)
         }
 }
 
-static int tpm_nsc_suspend(struct platform_device *dev, pm_message_t msg)
-{
-        return tpm_pm_suspend(&dev->dev, msg);
-}
-
-static int tpm_nsc_resume(struct platform_device *dev)
-{
-        return tpm_pm_resume(&dev->dev);
-}
+static SIMPLE_DEV_PM_OPS(tpm_nsc_pm, tpm_pm_suspend, tpm_pm_resume);
 
 static struct platform_driver nsc_drv = {
-        .suspend         = tpm_nsc_suspend,
-        .resume          = tpm_nsc_resume,
         .driver          = {
                 .name    = "tpm_nsc",
                 .owner   = THIS_MODULE,
+                .pm      = &tpm_nsc_pm,
         },
 };
 
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index d2a70cae76df..89682fa8801e 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -750,7 +750,7 @@ static int __devinit tpm_tis_pnp_init(struct pnp_dev *pnp_dev,
 
 static int tpm_tis_pnp_suspend(struct pnp_dev *dev, pm_message_t msg)
 {
-        return tpm_pm_suspend(&dev->dev, msg);
+        return tpm_pm_suspend(&dev->dev);
 }
 
 static int tpm_tis_pnp_resume(struct pnp_dev *dev)
@@ -806,27 +806,25 @@ module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
                     sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
 #endif
-static int tpm_tis_suspend(struct platform_device *dev, pm_message_t msg)
-{
-        return tpm_pm_suspend(&dev->dev, msg);
-}
 
-static int tpm_tis_resume(struct platform_device *dev)
+static int tpm_tis_resume(struct device *dev)
 {
-        struct tpm_chip *chip = dev_get_drvdata(&dev->dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
 
         if (chip->vendor.irq)
                 tpm_tis_reenable_interrupts(chip);
 
-        return tpm_pm_resume(&dev->dev);
+        return tpm_pm_resume(dev);
 }
+
+static SIMPLE_DEV_PM_OPS(tpm_tis_pm, tpm_pm_suspend, tpm_tis_resume);
+
 static struct platform_driver tis_drv = {
         .driver = {
                 .name = "tpm_tis",
                 .owner          = THIS_MODULE,
+                .pm             = &tpm_tis_pm,
         },
-        .suspend = tpm_tis_suspend,
-        .resume = tpm_tis_resume,
 };
 
 static struct platform_device *pdev;
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index dcbe05616090..9a1eb0cfa95f 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -1067,26 +1067,24 @@ static int __clk_set_parent(struct clk *clk, struct clk *parent)
 
         old_parent = clk->parent;
 
-        /* find index of new parent clock using cached parent ptrs */
-        if (clk->parents)
-                for (i = 0; i < clk->num_parents; i++)
-                        if (clk->parents[i] == parent)
-                                break;
-        else
+        if (!clk->parents)
                 clk->parents = kzalloc((sizeof(struct clk*) * clk->num_parents),
                                                                 GFP_KERNEL);
 
         /*
-         * find index of new parent clock using string name comparison
-         * also try to cache the parent to avoid future calls to __clk_lookup
+         * find index of new parent clock using cached parent ptrs,
+         * or if not yet cached, use string name comparison and cache
+         * them now to avoid future calls to __clk_lookup.
          */
-        if (i == clk->num_parents)
-                for (i = 0; i < clk->num_parents; i++)
-                        if (!strcmp(clk->parent_names[i], parent->name)) {
-                                if (clk->parents)
-                                        clk->parents[i] = __clk_lookup(parent->name);
-                                break;
-                        }
+        for (i = 0; i < clk->num_parents; i++) {
+                if (clk->parents && clk->parents[i] == parent)
+                        break;
+                else if (!strcmp(clk->parent_names[i], parent->name)) {
+                        if (clk->parents)
+                                clk->parents[i] = __clk_lookup(parent->name);
+                        break;
+                }
+        }
 
         if (i == clk->num_parents) {
                 pr_debug("%s: clock %s is not a possible parent of clock %s\n",
diff --git a/drivers/clk/spear/spear1310_clock.c b/drivers/clk/spear/spear1310_clock.c
index 8f05652d53e6..0fcec2aae19c 100644
--- a/drivers/clk/spear/spear1310_clock.c
+++ b/drivers/clk/spear/spear1310_clock.c
@@ -345,31 +345,30 @@ static struct frac_rate_tbl gen_rtbl[] = {
 /* clock parents */
 static const char *vco_parents[] = { "osc_24m_clk", "osc_25m_clk", };
 static const char *gpt_parents[] = { "osc_24m_clk", "apb_clk", };
-static const char *uart0_parents[] = { "pll5_clk", "uart_synth_gate_clk", };
-static const char *c3_parents[] = { "pll5_clk", "c3_synth_gate_clk", };
-static const char *gmac_phy_input_parents[] = { "gmii_125m_pad_clk", "pll2_clk",
+static const char *uart0_parents[] = { "pll5_clk", "uart_syn_gclk", };
+static const char *c3_parents[] = { "pll5_clk", "c3_syn_gclk", };
+static const char *gmac_phy_input_parents[] = { "gmii_pad_clk", "pll2_clk",
         "osc_25m_clk", };
-static const char *gmac_phy_parents[] = { "gmac_phy_input_mux_clk",
-        "gmac_phy_synth_gate_clk", };
+static const char *gmac_phy_parents[] = { "phy_input_mclk", "phy_syn_gclk", };
 static const char *clcd_synth_parents[] = { "vco1div4_clk", "pll2_clk", };
-static const char *clcd_pixel_parents[] = { "pll5_clk", "clcd_synth_clk", };
+static const char *clcd_pixel_parents[] = { "pll5_clk", "clcd_syn_clk", };
 static const char *i2s_src_parents[] = { "vco1div2_clk", "none", "pll3_clk",
         "i2s_src_pad_clk", };
-static const char *i2s_ref_parents[] = { "i2s_src_mux_clk", "i2s_prs1_clk", };
+static const char *i2s_ref_parents[] = { "i2s_src_mclk", "i2s_prs1_clk", };
 static const char *gen_synth0_1_parents[] = { "vco1div4_clk", "vco3div2_clk",
         "pll3_clk", };
 static const char *gen_synth2_3_parents[] = { "vco1div4_clk", "vco3div2_clk",
         "pll2_clk", };
 static const char *rmii_phy_parents[] = { "ras_tx50_clk", "none",
-        "ras_pll2_clk", "ras_synth0_clk", };
+        "ras_pll2_clk", "ras_syn0_clk", };
 static const char *smii_rgmii_phy_parents[] = { "none", "ras_tx125_clk",
-        "ras_pll2_clk", "ras_synth0_clk", };
-static const char *uart_parents[] = { "ras_apb_clk", "gen_synth3_clk", };
-static const char *i2c_parents[] = { "ras_apb_clk", "gen_synth1_clk", };
-static const char *ssp1_parents[] = { "ras_apb_clk", "gen_synth1_clk",
+        "ras_pll2_clk", "ras_syn0_clk", };
+static const char *uart_parents[] = { "ras_apb_clk", "gen_syn3_clk", };
+static const char *i2c_parents[] = { "ras_apb_clk", "gen_syn1_clk", };
+static const char *ssp1_parents[] = { "ras_apb_clk", "gen_syn1_clk",
         "ras_plclk0_clk", };
-static const char *pci_parents[] = { "ras_pll3_clk", "gen_synth2_clk", };
-static const char *tdm_parents[] = { "ras_pll3_clk", "gen_synth1_clk", };
+static const char *pci_parents[] = { "ras_pll3_clk", "gen_syn2_clk", };
+static const char *tdm_parents[] = { "ras_pll3_clk", "gen_syn1_clk", };
 
 void __init spear1310_clk_init(void)
 {
@@ -390,9 +389,9 @@ void __init spear1310_clk_init(void)
                         25000000);
         clk_register_clkdev(clk, "osc_25m_clk", NULL);
 
-        clk = clk_register_fixed_rate(NULL, "gmii_125m_pad_clk", NULL,
-                        CLK_IS_ROOT, 125000000);
-        clk_register_clkdev(clk, "gmii_125m_pad_clk", NULL);
+        clk = clk_register_fixed_rate(NULL, "gmii_pad_clk", NULL, CLK_IS_ROOT,
+                        125000000);
+        clk_register_clkdev(clk, "gmii_pad_clk", NULL);
 
         clk = clk_register_fixed_rate(NULL, "i2s_src_pad_clk", NULL,
                         CLK_IS_ROOT, 12288000);
@@ -406,34 +405,34 @@ void __init spear1310_clk_init(void)
 
         /* clock derived from 24 or 25 MHz osc clk */
         /* vco-pll */
-        clk = clk_register_mux(NULL, "vco1_mux_clk", vco_parents,
+        clk = clk_register_mux(NULL, "vco1_mclk", vco_parents,
                         ARRAY_SIZE(vco_parents), 0, SPEAR1310_PLL_CFG,
                         SPEAR1310_PLL1_CLK_SHIFT, SPEAR1310_PLL_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "vco1_mux_clk", NULL);
-        clk = clk_register_vco_pll("vco1_clk", "pll1_clk", NULL, "vco1_mux_clk",
+        clk_register_clkdev(clk, "vco1_mclk", NULL);
+        clk = clk_register_vco_pll("vco1_clk", "pll1_clk", NULL, "vco1_mclk",
                         0, SPEAR1310_PLL1_CTR, SPEAR1310_PLL1_FRQ, pll_rtbl,
                         ARRAY_SIZE(pll_rtbl), &_lock, &clk1, NULL);
         clk_register_clkdev(clk, "vco1_clk", NULL);
         clk_register_clkdev(clk1, "pll1_clk", NULL);
 
-        clk = clk_register_mux(NULL, "vco2_mux_clk", vco_parents,
+        clk = clk_register_mux(NULL, "vco2_mclk", vco_parents,
                         ARRAY_SIZE(vco_parents), 0, SPEAR1310_PLL_CFG,
                         SPEAR1310_PLL2_CLK_SHIFT, SPEAR1310_PLL_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "vco2_mux_clk", NULL);
-        clk = clk_register_vco_pll("vco2_clk", "pll2_clk", NULL, "vco2_mux_clk",
+        clk_register_clkdev(clk, "vco2_mclk", NULL);
+        clk = clk_register_vco_pll("vco2_clk", "pll2_clk", NULL, "vco2_mclk",
                         0, SPEAR1310_PLL2_CTR, SPEAR1310_PLL2_FRQ, pll_rtbl,
                         ARRAY_SIZE(pll_rtbl), &_lock, &clk1, NULL);
         clk_register_clkdev(clk, "vco2_clk", NULL);
         clk_register_clkdev(clk1, "pll2_clk", NULL);
 
-        clk = clk_register_mux(NULL, "vco3_mux_clk", vco_parents,
+        clk = clk_register_mux(NULL, "vco3_mclk", vco_parents,
                         ARRAY_SIZE(vco_parents), 0, SPEAR1310_PLL_CFG,
                         SPEAR1310_PLL3_CLK_SHIFT, SPEAR1310_PLL_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "vco3_mux_clk", NULL);
-        clk = clk_register_vco_pll("vco3_clk", "pll3_clk", NULL, "vco3_mux_clk",
+        clk_register_clkdev(clk, "vco3_mclk", NULL);
+        clk = clk_register_vco_pll("vco3_clk", "pll3_clk", NULL, "vco3_mclk",
                         0, SPEAR1310_PLL3_CTR, SPEAR1310_PLL3_FRQ, pll_rtbl,
                         ARRAY_SIZE(pll_rtbl), &_lock, &clk1, NULL);
         clk_register_clkdev(clk, "vco3_clk", NULL);
@@ -473,7 +472,7 @@ void __init spear1310_clk_init(void)
         /* peripherals */
         clk_register_fixed_factor(NULL, "thermal_clk", "osc_24m_clk", 0, 1,
                         128);
-        clk = clk_register_gate(NULL, "thermal_gate_clk", "thermal_clk", 0,
+        clk = clk_register_gate(NULL, "thermal_gclk", "thermal_clk", 0,
                         SPEAR1310_PERIP2_CLK_ENB, SPEAR1310_THSENS_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "spear_thermal");
@@ -500,177 +499,176 @@ void __init spear1310_clk_init(void)
         clk_register_clkdev(clk, "apb_clk", NULL);
 
         /* gpt clocks */
-        clk = clk_register_mux(NULL, "gpt0_mux_clk", gpt_parents,
+        clk = clk_register_mux(NULL, "gpt0_mclk", gpt_parents,
                         ARRAY_SIZE(gpt_parents), 0, SPEAR1310_PERIP_CLK_CFG,
                         SPEAR1310_GPT0_CLK_SHIFT, SPEAR1310_GPT_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "gpt0_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt0_clk", "gpt0_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt0_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt0_clk", "gpt0_mclk", 0,
                         SPEAR1310_PERIP1_CLK_ENB, SPEAR1310_GPT0_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "gpt0");
 
-        clk = clk_register_mux(NULL, "gpt1_mux_clk", gpt_parents,
+        clk = clk_register_mux(NULL, "gpt1_mclk", gpt_parents,
                         ARRAY_SIZE(gpt_parents), 0, SPEAR1310_PERIP_CLK_CFG,
                         SPEAR1310_GPT1_CLK_SHIFT, SPEAR1310_GPT_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "gpt1_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt1_clk", "gpt1_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt1_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt1_clk", "gpt1_mclk", 0,
                         SPEAR1310_PERIP1_CLK_ENB, SPEAR1310_GPT1_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "gpt1");
 
-        clk = clk_register_mux(NULL, "gpt2_mux_clk", gpt_parents,
+        clk = clk_register_mux(NULL, "gpt2_mclk", gpt_parents,
                         ARRAY_SIZE(gpt_parents), 0, SPEAR1310_PERIP_CLK_CFG,
                         SPEAR1310_GPT2_CLK_SHIFT, SPEAR1310_GPT_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "gpt2_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt2_clk", "gpt2_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt2_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt2_clk", "gpt2_mclk", 0,
                         SPEAR1310_PERIP2_CLK_ENB, SPEAR1310_GPT2_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "gpt2");
 
-        clk = clk_register_mux(NULL, "gpt3_mux_clk", gpt_parents,
+        clk = clk_register_mux(NULL, "gpt3_mclk", gpt_parents,
                         ARRAY_SIZE(gpt_parents), 0, SPEAR1310_PERIP_CLK_CFG,
                         SPEAR1310_GPT3_CLK_SHIFT, SPEAR1310_GPT_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "gpt3_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt3_clk", "gpt3_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt3_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt3_clk", "gpt3_mclk", 0,
                         SPEAR1310_PERIP2_CLK_ENB, SPEAR1310_GPT3_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "gpt3");
 
         /* others */
-        clk = clk_register_aux("uart_synth_clk", "uart_synth_gate_clk",
-                        "vco1div2_clk", 0, SPEAR1310_UART_CLK_SYNT, NULL,
-                        aux_rtbl, ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "uart_synth_clk", NULL);
-        clk_register_clkdev(clk1, "uart_synth_gate_clk", NULL);
+        clk = clk_register_aux("uart_syn_clk", "uart_syn_gclk", "vco1div2_clk",
+                        0, SPEAR1310_UART_CLK_SYNT, NULL, aux_rtbl,
+                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
+        clk_register_clkdev(clk, "uart_syn_clk", NULL);
+        clk_register_clkdev(clk1, "uart_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "uart0_mux_clk", uart0_parents,
+        clk = clk_register_mux(NULL, "uart0_mclk", uart0_parents,
                         ARRAY_SIZE(uart0_parents), 0, SPEAR1310_PERIP_CLK_CFG,
                         SPEAR1310_UART_CLK_SHIFT, SPEAR1310_UART_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "uart0_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart0_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart0_clk", "uart0_mux_clk", 0,
+        clk = clk_register_gate(NULL, "uart0_clk", "uart0_mclk", 0,
                         SPEAR1310_PERIP1_CLK_ENB, SPEAR1310_UART_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "e0000000.serial");
 
-        clk = clk_register_aux("sdhci_synth_clk", "sdhci_synth_gate_clk",
+        clk = clk_register_aux("sdhci_syn_clk", "sdhci_syn_gclk",
                         "vco1div2_clk", 0, SPEAR1310_SDHCI_CLK_SYNT, NULL,
                         aux_rtbl, ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "sdhci_synth_clk", NULL);
-        clk_register_clkdev(clk1, "sdhci_synth_gate_clk", NULL);
+        clk_register_clkdev(clk, "sdhci_syn_clk", NULL);
+        clk_register_clkdev(clk1, "sdhci_syn_gclk", NULL);
 
-        clk = clk_register_gate(NULL, "sdhci_clk", "sdhci_synth_gate_clk", 0,
+        clk = clk_register_gate(NULL, "sdhci_clk", "sdhci_syn_gclk", 0,
                         SPEAR1310_PERIP1_CLK_ENB, SPEAR1310_SDHCI_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "b3000000.sdhci");
 
-        clk = clk_register_aux("cfxd_synth_clk", "cfxd_synth_gate_clk",
-                        "vco1div2_clk", 0, SPEAR1310_CFXD_CLK_SYNT, NULL,
-                        aux_rtbl, ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "cfxd_synth_clk", NULL);
-        clk_register_clkdev(clk1, "cfxd_synth_gate_clk", NULL);
+        clk = clk_register_aux("cfxd_syn_clk", "cfxd_syn_gclk", "vco1div2_clk",
+                        0, SPEAR1310_CFXD_CLK_SYNT, NULL, aux_rtbl,
+                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
+        clk_register_clkdev(clk, "cfxd_syn_clk", NULL);
+        clk_register_clkdev(clk1, "cfxd_syn_gclk", NULL);
 
-        clk = clk_register_gate(NULL, "cfxd_clk", "cfxd_synth_gate_clk", 0,
+        clk = clk_register_gate(NULL, "cfxd_clk", "cfxd_syn_gclk", 0,
                         SPEAR1310_PERIP1_CLK_ENB, SPEAR1310_CFXD_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "b2800000.cf");
         clk_register_clkdev(clk, NULL, "arasan_xd");
 
-        clk = clk_register_aux("c3_synth_clk", "c3_synth_gate_clk",
-                        "vco1div2_clk", 0, SPEAR1310_C3_CLK_SYNT, NULL,
-                        aux_rtbl, ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "c3_synth_clk", NULL);
-        clk_register_clkdev(clk1, "c3_synth_gate_clk", NULL);
+        clk = clk_register_aux("c3_syn_clk", "c3_syn_gclk", "vco1div2_clk",
+                        0, SPEAR1310_C3_CLK_SYNT, NULL, aux_rtbl,
+                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
+        clk_register_clkdev(clk, "c3_syn_clk", NULL);
+        clk_register_clkdev(clk1, "c3_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "c3_mux_clk", c3_parents,
+        clk = clk_register_mux(NULL, "c3_mclk", c3_parents,
                         ARRAY_SIZE(c3_parents), 0, SPEAR1310_PERIP_CLK_CFG,
                         SPEAR1310_C3_CLK_SHIFT, SPEAR1310_C3_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "c3_mux_clk", NULL);
+        clk_register_clkdev(clk, "c3_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "c3_clk", "c3_mux_clk", 0,
+        clk = clk_register_gate(NULL, "c3_clk", "c3_mclk", 0,
                         SPEAR1310_PERIP1_CLK_ENB, SPEAR1310_C3_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "c3");
 
         /* gmac */
-        clk = clk_register_mux(NULL, "gmac_phy_input_mux_clk",
-                        gmac_phy_input_parents,
+        clk = clk_register_mux(NULL, "phy_input_mclk", gmac_phy_input_parents,
                         ARRAY_SIZE(gmac_phy_input_parents), 0,
                         SPEAR1310_GMAC_CLK_CFG,
                         SPEAR1310_GMAC_PHY_INPUT_CLK_SHIFT,
                         SPEAR1310_GMAC_PHY_INPUT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gmac_phy_input_mux_clk", NULL);
+        clk_register_clkdev(clk, "phy_input_mclk", NULL);
 
-        clk = clk_register_aux("gmac_phy_synth_clk", "gmac_phy_synth_gate_clk",
-                        "gmac_phy_input_mux_clk", 0, SPEAR1310_GMAC_CLK_SYNT,
-                        NULL, gmac_rtbl, ARRAY_SIZE(gmac_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "gmac_phy_synth_clk", NULL);
-        clk_register_clkdev(clk1, "gmac_phy_synth_gate_clk", NULL);
+        clk = clk_register_aux("phy_syn_clk", "phy_syn_gclk", "phy_input_mclk",
+                        0, SPEAR1310_GMAC_CLK_SYNT, NULL, gmac_rtbl,
+                        ARRAY_SIZE(gmac_rtbl), &_lock, &clk1);
+        clk_register_clkdev(clk, "phy_syn_clk", NULL);
+        clk_register_clkdev(clk1, "phy_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "gmac_phy_mux_clk", gmac_phy_parents,
+        clk = clk_register_mux(NULL, "phy_mclk", gmac_phy_parents,
                         ARRAY_SIZE(gmac_phy_parents), 0,
                         SPEAR1310_PERIP_CLK_CFG, SPEAR1310_GMAC_PHY_CLK_SHIFT,
                         SPEAR1310_GMAC_PHY_CLK_MASK, 0, &_lock);
         clk_register_clkdev(clk, NULL, "stmmacphy.0");
 
         /* clcd */
-        clk = clk_register_mux(NULL, "clcd_synth_mux_clk", clcd_synth_parents,
+        clk = clk_register_mux(NULL, "clcd_syn_mclk", clcd_synth_parents,
                         ARRAY_SIZE(clcd_synth_parents), 0,
                         SPEAR1310_CLCD_CLK_SYNT, SPEAR1310_CLCD_SYNT_CLK_SHIFT,
                         SPEAR1310_CLCD_SYNT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "clcd_synth_mux_clk", NULL);
+        clk_register_clkdev(clk, "clcd_syn_mclk", NULL);
 
-        clk = clk_register_frac("clcd_synth_clk", "clcd_synth_mux_clk", 0,
+        clk = clk_register_frac("clcd_syn_clk", "clcd_syn_mclk", 0,
                         SPEAR1310_CLCD_CLK_SYNT, clcd_rtbl,
                         ARRAY_SIZE(clcd_rtbl), &_lock);
-        clk_register_clkdev(clk, "clcd_synth_clk", NULL);
+        clk_register_clkdev(clk, "clcd_syn_clk", NULL);
 
-        clk = clk_register_mux(NULL, "clcd_pixel_mux_clk", clcd_pixel_parents,
+        clk = clk_register_mux(NULL, "clcd_pixel_mclk", clcd_pixel_parents,
                         ARRAY_SIZE(clcd_pixel_parents), 0,
                         SPEAR1310_PERIP_CLK_CFG, SPEAR1310_CLCD_CLK_SHIFT,
                         SPEAR1310_CLCD_CLK_MASK, 0, &_lock);
         clk_register_clkdev(clk, "clcd_pixel_clk", NULL);
 
-        clk = clk_register_gate(NULL, "clcd_clk", "clcd_pixel_mux_clk", 0,
+        clk = clk_register_gate(NULL, "clcd_clk", "clcd_pixel_mclk", 0,
                         SPEAR1310_PERIP1_CLK_ENB, SPEAR1310_CLCD_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, "clcd_clk", NULL);
 
         /* i2s */
-        clk = clk_register_mux(NULL, "i2s_src_mux_clk", i2s_src_parents,
+        clk = clk_register_mux(NULL, "i2s_src_mclk", i2s_src_parents,
                         ARRAY_SIZE(i2s_src_parents), 0, SPEAR1310_I2S_CLK_CFG,
                         SPEAR1310_I2S_SRC_CLK_SHIFT, SPEAR1310_I2S_SRC_CLK_MASK,
                         0, &_lock);
         clk_register_clkdev(clk, "i2s_src_clk", NULL);
 
-        clk = clk_register_aux("i2s_prs1_clk", NULL, "i2s_src_mux_clk", 0,
+        clk = clk_register_aux("i2s_prs1_clk", NULL, "i2s_src_mclk", 0,
                         SPEAR1310_I2S_CLK_CFG, &i2s_prs1_masks, i2s_prs1_rtbl,
                         ARRAY_SIZE(i2s_prs1_rtbl), &_lock, NULL);
         clk_register_clkdev(clk, "i2s_prs1_clk", NULL);
 
-        clk = clk_register_mux(NULL, "i2s_ref_mux_clk", i2s_ref_parents,
+        clk = clk_register_mux(NULL, "i2s_ref_mclk", i2s_ref_parents,
                         ARRAY_SIZE(i2s_ref_parents), 0, SPEAR1310_I2S_CLK_CFG,
                         SPEAR1310_I2S_REF_SHIFT, SPEAR1310_I2S_REF_SEL_MASK, 0,
                         &_lock);
         clk_register_clkdev(clk, "i2s_ref_clk", NULL);
 
-        clk = clk_register_gate(NULL, "i2s_ref_pad_clk", "i2s_ref_mux_clk", 0,
+        clk = clk_register_gate(NULL, "i2s_ref_pad_clk", "i2s_ref_mclk", 0,
                         SPEAR1310_PERIP2_CLK_ENB, SPEAR1310_I2S_REF_PAD_CLK_ENB,
                         0, &_lock);
         clk_register_clkdev(clk, "i2s_ref_pad_clk", NULL);
 
-        clk = clk_register_aux("i2s_sclk_clk", "i2s_sclk_gate_clk",
+        clk = clk_register_aux("i2s_sclk_clk", "i2s_sclk_gclk",
                         "i2s_ref_pad_clk", 0, SPEAR1310_I2S_CLK_CFG,
                         &i2s_sclk_masks, i2s_sclk_rtbl,
                         ARRAY_SIZE(i2s_sclk_rtbl), &_lock, &clk1);
         clk_register_clkdev(clk, "i2s_sclk_clk", NULL);
-        clk_register_clkdev(clk1, "i2s_sclk_gate_clk", NULL);
+        clk_register_clkdev(clk1, "i2s_sclk_gclk", NULL);
 
         /* clock derived from ahb clk */
         clk = clk_register_gate(NULL, "i2c0_clk", "ahb_clk", 0,
@@ -747,13 +745,13 @@ void __init spear1310_clk_init(void)
                         &_lock);
         clk_register_clkdev(clk, "sysram1_clk", NULL);
 
-        clk = clk_register_aux("adc_synth_clk", "adc_synth_gate_clk", "ahb_clk",
+        clk = clk_register_aux("adc_syn_clk", "adc_syn_gclk", "ahb_clk",
                         0, SPEAR1310_ADC_CLK_SYNT, NULL, adc_rtbl,
                         ARRAY_SIZE(adc_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "adc_synth_clk", NULL);
-        clk_register_clkdev(clk1, "adc_synth_gate_clk", NULL);
+        clk_register_clkdev(clk, "adc_syn_clk", NULL);
+        clk_register_clkdev(clk1, "adc_syn_gclk", NULL);
 
-        clk = clk_register_gate(NULL, "adc_clk", "adc_synth_gate_clk", 0,
+        clk = clk_register_gate(NULL, "adc_clk", "adc_syn_gclk", 0,
                         SPEAR1310_PERIP1_CLK_ENB, SPEAR1310_ADC_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "adc_clk");
@@ -790,37 +788,37 @@ void __init spear1310_clk_init(void)
         clk_register_clkdev(clk, NULL, "e0300000.kbd");
 
         /* RAS clks */
-        clk = clk_register_mux(NULL, "gen_synth0_1_mux_clk",
-                        gen_synth0_1_parents, ARRAY_SIZE(gen_synth0_1_parents),
-                        0, SPEAR1310_PLL_CFG, SPEAR1310_RAS_SYNT0_1_CLK_SHIFT,
+        clk = clk_register_mux(NULL, "gen_syn0_1_mclk", gen_synth0_1_parents,
+                        ARRAY_SIZE(gen_synth0_1_parents), 0, SPEAR1310_PLL_CFG,
+                        SPEAR1310_RAS_SYNT0_1_CLK_SHIFT,
                         SPEAR1310_RAS_SYNT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gen_synth0_1_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn0_1_clk", NULL);
 
-        clk = clk_register_mux(NULL, "gen_synth2_3_mux_clk",
-                        gen_synth2_3_parents, ARRAY_SIZE(gen_synth2_3_parents),
-                        0, SPEAR1310_PLL_CFG, SPEAR1310_RAS_SYNT2_3_CLK_SHIFT,
+        clk = clk_register_mux(NULL, "gen_syn2_3_mclk", gen_synth2_3_parents,
+                        ARRAY_SIZE(gen_synth2_3_parents), 0, SPEAR1310_PLL_CFG,
+                        SPEAR1310_RAS_SYNT2_3_CLK_SHIFT,
                         SPEAR1310_RAS_SYNT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gen_synth2_3_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn2_3_clk", NULL);
 
-        clk = clk_register_frac("gen_synth0_clk", "gen_synth0_1_clk", 0,
+        clk = clk_register_frac("gen_syn0_clk", "gen_syn0_1_clk", 0,
                         SPEAR1310_RAS_CLK_SYNT0, gen_rtbl, ARRAY_SIZE(gen_rtbl),
                         &_lock);
-        clk_register_clkdev(clk, "gen_synth0_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn0_clk", NULL);
 
-        clk = clk_register_frac("gen_synth1_clk", "gen_synth0_1_clk", 0,
+        clk = clk_register_frac("gen_syn1_clk", "gen_syn0_1_clk", 0,
                         SPEAR1310_RAS_CLK_SYNT1, gen_rtbl, ARRAY_SIZE(gen_rtbl),
                         &_lock);
-        clk_register_clkdev(clk, "gen_synth1_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn1_clk", NULL);
 
-        clk = clk_register_frac("gen_synth2_clk", "gen_synth2_3_clk", 0,
+        clk = clk_register_frac("gen_syn2_clk", "gen_syn2_3_clk", 0,
                         SPEAR1310_RAS_CLK_SYNT2, gen_rtbl, ARRAY_SIZE(gen_rtbl),
                         &_lock);
-        clk_register_clkdev(clk, "gen_synth2_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn2_clk", NULL);
 
-        clk = clk_register_frac("gen_synth3_clk", "gen_synth2_3_clk", 0,
+        clk = clk_register_frac("gen_syn3_clk", "gen_syn2_3_clk", 0,
                         SPEAR1310_RAS_CLK_SYNT3, gen_rtbl, ARRAY_SIZE(gen_rtbl),
                         &_lock);
-        clk_register_clkdev(clk, "gen_synth3_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn3_clk", NULL);
 
         clk = clk_register_gate(NULL, "ras_osc_24m_clk", "osc_24m_clk", 0,
                         SPEAR1310_RAS_CLK_ENB, SPEAR1310_OSC_24M_CLK_ENB, 0,
@@ -847,7 +845,7 @@ void __init spear1310_clk_init(void)
                         &_lock);
         clk_register_clkdev(clk, "ras_pll3_clk", NULL);
 
-        clk = clk_register_gate(NULL, "ras_tx125_clk", "gmii_125m_pad_clk", 0,
+        clk = clk_register_gate(NULL, "ras_tx125_clk", "gmii_pad_clk", 0,
                         SPEAR1310_RAS_CLK_ENB, SPEAR1310_C125M_PAD_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, "ras_tx125_clk", NULL);
@@ -912,7 +910,7 @@ void __init spear1310_clk_init(void)
                         &_lock);
         clk_register_clkdev(clk, NULL, "5c700000.eth");
 
-        clk = clk_register_mux(NULL, "smii_rgmii_phy_mux_clk",
+        clk = clk_register_mux(NULL, "smii_rgmii_phy_mclk",
                         smii_rgmii_phy_parents,
                         ARRAY_SIZE(smii_rgmii_phy_parents), 0,
                         SPEAR1310_RAS_CTRL_REG1,
@@ -922,184 +920,184 @@ void __init spear1310_clk_init(void)
         clk_register_clkdev(clk, NULL, "stmmacphy.2");
         clk_register_clkdev(clk, NULL, "stmmacphy.4");
 
-        clk = clk_register_mux(NULL, "rmii_phy_mux_clk", rmii_phy_parents,
+        clk = clk_register_mux(NULL, "rmii_phy_mclk", rmii_phy_parents,
                         ARRAY_SIZE(rmii_phy_parents), 0,
                         SPEAR1310_RAS_CTRL_REG1, SPEAR1310_RMII_PHY_CLK_SHIFT,
                         SPEAR1310_PHY_CLK_MASK, 0, &_lock);
         clk_register_clkdev(clk, NULL, "stmmacphy.3");
 
-        clk = clk_register_mux(NULL, "uart1_mux_clk", uart_parents,
+        clk = clk_register_mux(NULL, "uart1_mclk", uart_parents,
                         ARRAY_SIZE(uart_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_UART1_CLK_SHIFT, SPEAR1310_RAS_UART_CLK_MASK,
                         0, &_lock);
-        clk_register_clkdev(clk, "uart1_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart1_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart1_clk", "uart1_mux_clk", 0,
+        clk = clk_register_gate(NULL, "uart1_clk", "uart1_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_UART1_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5c800000.serial");
 
-        clk = clk_register_mux(NULL, "uart2_mux_clk", uart_parents,
+        clk = clk_register_mux(NULL, "uart2_mclk", uart_parents,
                         ARRAY_SIZE(uart_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_UART2_CLK_SHIFT, SPEAR1310_RAS_UART_CLK_MASK,
                         0, &_lock);
-        clk_register_clkdev(clk, "uart2_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart2_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart2_clk", "uart2_mux_clk", 0,
+        clk = clk_register_gate(NULL, "uart2_clk", "uart2_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_UART2_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5c900000.serial");
 
-        clk = clk_register_mux(NULL, "uart3_mux_clk", uart_parents,
+        clk = clk_register_mux(NULL, "uart3_mclk", uart_parents,
                         ARRAY_SIZE(uart_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_UART3_CLK_SHIFT, SPEAR1310_RAS_UART_CLK_MASK,
                         0, &_lock);
-        clk_register_clkdev(clk, "uart3_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart3_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart3_clk", "uart3_mux_clk", 0,
+        clk = clk_register_gate(NULL, "uart3_clk", "uart3_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_UART3_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5ca00000.serial");
 
-        clk = clk_register_mux(NULL, "uart4_mux_clk", uart_parents,
+        clk = clk_register_mux(NULL, "uart4_mclk", uart_parents,
                         ARRAY_SIZE(uart_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_UART4_CLK_SHIFT, SPEAR1310_RAS_UART_CLK_MASK,
                         0, &_lock);
-        clk_register_clkdev(clk, "uart4_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart4_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart4_clk", "uart4_mux_clk", 0,
+        clk = clk_register_gate(NULL, "uart4_clk", "uart4_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_UART4_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5cb00000.serial");
 
-        clk = clk_register_mux(NULL, "uart5_mux_clk", uart_parents,
+        clk = clk_register_mux(NULL, "uart5_mclk", uart_parents,
                         ARRAY_SIZE(uart_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_UART5_CLK_SHIFT, SPEAR1310_RAS_UART_CLK_MASK,
                         0, &_lock);
-        clk_register_clkdev(clk, "uart5_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart5_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart5_clk", "uart5_mux_clk", 0,
+        clk = clk_register_gate(NULL, "uart5_clk", "uart5_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_UART5_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5cc00000.serial");
 
-        clk = clk_register_mux(NULL, "i2c1_mux_clk", i2c_parents,
+        clk = clk_register_mux(NULL, "i2c1_mclk", i2c_parents,
                         ARRAY_SIZE(i2c_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_I2C1_CLK_SHIFT, SPEAR1310_I2C_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "i2c1_mux_clk", NULL);
+        clk_register_clkdev(clk, "i2c1_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "i2c1_clk", "i2c1_mux_clk", 0,
+        clk = clk_register_gate(NULL, "i2c1_clk", "i2c1_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_I2C1_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5cd00000.i2c");
 
-        clk = clk_register_mux(NULL, "i2c2_mux_clk", i2c_parents,
+        clk = clk_register_mux(NULL, "i2c2_mclk", i2c_parents,
                         ARRAY_SIZE(i2c_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_I2C2_CLK_SHIFT, SPEAR1310_I2C_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "i2c2_mux_clk", NULL);
+        clk_register_clkdev(clk, "i2c2_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "i2c2_clk", "i2c2_mux_clk", 0,
+        clk = clk_register_gate(NULL, "i2c2_clk", "i2c2_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_I2C2_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5ce00000.i2c");
 
-        clk = clk_register_mux(NULL, "i2c3_mux_clk", i2c_parents,
+        clk = clk_register_mux(NULL, "i2c3_mclk", i2c_parents,
                         ARRAY_SIZE(i2c_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_I2C3_CLK_SHIFT, SPEAR1310_I2C_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "i2c3_mux_clk", NULL);
+        clk_register_clkdev(clk, "i2c3_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "i2c3_clk", "i2c3_mux_clk", 0,
+        clk = clk_register_gate(NULL, "i2c3_clk", "i2c3_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_I2C3_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5cf00000.i2c");
 
-        clk = clk_register_mux(NULL, "i2c4_mux_clk", i2c_parents,
+        clk = clk_register_mux(NULL, "i2c4_mclk", i2c_parents,
                         ARRAY_SIZE(i2c_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_I2C4_CLK_SHIFT, SPEAR1310_I2C_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "i2c4_mux_clk", NULL);
+        clk_register_clkdev(clk, "i2c4_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "i2c4_clk", "i2c4_mux_clk", 0,
+        clk = clk_register_gate(NULL, "i2c4_clk", "i2c4_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_I2C4_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5d000000.i2c");
 
-        clk = clk_register_mux(NULL, "i2c5_mux_clk", i2c_parents,
+        clk = clk_register_mux(NULL, "i2c5_mclk", i2c_parents,
                         ARRAY_SIZE(i2c_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_I2C5_CLK_SHIFT, SPEAR1310_I2C_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "i2c5_mux_clk", NULL);
+        clk_register_clkdev(clk, "i2c5_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "i2c5_clk", "i2c5_mux_clk", 0,
+        clk = clk_register_gate(NULL, "i2c5_clk", "i2c5_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_I2C5_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5d100000.i2c");
 
-        clk = clk_register_mux(NULL, "i2c6_mux_clk", i2c_parents,
+        clk = clk_register_mux(NULL, "i2c6_mclk", i2c_parents,
                         ARRAY_SIZE(i2c_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_I2C6_CLK_SHIFT, SPEAR1310_I2C_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "i2c6_mux_clk", NULL);
+        clk_register_clkdev(clk, "i2c6_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "i2c6_clk", "i2c6_mux_clk", 0,
+        clk = clk_register_gate(NULL, "i2c6_clk", "i2c6_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_I2C6_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5d200000.i2c");
 
-        clk = clk_register_mux(NULL, "i2c7_mux_clk", i2c_parents,
+        clk = clk_register_mux(NULL, "i2c7_mclk", i2c_parents,
                         ARRAY_SIZE(i2c_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_I2C7_CLK_SHIFT, SPEAR1310_I2C_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "i2c7_mux_clk", NULL);
+        clk_register_clkdev(clk, "i2c7_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "i2c7_clk", "i2c7_mux_clk", 0,
+        clk = clk_register_gate(NULL, "i2c7_clk", "i2c7_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_I2C7_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5d300000.i2c");
 
-        clk = clk_register_mux(NULL, "ssp1_mux_clk", ssp1_parents,
+        clk = clk_register_mux(NULL, "ssp1_mclk", ssp1_parents,
                         ARRAY_SIZE(ssp1_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_SSP1_CLK_SHIFT, SPEAR1310_SSP1_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "ssp1_mux_clk", NULL);
+        clk_register_clkdev(clk, "ssp1_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "ssp1_clk", "ssp1_mux_clk", 0,
+        clk = clk_register_gate(NULL, "ssp1_clk", "ssp1_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_SSP1_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "5d400000.spi");
 
-        clk = clk_register_mux(NULL, "pci_mux_clk", pci_parents,
+        clk = clk_register_mux(NULL, "pci_mclk", pci_parents,
                         ARRAY_SIZE(pci_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_PCI_CLK_SHIFT, SPEAR1310_PCI_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "pci_mux_clk", NULL);
+        clk_register_clkdev(clk, "pci_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "pci_clk", "pci_mux_clk", 0,
+        clk = clk_register_gate(NULL, "pci_clk", "pci_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_PCI_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "pci");
 
-        clk = clk_register_mux(NULL, "tdm1_mux_clk", tdm_parents,
+        clk = clk_register_mux(NULL, "tdm1_mclk", tdm_parents,
                         ARRAY_SIZE(tdm_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_TDM1_CLK_SHIFT, SPEAR1310_TDM_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "tdm1_mux_clk", NULL);
+        clk_register_clkdev(clk, "tdm1_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "tdm1_clk", "tdm1_mux_clk", 0,
+        clk = clk_register_gate(NULL, "tdm1_clk", "tdm1_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_TDM1_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "tdm_hdlc.0");
 
-        clk = clk_register_mux(NULL, "tdm2_mux_clk", tdm_parents,
+        clk = clk_register_mux(NULL, "tdm2_mclk", tdm_parents,
                         ARRAY_SIZE(tdm_parents), 0, SPEAR1310_RAS_CTRL_REG0,
                         SPEAR1310_TDM2_CLK_SHIFT, SPEAR1310_TDM_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "tdm2_mux_clk", NULL);
+        clk_register_clkdev(clk, "tdm2_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "tdm2_clk", "tdm2_mux_clk", 0,
+        clk = clk_register_gate(NULL, "tdm2_clk", "tdm2_mclk", 0,
                         SPEAR1310_RAS_SW_CLK_CTRL, SPEAR1310_TDM2_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "tdm_hdlc.1");
diff --git a/drivers/clk/spear/spear1340_clock.c b/drivers/clk/spear/spear1340_clock.c
index e3ea72162236..2352cee7f645 100644
--- a/drivers/clk/spear/spear1340_clock.c
+++ b/drivers/clk/spear/spear1340_clock.c
@@ -369,27 +369,25 @@ static struct frac_rate_tbl gen_rtbl[] = {
 
 /* clock parents */
 static const char *vco_parents[] = { "osc_24m_clk", "osc_25m_clk", };
-static const char *sys_parents[] = { "none", "pll1_clk", "none", "none",
-        "sys_synth_clk", "none", "pll2_clk", "pll3_clk", };
-static const char *ahb_parents[] = { "cpu_div3_clk", "amba_synth_clk", };
+static const char *sys_parents[] = { "pll1_clk", "pll1_clk", "pll1_clk",
+        "pll1_clk", "sys_synth_clk", "sys_synth_clk", "pll2_clk", "pll3_clk", };
+static const char *ahb_parents[] = { "cpu_div3_clk", "amba_syn_clk", };
 static const char *gpt_parents[] = { "osc_24m_clk", "apb_clk", };
 static const char *uart0_parents[] = { "pll5_clk", "osc_24m_clk",
-        "uart0_synth_gate_clk", };
+        "uart0_syn_gclk", };
 static const char *uart1_parents[] = { "pll5_clk", "osc_24m_clk",
-        "uart1_synth_gate_clk", };
-static const char *c3_parents[] = { "pll5_clk", "c3_synth_gate_clk", };
-static const char *gmac_phy_input_parents[] = { "gmii_125m_pad_clk", "pll2_clk",
+        "uart1_syn_gclk", };
+static const char *c3_parents[] = { "pll5_clk", "c3_syn_gclk", };
+static const char *gmac_phy_input_parents[] = { "gmii_pad_clk", "pll2_clk",
         "osc_25m_clk", };
-static const char *gmac_phy_parents[] = { "gmac_phy_input_mux_clk",
-        "gmac_phy_synth_gate_clk", };
+static const char *gmac_phy_parents[] = { "phy_input_mclk", "phy_syn_gclk", };
 static const char *clcd_synth_parents[] = { "vco1div4_clk", "pll2_clk", };
-static const char *clcd_pixel_parents[] = { "pll5_clk", "clcd_synth_clk", };
+static const char *clcd_pixel_parents[] = { "pll5_clk", "clcd_syn_clk", };
 static const char *i2s_src_parents[] = { "vco1div2_clk", "pll2_clk", "pll3_clk",
         "i2s_src_pad_clk", };
-static const char *i2s_ref_parents[] = { "i2s_src_mux_clk", "i2s_prs1_clk", };
-static const char *spdif_out_parents[] = { "i2s_src_pad_clk", "gen_synth2_clk",
-};
-static const char *spdif_in_parents[] = { "pll2_clk", "gen_synth3_clk", };
+static const char *i2s_ref_parents[] = { "i2s_src_mclk", "i2s_prs1_clk", };
+static const char *spdif_out_parents[] = { "i2s_src_pad_clk", "gen_syn2_clk", };
+static const char *spdif_in_parents[] = { "pll2_clk", "gen_syn3_clk", };
 
 static const char *gen_synth0_1_parents[] = { "vco1div4_clk", "vco3div2_clk",
         "pll3_clk", };
@@ -415,9 +413,9 @@ void __init spear1340_clk_init(void)
                         25000000);
         clk_register_clkdev(clk, "osc_25m_clk", NULL);
 
-        clk = clk_register_fixed_rate(NULL, "gmii_125m_pad_clk", NULL,
-                        CLK_IS_ROOT, 125000000);
-        clk_register_clkdev(clk, "gmii_125m_pad_clk", NULL);
+        clk = clk_register_fixed_rate(NULL, "gmii_pad_clk", NULL, CLK_IS_ROOT,
+                        125000000);
+        clk_register_clkdev(clk, "gmii_pad_clk", NULL);
 
         clk = clk_register_fixed_rate(NULL, "i2s_src_pad_clk", NULL,
                         CLK_IS_ROOT, 12288000);
@@ -431,35 +429,35 @@ void __init spear1340_clk_init(void)
 
         /* clock derived from 24 or 25 MHz osc clk */
         /* vco-pll */
-        clk = clk_register_mux(NULL, "vco1_mux_clk", vco_parents,
+        clk = clk_register_mux(NULL, "vco1_mclk", vco_parents,
                         ARRAY_SIZE(vco_parents), 0, SPEAR1340_PLL_CFG,
                         SPEAR1340_PLL1_CLK_SHIFT, SPEAR1340_PLL_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "vco1_mux_clk", NULL);
-        clk = clk_register_vco_pll("vco1_clk", "pll1_clk", NULL, "vco1_mux_clk",
-                        0, SPEAR1340_PLL1_CTR, SPEAR1340_PLL1_FRQ, pll_rtbl,
+        clk_register_clkdev(clk, "vco1_mclk", NULL);
+        clk = clk_register_vco_pll("vco1_clk", "pll1_clk", NULL, "vco1_mclk", 0,
+                        SPEAR1340_PLL1_CTR, SPEAR1340_PLL1_FRQ, pll_rtbl,
                         ARRAY_SIZE(pll_rtbl), &_lock, &clk1, NULL);
         clk_register_clkdev(clk, "vco1_clk", NULL);
         clk_register_clkdev(clk1, "pll1_clk", NULL);
 
-        clk = clk_register_mux(NULL, "vco2_mux_clk", vco_parents,
+        clk = clk_register_mux(NULL, "vco2_mclk", vco_parents,
                         ARRAY_SIZE(vco_parents), 0, SPEAR1340_PLL_CFG,
                         SPEAR1340_PLL2_CLK_SHIFT, SPEAR1340_PLL_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "vco2_mux_clk", NULL);
-        clk = clk_register_vco_pll("vco2_clk", "pll2_clk", NULL, "vco2_mux_clk",
-                        0, SPEAR1340_PLL2_CTR, SPEAR1340_PLL2_FRQ, pll_rtbl,
+        clk_register_clkdev(clk, "vco2_mclk", NULL);
+        clk = clk_register_vco_pll("vco2_clk", "pll2_clk", NULL, "vco2_mclk", 0,
+                        SPEAR1340_PLL2_CTR, SPEAR1340_PLL2_FRQ, pll_rtbl,
                         ARRAY_SIZE(pll_rtbl), &_lock, &clk1, NULL);
         clk_register_clkdev(clk, "vco2_clk", NULL);
         clk_register_clkdev(clk1, "pll2_clk", NULL);
 
-        clk = clk_register_mux(NULL, "vco3_mux_clk", vco_parents,
+        clk = clk_register_mux(NULL, "vco3_mclk", vco_parents,
                         ARRAY_SIZE(vco_parents), 0, SPEAR1340_PLL_CFG,
                         SPEAR1340_PLL3_CLK_SHIFT, SPEAR1340_PLL_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "vco3_mux_clk", NULL);
-        clk = clk_register_vco_pll("vco3_clk", "pll3_clk", NULL, "vco3_mux_clk",
-                        0, SPEAR1340_PLL3_CTR, SPEAR1340_PLL3_FRQ, pll_rtbl,
+        clk_register_clkdev(clk, "vco3_mclk", NULL);
+        clk = clk_register_vco_pll("vco3_clk", "pll3_clk", NULL, "vco3_mclk", 0,
+                        SPEAR1340_PLL3_CTR, SPEAR1340_PLL3_FRQ, pll_rtbl,
                         ARRAY_SIZE(pll_rtbl), &_lock, &clk1, NULL);
         clk_register_clkdev(clk, "vco3_clk", NULL);
         clk_register_clkdev(clk1, "pll3_clk", NULL);
@@ -498,7 +496,7 @@ void __init spear1340_clk_init(void)
         /* peripherals */
         clk_register_fixed_factor(NULL, "thermal_clk", "osc_24m_clk", 0, 1,
                         128);
-        clk = clk_register_gate(NULL, "thermal_gate_clk", "thermal_clk", 0,
+        clk = clk_register_gate(NULL, "thermal_gclk", "thermal_clk", 0,
                         SPEAR1340_PERIP2_CLK_ENB, SPEAR1340_THSENS_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "spear_thermal");
@@ -509,23 +507,23 @@ void __init spear1340_clk_init(void)
         clk_register_clkdev(clk, "ddr_clk", NULL);
 
         /* clock derived from pll1 clk */
-        clk = clk_register_frac("sys_synth_clk", "vco1div2_clk", 0,
+        clk = clk_register_frac("sys_syn_clk", "vco1div2_clk", 0,
                         SPEAR1340_SYS_CLK_SYNT, sys_synth_rtbl,
                         ARRAY_SIZE(sys_synth_rtbl), &_lock);
-        clk_register_clkdev(clk, "sys_synth_clk", NULL);
+        clk_register_clkdev(clk, "sys_syn_clk", NULL);
 
-        clk = clk_register_frac("amba_synth_clk", "vco1div2_clk", 0,
+        clk = clk_register_frac("amba_syn_clk", "vco1div2_clk", 0,
                         SPEAR1340_AMBA_CLK_SYNT, amba_synth_rtbl,
                         ARRAY_SIZE(amba_synth_rtbl), &_lock);
-        clk_register_clkdev(clk, "amba_synth_clk", NULL);
+        clk_register_clkdev(clk, "amba_syn_clk", NULL);
 
-        clk = clk_register_mux(NULL, "sys_mux_clk", sys_parents,
+        clk = clk_register_mux(NULL, "sys_mclk", sys_parents,
                         ARRAY_SIZE(sys_parents), 0, SPEAR1340_SYS_CLK_CTRL,
                         SPEAR1340_SCLK_SRC_SEL_SHIFT,
                         SPEAR1340_SCLK_SRC_SEL_MASK, 0, &_lock);
         clk_register_clkdev(clk, "sys_clk", NULL);
 
-        clk = clk_register_fixed_factor(NULL, "cpu_clk", "sys_mux_clk", 0, 1,
+        clk = clk_register_fixed_factor(NULL, "cpu_clk", "sys_mclk", 0, 1,
                         2);
         clk_register_clkdev(clk, "cpu_clk", NULL);
 
@@ -548,194 +546,193 @@ void __init spear1340_clk_init(void)
         clk_register_clkdev(clk, "apb_clk", NULL);
 
         /* gpt clocks */
-        clk = clk_register_mux(NULL, "gpt0_mux_clk", gpt_parents,
+        clk = clk_register_mux(NULL, "gpt0_mclk", gpt_parents,
                         ARRAY_SIZE(gpt_parents), 0, SPEAR1340_PERIP_CLK_CFG,
                         SPEAR1340_GPT0_CLK_SHIFT, SPEAR1340_GPT_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "gpt0_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt0_clk", "gpt0_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt0_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt0_clk", "gpt0_mclk", 0,
                         SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_GPT0_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "gpt0");
 
-        clk = clk_register_mux(NULL, "gpt1_mux_clk", gpt_parents,
+        clk = clk_register_mux(NULL, "gpt1_mclk", gpt_parents,
                         ARRAY_SIZE(gpt_parents), 0, SPEAR1340_PERIP_CLK_CFG,
                         SPEAR1340_GPT1_CLK_SHIFT, SPEAR1340_GPT_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "gpt1_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt1_clk", "gpt1_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt1_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt1_clk", "gpt1_mclk", 0,
                         SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_GPT1_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "gpt1");
 
-        clk = clk_register_mux(NULL, "gpt2_mux_clk", gpt_parents,
+        clk = clk_register_mux(NULL, "gpt2_mclk", gpt_parents,
                         ARRAY_SIZE(gpt_parents), 0, SPEAR1340_PERIP_CLK_CFG,
                         SPEAR1340_GPT2_CLK_SHIFT, SPEAR1340_GPT_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "gpt2_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt2_clk", "gpt2_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt2_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt2_clk", "gpt2_mclk", 0,
                         SPEAR1340_PERIP2_CLK_ENB, SPEAR1340_GPT2_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "gpt2");
 
-        clk = clk_register_mux(NULL, "gpt3_mux_clk", gpt_parents,
+        clk = clk_register_mux(NULL, "gpt3_mclk", gpt_parents,
                         ARRAY_SIZE(gpt_parents), 0, SPEAR1340_PERIP_CLK_CFG,
                         SPEAR1340_GPT3_CLK_SHIFT, SPEAR1340_GPT_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "gpt3_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt3_clk", "gpt3_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt3_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt3_clk", "gpt3_mclk", 0,
                         SPEAR1340_PERIP2_CLK_ENB, SPEAR1340_GPT3_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "gpt3");
 
         /* others */
-        clk = clk_register_aux("uart0_synth_clk", "uart0_synth_gate_clk",
+        clk = clk_register_aux("uart0_syn_clk", "uart0_syn_gclk",
                         "vco1div2_clk", 0, SPEAR1340_UART0_CLK_SYNT, NULL,
                         aux_rtbl, ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "uart0_synth_clk", NULL);
-        clk_register_clkdev(clk1, "uart0_synth_gate_clk", NULL);
+        clk_register_clkdev(clk, "uart0_syn_clk", NULL);
+        clk_register_clkdev(clk1, "uart0_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "uart0_mux_clk", uart0_parents,
+        clk = clk_register_mux(NULL, "uart0_mclk", uart0_parents,
                         ARRAY_SIZE(uart0_parents), 0, SPEAR1340_PERIP_CLK_CFG,
                         SPEAR1340_UART0_CLK_SHIFT, SPEAR1340_UART_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "uart0_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart0_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart0_clk", "uart0_mux_clk", 0,
+        clk = clk_register_gate(NULL, "uart0_clk", "uart0_mclk", 0,
                         SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_UART0_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "e0000000.serial");
 
-        clk = clk_register_aux("uart1_synth_clk", "uart1_synth_gate_clk",
+        clk = clk_register_aux("uart1_syn_clk", "uart1_syn_gclk",
                         "vco1div2_clk", 0, SPEAR1340_UART1_CLK_SYNT, NULL,
                         aux_rtbl, ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "uart1_synth_clk", NULL);
-        clk_register_clkdev(clk1, "uart1_synth_gate_clk", NULL);
+        clk_register_clkdev(clk, "uart1_syn_clk", NULL);
+        clk_register_clkdev(clk1, "uart1_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "uart1_mux_clk", uart1_parents,
+        clk = clk_register_mux(NULL, "uart1_mclk", uart1_parents,
                         ARRAY_SIZE(uart1_parents), 0, SPEAR1340_PERIP_CLK_CFG,
                         SPEAR1340_UART1_CLK_SHIFT, SPEAR1340_UART_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "uart1_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart1_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart1_clk", "uart1_mux_clk", 0,
-                        SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_UART1_CLK_ENB, 0,
+        clk = clk_register_gate(NULL, "uart1_clk", "uart1_mclk", 0,
+                        SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_UART1_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "b4100000.serial");
 
-        clk = clk_register_aux("sdhci_synth_clk", "sdhci_synth_gate_clk",
+        clk = clk_register_aux("sdhci_syn_clk", "sdhci_syn_gclk",
                         "vco1div2_clk", 0, SPEAR1340_SDHCI_CLK_SYNT, NULL,
                         aux_rtbl, ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "sdhci_synth_clk", NULL);
-        clk_register_clkdev(clk1, "sdhci_synth_gate_clk", NULL);
+        clk_register_clkdev(clk, "sdhci_syn_clk", NULL);
+        clk_register_clkdev(clk1, "sdhci_syn_gclk", NULL);
 
-        clk = clk_register_gate(NULL, "sdhci_clk", "sdhci_synth_gate_clk", 0,
+        clk = clk_register_gate(NULL, "sdhci_clk", "sdhci_syn_gclk", 0,
                         SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_SDHCI_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "b3000000.sdhci");
 
-        clk = clk_register_aux("cfxd_synth_clk", "cfxd_synth_gate_clk",
-                        "vco1div2_clk", 0, SPEAR1340_CFXD_CLK_SYNT, NULL,
-                        aux_rtbl, ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "cfxd_synth_clk", NULL);
-        clk_register_clkdev(clk1, "cfxd_synth_gate_clk", NULL);
+        clk = clk_register_aux("cfxd_syn_clk", "cfxd_syn_gclk", "vco1div2_clk",
+                        0, SPEAR1340_CFXD_CLK_SYNT, NULL, aux_rtbl,
+                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
+        clk_register_clkdev(clk, "cfxd_syn_clk", NULL);
+        clk_register_clkdev(clk1, "cfxd_syn_gclk", NULL);
 
-        clk = clk_register_gate(NULL, "cfxd_clk", "cfxd_synth_gate_clk", 0,
+        clk = clk_register_gate(NULL, "cfxd_clk", "cfxd_syn_gclk", 0,
                         SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_CFXD_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "b2800000.cf");
         clk_register_clkdev(clk, NULL, "arasan_xd");
 
-        clk = clk_register_aux("c3_synth_clk", "c3_synth_gate_clk",
-                        "vco1div2_clk", 0, SPEAR1340_C3_CLK_SYNT, NULL,
-                        aux_rtbl, ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "c3_synth_clk", NULL);
-        clk_register_clkdev(clk1, "c3_synth_gate_clk", NULL);
+        clk = clk_register_aux("c3_syn_clk", "c3_syn_gclk", "vco1div2_clk", 0,
+                        SPEAR1340_C3_CLK_SYNT, NULL, aux_rtbl,
+                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
+        clk_register_clkdev(clk, "c3_syn_clk", NULL);
+        clk_register_clkdev(clk1, "c3_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "c3_mux_clk", c3_parents,
+        clk = clk_register_mux(NULL, "c3_mclk", c3_parents,
                         ARRAY_SIZE(c3_parents), 0, SPEAR1340_PERIP_CLK_CFG,
                         SPEAR1340_C3_CLK_SHIFT, SPEAR1340_C3_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "c3_mux_clk", NULL);
+        clk_register_clkdev(clk, "c3_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "c3_clk", "c3_mux_clk", 0,
+        clk = clk_register_gate(NULL, "c3_clk", "c3_mclk", 0,
                         SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_C3_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "c3");
 
         /* gmac */
-        clk = clk_register_mux(NULL, "gmac_phy_input_mux_clk",
-                        gmac_phy_input_parents,
+        clk = clk_register_mux(NULL, "phy_input_mclk", gmac_phy_input_parents,
                         ARRAY_SIZE(gmac_phy_input_parents), 0,
                         SPEAR1340_GMAC_CLK_CFG,
                         SPEAR1340_GMAC_PHY_INPUT_CLK_SHIFT,
                         SPEAR1340_GMAC_PHY_INPUT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gmac_phy_input_mux_clk", NULL);
+        clk_register_clkdev(clk, "phy_input_mclk", NULL);
 
-        clk = clk_register_aux("gmac_phy_synth_clk", "gmac_phy_synth_gate_clk",
-                        "gmac_phy_input_mux_clk", 0, SPEAR1340_GMAC_CLK_SYNT,
-                        NULL, gmac_rtbl, ARRAY_SIZE(gmac_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "gmac_phy_synth_clk", NULL);
-        clk_register_clkdev(clk1, "gmac_phy_synth_gate_clk", NULL);
+        clk = clk_register_aux("phy_syn_clk", "phy_syn_gclk", "phy_input_mclk",
+                        0, SPEAR1340_GMAC_CLK_SYNT, NULL, gmac_rtbl,
+                        ARRAY_SIZE(gmac_rtbl), &_lock, &clk1);
+        clk_register_clkdev(clk, "phy_syn_clk", NULL);
+        clk_register_clkdev(clk1, "phy_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "gmac_phy_mux_clk", gmac_phy_parents,
+        clk = clk_register_mux(NULL, "phy_mclk", gmac_phy_parents,
                         ARRAY_SIZE(gmac_phy_parents), 0,
                         SPEAR1340_PERIP_CLK_CFG, SPEAR1340_GMAC_PHY_CLK_SHIFT,
                         SPEAR1340_GMAC_PHY_CLK_MASK, 0, &_lock);
         clk_register_clkdev(clk, NULL, "stmmacphy.0");
 
         /* clcd */
-        clk = clk_register_mux(NULL, "clcd_synth_mux_clk", clcd_synth_parents,
+        clk = clk_register_mux(NULL, "clcd_syn_mclk", clcd_synth_parents,
                         ARRAY_SIZE(clcd_synth_parents), 0,
                         SPEAR1340_CLCD_CLK_SYNT, SPEAR1340_CLCD_SYNT_CLK_SHIFT,
                         SPEAR1340_CLCD_SYNT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "clcd_synth_mux_clk", NULL);
+        clk_register_clkdev(clk, "clcd_syn_mclk", NULL);
 
-        clk = clk_register_frac("clcd_synth_clk", "clcd_synth_mux_clk", 0,
+        clk = clk_register_frac("clcd_syn_clk", "clcd_syn_mclk", 0,
                         SPEAR1340_CLCD_CLK_SYNT, clcd_rtbl,
                         ARRAY_SIZE(clcd_rtbl), &_lock);
-        clk_register_clkdev(clk, "clcd_synth_clk", NULL);
+        clk_register_clkdev(clk, "clcd_syn_clk", NULL);
 
-        clk = clk_register_mux(NULL, "clcd_pixel_mux_clk", clcd_pixel_parents,
+        clk = clk_register_mux(NULL, "clcd_pixel_mclk", clcd_pixel_parents,
                         ARRAY_SIZE(clcd_pixel_parents), 0,
                         SPEAR1340_PERIP_CLK_CFG, SPEAR1340_CLCD_CLK_SHIFT,
                         SPEAR1340_CLCD_CLK_MASK, 0, &_lock);
         clk_register_clkdev(clk, "clcd_pixel_clk", NULL);
 
-        clk = clk_register_gate(NULL, "clcd_clk", "clcd_pixel_mux_clk", 0,
+        clk = clk_register_gate(NULL, "clcd_clk", "clcd_pixel_mclk", 0,
                         SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_CLCD_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, "clcd_clk", NULL);
 
         /* i2s */
-        clk = clk_register_mux(NULL, "i2s_src_mux_clk", i2s_src_parents,
+        clk = clk_register_mux(NULL, "i2s_src_mclk", i2s_src_parents,
                         ARRAY_SIZE(i2s_src_parents), 0, SPEAR1340_I2S_CLK_CFG,
                         SPEAR1340_I2S_SRC_CLK_SHIFT, SPEAR1340_I2S_SRC_CLK_MASK,
                         0, &_lock);
         clk_register_clkdev(clk, "i2s_src_clk", NULL);
 
-        clk = clk_register_aux("i2s_prs1_clk", NULL, "i2s_src_mux_clk", 0,
+        clk = clk_register_aux("i2s_prs1_clk", NULL, "i2s_src_mclk", 0,
                         SPEAR1340_I2S_CLK_CFG, &i2s_prs1_masks, i2s_prs1_rtbl,
                         ARRAY_SIZE(i2s_prs1_rtbl), &_lock, NULL);
         clk_register_clkdev(clk, "i2s_prs1_clk", NULL);
 
-        clk = clk_register_mux(NULL, "i2s_ref_mux_clk", i2s_ref_parents,
+        clk = clk_register_mux(NULL, "i2s_ref_mclk", i2s_ref_parents,
                         ARRAY_SIZE(i2s_ref_parents), 0, SPEAR1340_I2S_CLK_CFG,
                         SPEAR1340_I2S_REF_SHIFT, SPEAR1340_I2S_REF_SEL_MASK, 0,
                         &_lock);
         clk_register_clkdev(clk, "i2s_ref_clk", NULL);
 
-        clk = clk_register_gate(NULL, "i2s_ref_pad_clk", "i2s_ref_mux_clk", 0,
+        clk = clk_register_gate(NULL, "i2s_ref_pad_clk", "i2s_ref_mclk", 0,
                         SPEAR1340_PERIP2_CLK_ENB, SPEAR1340_I2S_REF_PAD_CLK_ENB,
                         0, &_lock);
         clk_register_clkdev(clk, "i2s_ref_pad_clk", NULL);
 
-        clk = clk_register_aux("i2s_sclk_clk", "i2s_sclk_gate_clk",
-                        "i2s_ref_mux_clk", 0, SPEAR1340_I2S_CLK_CFG,
-                        &i2s_sclk_masks, i2s_sclk_rtbl,
-                        ARRAY_SIZE(i2s_sclk_rtbl), &_lock, &clk1);
+        clk = clk_register_aux("i2s_sclk_clk", "i2s_sclk_gclk", "i2s_ref_mclk",
+                        0, SPEAR1340_I2S_CLK_CFG, &i2s_sclk_masks,
+                        i2s_sclk_rtbl, ARRAY_SIZE(i2s_sclk_rtbl), &_lock,
+                        &clk1);
         clk_register_clkdev(clk, "i2s_sclk_clk", NULL);
-        clk_register_clkdev(clk1, "i2s_sclk_gate_clk", NULL);
+        clk_register_clkdev(clk1, "i2s_sclk_gclk", NULL);
 
         /* clock derived from ahb clk */
         clk = clk_register_gate(NULL, "i2c0_clk", "ahb_clk", 0,
@@ -744,7 +741,7 @@ void __init spear1340_clk_init(void)
         clk_register_clkdev(clk, NULL, "e0280000.i2c");
 
         clk = clk_register_gate(NULL, "i2c1_clk", "ahb_clk", 0,
-                        SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_I2C1_CLK_ENB, 0,
+                        SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_I2C1_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "b4000000.i2c");
 
@@ -800,13 +797,13 @@ void __init spear1340_clk_init(void)
                         &_lock);
         clk_register_clkdev(clk, "sysram1_clk", NULL);
 
-        clk = clk_register_aux("adc_synth_clk", "adc_synth_gate_clk", "ahb_clk",
+        clk = clk_register_aux("adc_syn_clk", "adc_syn_gclk", "ahb_clk",
                         0, SPEAR1340_ADC_CLK_SYNT, NULL, adc_rtbl,
                         ARRAY_SIZE(adc_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "adc_synth_clk", NULL);
-        clk_register_clkdev(clk1, "adc_synth_gate_clk", NULL);
+        clk_register_clkdev(clk, "adc_syn_clk", NULL);
+        clk_register_clkdev(clk1, "adc_syn_gclk", NULL);
 
-        clk = clk_register_gate(NULL, "adc_clk", "adc_synth_gate_clk", 0,
+        clk = clk_register_gate(NULL, "adc_clk", "adc_syn_gclk", 0,
                         SPEAR1340_PERIP1_CLK_ENB, SPEAR1340_ADC_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "adc_clk");
@@ -843,39 +840,39 @@ void __init spear1340_clk_init(void)
         clk_register_clkdev(clk, NULL, "e0300000.kbd");
 
         /* RAS clks */
-        clk = clk_register_mux(NULL, "gen_synth0_1_mux_clk",
-                        gen_synth0_1_parents, ARRAY_SIZE(gen_synth0_1_parents),
-                        0, SPEAR1340_PLL_CFG, SPEAR1340_GEN_SYNT0_1_CLK_SHIFT,
+        clk = clk_register_mux(NULL, "gen_syn0_1_mclk", gen_synth0_1_parents,
+                        ARRAY_SIZE(gen_synth0_1_parents), 0, SPEAR1340_PLL_CFG,
+                        SPEAR1340_GEN_SYNT0_1_CLK_SHIFT,
                         SPEAR1340_GEN_SYNT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gen_synth0_1_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn0_1_clk", NULL);
 
-        clk = clk_register_mux(NULL, "gen_synth2_3_mux_clk",
-                        gen_synth2_3_parents, ARRAY_SIZE(gen_synth2_3_parents),
-                        0, SPEAR1340_PLL_CFG, SPEAR1340_GEN_SYNT2_3_CLK_SHIFT,
+        clk = clk_register_mux(NULL, "gen_syn2_3_mclk", gen_synth2_3_parents,
+                        ARRAY_SIZE(gen_synth2_3_parents), 0, SPEAR1340_PLL_CFG,
+                        SPEAR1340_GEN_SYNT2_3_CLK_SHIFT,
                         SPEAR1340_GEN_SYNT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gen_synth2_3_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn2_3_clk", NULL);
 
-        clk = clk_register_frac("gen_synth0_clk", "gen_synth0_1_clk", 0,
+        clk = clk_register_frac("gen_syn0_clk", "gen_syn0_1_clk", 0,
                         SPEAR1340_GEN_CLK_SYNT0, gen_rtbl, ARRAY_SIZE(gen_rtbl),
                         &_lock);
-        clk_register_clkdev(clk, "gen_synth0_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn0_clk", NULL);
 
-        clk = clk_register_frac("gen_synth1_clk", "gen_synth0_1_clk", 0,
+        clk = clk_register_frac("gen_syn1_clk", "gen_syn0_1_clk", 0,
                         SPEAR1340_GEN_CLK_SYNT1, gen_rtbl, ARRAY_SIZE(gen_rtbl),
                         &_lock);
-        clk_register_clkdev(clk, "gen_synth1_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn1_clk", NULL);
 
-        clk = clk_register_frac("gen_synth2_clk", "gen_synth2_3_clk", 0,
+        clk = clk_register_frac("gen_syn2_clk", "gen_syn2_3_clk", 0,
                         SPEAR1340_GEN_CLK_SYNT2, gen_rtbl, ARRAY_SIZE(gen_rtbl),
                         &_lock);
-        clk_register_clkdev(clk, "gen_synth2_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn2_clk", NULL);
 
-        clk = clk_register_frac("gen_synth3_clk", "gen_synth2_3_clk", 0,
+        clk = clk_register_frac("gen_syn3_clk", "gen_syn2_3_clk", 0,
                         SPEAR1340_GEN_CLK_SYNT3, gen_rtbl, ARRAY_SIZE(gen_rtbl),
                         &_lock);
-        clk_register_clkdev(clk, "gen_synth3_clk", NULL);
+        clk_register_clkdev(clk, "gen_syn3_clk", NULL);
 
-        clk = clk_register_gate(NULL, "mali_clk", "gen_synth3_clk", 0,
+        clk = clk_register_gate(NULL, "mali_clk", "gen_syn3_clk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_MALI_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "mali");
@@ -890,74 +887,74 @@ void __init spear1340_clk_init(void)
                         &_lock);
         clk_register_clkdev(clk, NULL, "spear_cec.1");
 
-        clk = clk_register_mux(NULL, "spdif_out_mux_clk", spdif_out_parents,
+        clk = clk_register_mux(NULL, "spdif_out_mclk", spdif_out_parents,
                         ARRAY_SIZE(spdif_out_parents), 0,
                         SPEAR1340_PERIP_CLK_CFG, SPEAR1340_SPDIF_OUT_CLK_SHIFT,
                         SPEAR1340_SPDIF_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "spdif_out_mux_clk", NULL);
+        clk_register_clkdev(clk, "spdif_out_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "spdif_out_clk", "spdif_out_mux_clk", 0,
+        clk = clk_register_gate(NULL, "spdif_out_clk", "spdif_out_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_SPDIF_OUT_CLK_ENB,
                         0, &_lock);
         clk_register_clkdev(clk, NULL, "spdif-out");
 
-        clk = clk_register_mux(NULL, "spdif_in_mux_clk", spdif_in_parents,
+        clk = clk_register_mux(NULL, "spdif_in_mclk", spdif_in_parents,
                         ARRAY_SIZE(spdif_in_parents), 0,
                         SPEAR1340_PERIP_CLK_CFG, SPEAR1340_SPDIF_IN_CLK_SHIFT,
                         SPEAR1340_SPDIF_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "spdif_in_mux_clk", NULL);
+        clk_register_clkdev(clk, "spdif_in_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "spdif_in_clk", "spdif_in_mux_clk", 0,
+        clk = clk_register_gate(NULL, "spdif_in_clk", "spdif_in_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_SPDIF_IN_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "spdif-in");
 
-        clk = clk_register_gate(NULL, "acp_clk", "acp_mux_clk", 0,
+        clk = clk_register_gate(NULL, "acp_clk", "acp_mclk", 0,
                         SPEAR1340_PERIP2_CLK_ENB, SPEAR1340_ACP_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "acp_clk");
 
-        clk = clk_register_gate(NULL, "plgpio_clk", "plgpio_mux_clk", 0,
+        clk = clk_register_gate(NULL, "plgpio_clk", "plgpio_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_PLGPIO_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "plgpio");
 
-        clk = clk_register_gate(NULL, "video_dec_clk", "video_dec_mux_clk", 0,
+        clk = clk_register_gate(NULL, "video_dec_clk", "video_dec_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_VIDEO_DEC_CLK_ENB,
                         0, &_lock);
         clk_register_clkdev(clk, NULL, "video_dec");
 
-        clk = clk_register_gate(NULL, "video_enc_clk", "video_enc_mux_clk", 0,
+        clk = clk_register_gate(NULL, "video_enc_clk", "video_enc_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_VIDEO_ENC_CLK_ENB,
                         0, &_lock);
         clk_register_clkdev(clk, NULL, "video_enc");
 
-        clk = clk_register_gate(NULL, "video_in_clk", "video_in_mux_clk", 0,
+        clk = clk_register_gate(NULL, "video_in_clk", "video_in_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_VIDEO_IN_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "spear_vip");
 
-        clk = clk_register_gate(NULL, "cam0_clk", "cam0_mux_clk", 0,
+        clk = clk_register_gate(NULL, "cam0_clk", "cam0_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_CAM0_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "spear_camif.0");
 
-        clk = clk_register_gate(NULL, "cam1_clk", "cam1_mux_clk", 0,
+        clk = clk_register_gate(NULL, "cam1_clk", "cam1_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_CAM1_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "spear_camif.1");
 
-        clk = clk_register_gate(NULL, "cam2_clk", "cam2_mux_clk", 0,
+        clk = clk_register_gate(NULL, "cam2_clk", "cam2_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_CAM2_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "spear_camif.2");
 
-        clk = clk_register_gate(NULL, "cam3_clk", "cam3_mux_clk", 0,
+        clk = clk_register_gate(NULL, "cam3_clk", "cam3_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_CAM3_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "spear_camif.3");
 
-        clk = clk_register_gate(NULL, "pwm_clk", "pwm_mux_clk", 0,
+        clk = clk_register_gate(NULL, "pwm_clk", "pwm_mclk", 0,
                         SPEAR1340_PERIP3_CLK_ENB, SPEAR1340_PWM_CLK_ENB, 0,
                         &_lock);
         clk_register_clkdev(clk, NULL, "pwm");
diff --git a/drivers/clk/spear/spear3xx_clock.c b/drivers/clk/spear/spear3xx_clock.c
index 01dd6daff2a1..c3157454bb3f 100644
--- a/drivers/clk/spear/spear3xx_clock.c
+++ b/drivers/clk/spear/spear3xx_clock.c
@@ -122,12 +122,12 @@ static struct gpt_rate_tbl gpt_rtbl[] = {
 };
 
 /* clock parents */
-static const char *uart0_parents[] = { "pll3_48m_clk", "uart_synth_gate_clk", };
-static const char *firda_parents[] = { "pll3_48m_clk", "firda_synth_gate_clk",
+static const char *uart0_parents[] = { "pll3_clk", "uart_syn_gclk", };
+static const char *firda_parents[] = { "pll3_clk", "firda_syn_gclk",
 };
-static const char *gpt0_parents[] = { "pll3_48m_clk", "gpt0_synth_clk", };
-static const char *gpt1_parents[] = { "pll3_48m_clk", "gpt1_synth_clk", };
-static const char *gpt2_parents[] = { "pll3_48m_clk", "gpt2_synth_clk", };
+static const char *gpt0_parents[] = { "pll3_clk", "gpt0_syn_clk", };
+static const char *gpt1_parents[] = { "pll3_clk", "gpt1_syn_clk", };
+static const char *gpt2_parents[] = { "pll3_clk", "gpt2_syn_clk", };
 static const char *gen2_3_parents[] = { "pll1_clk", "pll2_clk", };
 static const char *ddr_parents[] = { "ahb_clk", "ahbmult2_clk", "none",
         "pll2_clk", };
@@ -137,7 +137,7 @@ static void __init spear300_clk_init(void)
 {
         struct clk *clk;
 
-        clk = clk_register_fixed_factor(NULL, "clcd_clk", "ras_pll3_48m_clk", 0,
+        clk = clk_register_fixed_factor(NULL, "clcd_clk", "ras_pll3_clk", 0,
                         1, 1);
         clk_register_clkdev(clk, NULL, "60000000.clcd");
 
@@ -219,15 +219,11 @@ static void __init spear310_clk_init(void)
         #define SPEAR320_UARTX_PCLK_VAL_SYNTH1          0x0
         #define SPEAR320_UARTX_PCLK_VAL_APB             0x1
 
-static const char *i2s_ref_parents[] = { "ras_pll2_clk",
-        "ras_gen2_synth_gate_clk", };
-static const char *sdhci_parents[] = { "ras_pll3_48m_clk",
-        "ras_gen3_synth_gate_clk",
-};
+static const char *i2s_ref_parents[] = { "ras_pll2_clk", "ras_syn2_gclk", };
+static const char *sdhci_parents[] = { "ras_pll3_clk", "ras_syn3_gclk", };
 static const char *smii0_parents[] = { "smii_125m_pad", "ras_pll2_clk",
-        "ras_gen0_synth_gate_clk", };
-static const char *uartx_parents[] = { "ras_gen1_synth_gate_clk", "ras_apb_clk",
-};
+        "ras_syn0_gclk", };
+static const char *uartx_parents[] = { "ras_syn1_gclk", "ras_apb_clk", };
 
 static void __init spear320_clk_init(void)
 {
@@ -237,7 +233,7 @@ static void __init spear320_clk_init(void)
                         CLK_IS_ROOT, 125000000);
         clk_register_clkdev(clk, "smii_125m_pad", NULL);
 
-        clk = clk_register_fixed_factor(NULL, "clcd_clk", "ras_pll3_48m_clk", 0,
+        clk = clk_register_fixed_factor(NULL, "clcd_clk", "ras_pll3_clk", 0,
                         1, 1);
         clk_register_clkdev(clk, NULL, "90000000.clcd");
 
@@ -363,9 +359,9 @@ void __init spear3xx_clk_init(void)
         clk_register_clkdev(clk, NULL, "fc900000.rtc");
 
         /* clock derived from 24 MHz osc clk */
-        clk = clk_register_fixed_rate(NULL, "pll3_48m_clk", "osc_24m_clk", 0,
+        clk = clk_register_fixed_rate(NULL, "pll3_clk", "osc_24m_clk", 0,
                         48000000);
-        clk_register_clkdev(clk, "pll3_48m_clk", NULL);
+        clk_register_clkdev(clk, "pll3_clk", NULL);
 
         clk = clk_register_fixed_factor(NULL, "wdt_clk", "osc_24m_clk", 0, 1,
                         1);
@@ -392,98 +388,98 @@ void __init spear3xx_clk_init(void)
                         HCLK_RATIO_MASK, 0, &_lock);
         clk_register_clkdev(clk, "ahb_clk", NULL);
 
-        clk = clk_register_aux("uart_synth_clk", "uart_synth_gate_clk",
-                        "pll1_clk", 0, UART_CLK_SYNT, NULL, aux_rtbl,
-                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "uart_synth_clk", NULL);
-        clk_register_clkdev(clk1, "uart_synth_gate_clk", NULL);
+        clk = clk_register_aux("uart_syn_clk", "uart_syn_gclk", "pll1_clk", 0,
+                        UART_CLK_SYNT, NULL, aux_rtbl, ARRAY_SIZE(aux_rtbl),
+                        &_lock, &clk1);
+        clk_register_clkdev(clk, "uart_syn_clk", NULL);
+        clk_register_clkdev(clk1, "uart_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "uart0_mux_clk", uart0_parents,
+        clk = clk_register_mux(NULL, "uart0_mclk", uart0_parents,
                         ARRAY_SIZE(uart0_parents), 0, PERIP_CLK_CFG,
                         UART_CLK_SHIFT, UART_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "uart0_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart0_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart0", "uart0_mux_clk", 0,
-                        PERIP1_CLK_ENB, UART_CLK_ENB, 0, &_lock);
+        clk = clk_register_gate(NULL, "uart0", "uart0_mclk", 0, PERIP1_CLK_ENB,
+                        UART_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "d0000000.serial");
 
-        clk = clk_register_aux("firda_synth_clk", "firda_synth_gate_clk",
-                        "pll1_clk", 0, FIRDA_CLK_SYNT, NULL, aux_rtbl,
-                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "firda_synth_clk", NULL);
-        clk_register_clkdev(clk1, "firda_synth_gate_clk", NULL);
+        clk = clk_register_aux("firda_syn_clk", "firda_syn_gclk", "pll1_clk", 0,
+                        FIRDA_CLK_SYNT, NULL, aux_rtbl, ARRAY_SIZE(aux_rtbl),
+                        &_lock, &clk1);
+        clk_register_clkdev(clk, "firda_syn_clk", NULL);
+        clk_register_clkdev(clk1, "firda_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "firda_mux_clk", firda_parents,
+        clk = clk_register_mux(NULL, "firda_mclk", firda_parents,
                         ARRAY_SIZE(firda_parents), 0, PERIP_CLK_CFG,
                         FIRDA_CLK_SHIFT, FIRDA_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "firda_mux_clk", NULL);
+        clk_register_clkdev(clk, "firda_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "firda_clk", "firda_mux_clk", 0,
+        clk = clk_register_gate(NULL, "firda_clk", "firda_mclk", 0,
                         PERIP1_CLK_ENB, FIRDA_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "firda");
 
         /* gpt clocks */
-        clk_register_gpt("gpt0_synth_clk", "pll1_clk", 0, PRSC0_CLK_CFG,
-                        gpt_rtbl, ARRAY_SIZE(gpt_rtbl), &_lock);
+        clk_register_gpt("gpt0_syn_clk", "pll1_clk", 0, PRSC0_CLK_CFG, gpt_rtbl,
+                        ARRAY_SIZE(gpt_rtbl), &_lock);
         clk = clk_register_mux(NULL, "gpt0_clk", gpt0_parents,
                         ARRAY_SIZE(gpt0_parents), 0, PERIP_CLK_CFG,
                         GPT0_CLK_SHIFT, GPT_CLK_MASK, 0, &_lock);
         clk_register_clkdev(clk, NULL, "gpt0");
 
-        clk_register_gpt("gpt1_synth_clk", "pll1_clk", 0, PRSC1_CLK_CFG,
-                        gpt_rtbl, ARRAY_SIZE(gpt_rtbl), &_lock);
-        clk = clk_register_mux(NULL, "gpt1_mux_clk", gpt1_parents,
+        clk_register_gpt("gpt1_syn_clk", "pll1_clk", 0, PRSC1_CLK_CFG, gpt_rtbl,
+                        ARRAY_SIZE(gpt_rtbl), &_lock);
+        clk = clk_register_mux(NULL, "gpt1_mclk", gpt1_parents,
                         ARRAY_SIZE(gpt1_parents), 0, PERIP_CLK_CFG,
                         GPT1_CLK_SHIFT, GPT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gpt1_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt1_clk", "gpt1_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt1_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt1_clk", "gpt1_mclk", 0,
                         PERIP1_CLK_ENB, GPT1_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "gpt1");
 
-        clk_register_gpt("gpt2_synth_clk", "pll1_clk", 0, PRSC2_CLK_CFG,
-                        gpt_rtbl, ARRAY_SIZE(gpt_rtbl), &_lock);
-        clk = clk_register_mux(NULL, "gpt2_mux_clk", gpt2_parents,
+        clk_register_gpt("gpt2_syn_clk", "pll1_clk", 0, PRSC2_CLK_CFG, gpt_rtbl,
+                        ARRAY_SIZE(gpt_rtbl), &_lock);
+        clk = clk_register_mux(NULL, "gpt2_mclk", gpt2_parents,
                         ARRAY_SIZE(gpt2_parents), 0, PERIP_CLK_CFG,
                         GPT2_CLK_SHIFT, GPT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gpt2_mux_clk", NULL);
-        clk = clk_register_gate(NULL, "gpt2_clk", "gpt2_mux_clk", 0,
+        clk_register_clkdev(clk, "gpt2_mclk", NULL);
+        clk = clk_register_gate(NULL, "gpt2_clk", "gpt2_mclk", 0,
                         PERIP1_CLK_ENB, GPT2_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "gpt2");
 
         /* general synths clocks */
-        clk = clk_register_aux("gen0_synth_clk", "gen0_synth_gate_clk",
-                        "pll1_clk", 0, GEN0_CLK_SYNT, NULL, aux_rtbl,
-                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "gen0_synth_clk", NULL);
-        clk_register_clkdev(clk1, "gen0_synth_gate_clk", NULL);
-
-        clk = clk_register_aux("gen1_synth_clk", "gen1_synth_gate_clk",
-                        "pll1_clk", 0, GEN1_CLK_SYNT, NULL, aux_rtbl,
-                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "gen1_synth_clk", NULL);
-        clk_register_clkdev(clk1, "gen1_synth_gate_clk", NULL);
-
-        clk = clk_register_mux(NULL, "gen2_3_parent_clk", gen2_3_parents,
+        clk = clk_register_aux("gen0_syn_clk", "gen0_syn_gclk", "pll1_clk",
+                        0, GEN0_CLK_SYNT, NULL, aux_rtbl, ARRAY_SIZE(aux_rtbl),
+                        &_lock, &clk1);
+        clk_register_clkdev(clk, "gen0_syn_clk", NULL);
+        clk_register_clkdev(clk1, "gen0_syn_gclk", NULL);
+
+        clk = clk_register_aux("gen1_syn_clk", "gen1_syn_gclk", "pll1_clk",
+                        0, GEN1_CLK_SYNT, NULL, aux_rtbl, ARRAY_SIZE(aux_rtbl),
+                        &_lock, &clk1);
+        clk_register_clkdev(clk, "gen1_syn_clk", NULL);
+        clk_register_clkdev(clk1, "gen1_syn_gclk", NULL);
+
+        clk = clk_register_mux(NULL, "gen2_3_par_clk", gen2_3_parents,
                         ARRAY_SIZE(gen2_3_parents), 0, CORE_CLK_CFG,
                         GEN_SYNTH2_3_CLK_SHIFT, GEN_SYNTH2_3_CLK_MASK, 0,
                         &_lock);
-        clk_register_clkdev(clk, "gen2_3_parent_clk", NULL);
+        clk_register_clkdev(clk, "gen2_3_par_clk", NULL);
 
-        clk = clk_register_aux("gen2_synth_clk", "gen2_synth_gate_clk",
-                        "gen2_3_parent_clk", 0, GEN2_CLK_SYNT, NULL, aux_rtbl,
+        clk = clk_register_aux("gen2_syn_clk", "gen2_syn_gclk",
+                        "gen2_3_par_clk", 0, GEN2_CLK_SYNT, NULL, aux_rtbl,
                         ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "gen2_synth_clk", NULL);
-        clk_register_clkdev(clk1, "gen2_synth_gate_clk", NULL);
+        clk_register_clkdev(clk, "gen2_syn_clk", NULL);
+        clk_register_clkdev(clk1, "gen2_syn_gclk", NULL);
 
-        clk = clk_register_aux("gen3_synth_clk", "gen3_synth_gate_clk",
-                        "gen2_3_parent_clk", 0, GEN3_CLK_SYNT, NULL, aux_rtbl,
+        clk = clk_register_aux("gen3_syn_clk", "gen3_syn_gclk",
+                        "gen2_3_par_clk", 0, GEN3_CLK_SYNT, NULL, aux_rtbl,
                         ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "gen3_synth_clk", NULL);
-        clk_register_clkdev(clk1, "gen3_synth_gate_clk", NULL);
+        clk_register_clkdev(clk, "gen3_syn_clk", NULL);
+        clk_register_clkdev(clk1, "gen3_syn_gclk", NULL);
 
         /* clock derived from pll3 clk */
-        clk = clk_register_gate(NULL, "usbh_clk", "pll3_48m_clk", 0,
-                        PERIP1_CLK_ENB, USBH_CLK_ENB, 0, &_lock);
+        clk = clk_register_gate(NULL, "usbh_clk", "pll3_clk", 0, PERIP1_CLK_ENB,
+                        USBH_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, "usbh_clk", NULL);
 
         clk = clk_register_fixed_factor(NULL, "usbh.0_clk", "usbh_clk", 0, 1,
@@ -494,8 +490,8 @@ void __init spear3xx_clk_init(void)
                         1);
         clk_register_clkdev(clk, "usbh.1_clk", NULL);
 
-        clk = clk_register_gate(NULL, "usbd_clk", "pll3_48m_clk", 0,
-                        PERIP1_CLK_ENB, USBD_CLK_ENB, 0, &_lock);
+        clk = clk_register_gate(NULL, "usbd_clk", "pll3_clk", 0, PERIP1_CLK_ENB,
+                        USBD_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "designware_udc");
 
         /* clock derived from ahb clk */
@@ -579,29 +575,25 @@ void __init spear3xx_clk_init(void)
                         RAS_CLK_ENB, RAS_PLL2_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, "ras_pll2_clk", NULL);
 
-        clk = clk_register_gate(NULL, "ras_pll3_48m_clk", "pll3_48m_clk", 0,
+        clk = clk_register_gate(NULL, "ras_pll3_clk", "pll3_clk", 0,
                         RAS_CLK_ENB, RAS_48M_CLK_ENB, 0, &_lock);
-        clk_register_clkdev(clk, "ras_pll3_48m_clk", NULL);
-
-        clk = clk_register_gate(NULL, "ras_gen0_synth_gate_clk",
-                        "gen0_synth_gate_clk", 0, RAS_CLK_ENB,
-                        RAS_SYNT0_CLK_ENB, 0, &_lock);
-        clk_register_clkdev(clk, "ras_gen0_synth_gate_clk", NULL);
-
-        clk = clk_register_gate(NULL, "ras_gen1_synth_gate_clk",
-                        "gen1_synth_gate_clk", 0, RAS_CLK_ENB,
-                        RAS_SYNT1_CLK_ENB, 0, &_lock);
-        clk_register_clkdev(clk, "ras_gen1_synth_gate_clk", NULL);
-
-        clk = clk_register_gate(NULL, "ras_gen2_synth_gate_clk",
-                        "gen2_synth_gate_clk", 0, RAS_CLK_ENB,
-                        RAS_SYNT2_CLK_ENB, 0, &_lock);
-        clk_register_clkdev(clk, "ras_gen2_synth_gate_clk", NULL);
-
-        clk = clk_register_gate(NULL, "ras_gen3_synth_gate_clk",
-                        "gen3_synth_gate_clk", 0, RAS_CLK_ENB,
-                        RAS_SYNT3_CLK_ENB, 0, &_lock);
-        clk_register_clkdev(clk, "ras_gen3_synth_gate_clk", NULL);
+        clk_register_clkdev(clk, "ras_pll3_clk", NULL);
+
+        clk = clk_register_gate(NULL, "ras_syn0_gclk", "gen0_syn_gclk", 0,
+                        RAS_CLK_ENB, RAS_SYNT0_CLK_ENB, 0, &_lock);
+        clk_register_clkdev(clk, "ras_syn0_gclk", NULL);
+
+        clk = clk_register_gate(NULL, "ras_syn1_gclk", "gen1_syn_gclk", 0,
+                        RAS_CLK_ENB, RAS_SYNT1_CLK_ENB, 0, &_lock);
+        clk_register_clkdev(clk, "ras_syn1_gclk", NULL);
+
+        clk = clk_register_gate(NULL, "ras_syn2_gclk", "gen2_syn_gclk", 0,
+                        RAS_CLK_ENB, RAS_SYNT2_CLK_ENB, 0, &_lock);
+        clk_register_clkdev(clk, "ras_syn2_gclk", NULL);
+
+        clk = clk_register_gate(NULL, "ras_syn3_gclk", "gen3_syn_gclk", 0,
+                        RAS_CLK_ENB, RAS_SYNT3_CLK_ENB, 0, &_lock);
+        clk_register_clkdev(clk, "ras_syn3_gclk", NULL);
 
         if (of_machine_is_compatible("st,spear300"))
                 spear300_clk_init();
diff --git a/drivers/clk/spear/spear6xx_clock.c b/drivers/clk/spear/spear6xx_clock.c
index 61026ae564ab..a98d0866f541 100644
--- a/drivers/clk/spear/spear6xx_clock.c
+++ b/drivers/clk/spear/spear6xx_clock.c
@@ -97,13 +97,12 @@ static struct aux_rate_tbl aux_rtbl[] = {
         {.xscale = 1, .yscale = 2, .eq = 1}, /* 166 MHz */
 };
 
-static const char *clcd_parents[] = { "pll3_48m_clk", "clcd_synth_gate_clk", };
-static const char *firda_parents[] = { "pll3_48m_clk", "firda_synth_gate_clk",
-};
-static const char *uart_parents[] = { "pll3_48m_clk", "uart_synth_gate_clk", };
-static const char *gpt0_1_parents[] = { "pll3_48m_clk", "gpt0_1_synth_clk", };
-static const char *gpt2_parents[] = { "pll3_48m_clk", "gpt2_synth_clk", };
-static const char *gpt3_parents[] = { "pll3_48m_clk", "gpt3_synth_clk", };
+static const char *clcd_parents[] = { "pll3_clk", "clcd_syn_gclk", };
+static const char *firda_parents[] = { "pll3_clk", "firda_syn_gclk", };
+static const char *uart_parents[] = { "pll3_clk", "uart_syn_gclk", };
+static const char *gpt0_1_parents[] = { "pll3_clk", "gpt0_1_syn_clk", };
+static const char *gpt2_parents[] = { "pll3_clk", "gpt2_syn_clk", };
+static const char *gpt3_parents[] = { "pll3_clk", "gpt3_syn_clk", };
 static const char *ddr_parents[] = { "ahb_clk", "ahbmult2_clk", "none",
         "pll2_clk", };
 
@@ -136,9 +135,9 @@ void __init spear6xx_clk_init(void)
         clk_register_clkdev(clk, NULL, "rtc-spear");
 
         /* clock derived from 30 MHz osc clk */
-        clk = clk_register_fixed_rate(NULL, "pll3_48m_clk", "osc_24m_clk", 0,
+        clk = clk_register_fixed_rate(NULL, "pll3_clk", "osc_24m_clk", 0,
                         48000000);
-        clk_register_clkdev(clk, "pll3_48m_clk", NULL);
+        clk_register_clkdev(clk, "pll3_clk", NULL);
 
         clk = clk_register_vco_pll("vco1_clk", "pll1_clk", NULL, "osc_30m_clk",
                         0, PLL1_CTR, PLL1_FRQ, pll_rtbl, ARRAY_SIZE(pll_rtbl),
@@ -146,9 +145,9 @@ void __init spear6xx_clk_init(void)
         clk_register_clkdev(clk, "vco1_clk", NULL);
         clk_register_clkdev(clk1, "pll1_clk", NULL);
 
-        clk = clk_register_vco_pll("vco2_clk", "pll2_clk", NULL,
-                        "osc_30m_clk", 0, PLL2_CTR, PLL2_FRQ, pll_rtbl,
-                        ARRAY_SIZE(pll_rtbl), &_lock, &clk1, NULL);
+        clk = clk_register_vco_pll("vco2_clk", "pll2_clk", NULL, "osc_30m_clk",
+                        0, PLL2_CTR, PLL2_FRQ, pll_rtbl, ARRAY_SIZE(pll_rtbl),
+                        &_lock, &clk1, NULL);
         clk_register_clkdev(clk, "vco2_clk", NULL);
         clk_register_clkdev(clk1, "pll2_clk", NULL);
 
@@ -165,111 +164,111 @@ void __init spear6xx_clk_init(void)
                         HCLK_RATIO_MASK, 0, &_lock);
         clk_register_clkdev(clk, "ahb_clk", NULL);
 
-        clk = clk_register_aux("uart_synth_clk", "uart_synth_gate_clk",
-                        "pll1_clk", 0, UART_CLK_SYNT, NULL, aux_rtbl,
-                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "uart_synth_clk", NULL);
-        clk_register_clkdev(clk1, "uart_synth_gate_clk", NULL);
+        clk = clk_register_aux("uart_syn_clk", "uart_syn_gclk", "pll1_clk", 0,
+                        UART_CLK_SYNT, NULL, aux_rtbl, ARRAY_SIZE(aux_rtbl),
+                        &_lock, &clk1);
+        clk_register_clkdev(clk, "uart_syn_clk", NULL);
+        clk_register_clkdev(clk1, "uart_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "uart_mux_clk", uart_parents,
+        clk = clk_register_mux(NULL, "uart_mclk", uart_parents,
                         ARRAY_SIZE(uart_parents), 0, PERIP_CLK_CFG,
                         UART_CLK_SHIFT, UART_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "uart_mux_clk", NULL);
+        clk_register_clkdev(clk, "uart_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "uart0", "uart_mux_clk", 0,
-                        PERIP1_CLK_ENB, UART0_CLK_ENB, 0, &_lock);
+        clk = clk_register_gate(NULL, "uart0", "uart_mclk", 0, PERIP1_CLK_ENB,
+                        UART0_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "d0000000.serial");
 
-        clk = clk_register_gate(NULL, "uart1", "uart_mux_clk", 0,
-                        PERIP1_CLK_ENB, UART1_CLK_ENB, 0, &_lock);
+        clk = clk_register_gate(NULL, "uart1", "uart_mclk", 0, PERIP1_CLK_ENB,
+                        UART1_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "d0080000.serial");
 
-        clk = clk_register_aux("firda_synth_clk", "firda_synth_gate_clk",
-                        "pll1_clk", 0, FIRDA_CLK_SYNT, NULL, aux_rtbl,
-                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "firda_synth_clk", NULL);
-        clk_register_clkdev(clk1, "firda_synth_gate_clk", NULL);
+        clk = clk_register_aux("firda_syn_clk", "firda_syn_gclk", "pll1_clk",
+                        0, FIRDA_CLK_SYNT, NULL, aux_rtbl, ARRAY_SIZE(aux_rtbl),
+                        &_lock, &clk1);
+        clk_register_clkdev(clk, "firda_syn_clk", NULL);
+        clk_register_clkdev(clk1, "firda_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "firda_mux_clk", firda_parents,
+        clk = clk_register_mux(NULL, "firda_mclk", firda_parents,
                         ARRAY_SIZE(firda_parents), 0, PERIP_CLK_CFG,
                         FIRDA_CLK_SHIFT, FIRDA_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "firda_mux_clk", NULL);
+        clk_register_clkdev(clk, "firda_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "firda_clk", "firda_mux_clk", 0,
+        clk = clk_register_gate(NULL, "firda_clk", "firda_mclk", 0,
                         PERIP1_CLK_ENB, FIRDA_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "firda");
 
-        clk = clk_register_aux("clcd_synth_clk", "clcd_synth_gate_clk",
-                        "pll1_clk", 0, CLCD_CLK_SYNT, NULL, aux_rtbl,
-                        ARRAY_SIZE(aux_rtbl), &_lock, &clk1);
-        clk_register_clkdev(clk, "clcd_synth_clk", NULL);
-        clk_register_clkdev(clk1, "clcd_synth_gate_clk", NULL);
+        clk = clk_register_aux("clcd_syn_clk", "clcd_syn_gclk", "pll1_clk",
+                        0, CLCD_CLK_SYNT, NULL, aux_rtbl, ARRAY_SIZE(aux_rtbl),
+                        &_lock, &clk1);
+        clk_register_clkdev(clk, "clcd_syn_clk", NULL);
+        clk_register_clkdev(clk1, "clcd_syn_gclk", NULL);
 
-        clk = clk_register_mux(NULL, "clcd_mux_clk", clcd_parents,
+        clk = clk_register_mux(NULL, "clcd_mclk", clcd_parents,
                         ARRAY_SIZE(clcd_parents), 0, PERIP_CLK_CFG,
                         CLCD_CLK_SHIFT, CLCD_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "clcd_mux_clk", NULL);
+        clk_register_clkdev(clk, "clcd_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "clcd_clk", "clcd_mux_clk", 0,
+        clk = clk_register_gate(NULL, "clcd_clk", "clcd_mclk", 0,
                         PERIP1_CLK_ENB, CLCD_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "clcd");
 
         /* gpt clocks */
-        clk = clk_register_gpt("gpt0_1_synth_clk", "pll1_clk", 0, PRSC0_CLK_CFG,
+        clk = clk_register_gpt("gpt0_1_syn_clk", "pll1_clk", 0, PRSC0_CLK_CFG,
                         gpt_rtbl, ARRAY_SIZE(gpt_rtbl), &_lock);
-        clk_register_clkdev(clk, "gpt0_1_synth_clk", NULL);
+        clk_register_clkdev(clk, "gpt0_1_syn_clk", NULL);
 
-        clk = clk_register_mux(NULL, "gpt0_mux_clk", gpt0_1_parents,
+        clk = clk_register_mux(NULL, "gpt0_mclk", gpt0_1_parents,
                         ARRAY_SIZE(gpt0_1_parents), 0, PERIP_CLK_CFG,
                         GPT0_CLK_SHIFT, GPT_CLK_MASK, 0, &_lock);
         clk_register_clkdev(clk, NULL, "gpt0");
 
-        clk = clk_register_mux(NULL, "gpt1_mux_clk", gpt0_1_parents,
+        clk = clk_register_mux(NULL, "gpt1_mclk", gpt0_1_parents,
                         ARRAY_SIZE(gpt0_1_parents), 0, PERIP_CLK_CFG,
                         GPT1_CLK_SHIFT, GPT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gpt1_mux_clk", NULL);
+        clk_register_clkdev(clk, "gpt1_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "gpt1_clk", "gpt1_mux_clk", 0,
+        clk = clk_register_gate(NULL, "gpt1_clk", "gpt1_mclk", 0,
                         PERIP1_CLK_ENB, GPT1_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "gpt1");
 
-        clk = clk_register_gpt("gpt2_synth_clk", "pll1_clk", 0, PRSC1_CLK_CFG,
+        clk = clk_register_gpt("gpt2_syn_clk", "pll1_clk", 0, PRSC1_CLK_CFG,
                         gpt_rtbl, ARRAY_SIZE(gpt_rtbl), &_lock);
-        clk_register_clkdev(clk, "gpt2_synth_clk", NULL);
+        clk_register_clkdev(clk, "gpt2_syn_clk", NULL);
 
-        clk = clk_register_mux(NULL, "gpt2_mux_clk", gpt2_parents,
+        clk = clk_register_mux(NULL, "gpt2_mclk", gpt2_parents,
                         ARRAY_SIZE(gpt2_parents), 0, PERIP_CLK_CFG,
                         GPT2_CLK_SHIFT, GPT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gpt2_mux_clk", NULL);
+        clk_register_clkdev(clk, "gpt2_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "gpt2_clk", "gpt2_mux_clk", 0,
+        clk = clk_register_gate(NULL, "gpt2_clk", "gpt2_mclk", 0,
                         PERIP1_CLK_ENB, GPT2_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "gpt2");
 
-        clk = clk_register_gpt("gpt3_synth_clk", "pll1_clk", 0, PRSC2_CLK_CFG,
+        clk = clk_register_gpt("gpt3_syn_clk", "pll1_clk", 0, PRSC2_CLK_CFG,
                         gpt_rtbl, ARRAY_SIZE(gpt_rtbl), &_lock);
-        clk_register_clkdev(clk, "gpt3_synth_clk", NULL);
+        clk_register_clkdev(clk, "gpt3_syn_clk", NULL);
 
-        clk = clk_register_mux(NULL, "gpt3_mux_clk", gpt3_parents,
+        clk = clk_register_mux(NULL, "gpt3_mclk", gpt3_parents,
                         ARRAY_SIZE(gpt3_parents), 0, PERIP_CLK_CFG,
                         GPT3_CLK_SHIFT, GPT_CLK_MASK, 0, &_lock);
-        clk_register_clkdev(clk, "gpt3_mux_clk", NULL);
+        clk_register_clkdev(clk, "gpt3_mclk", NULL);
 
-        clk = clk_register_gate(NULL, "gpt3_clk", "gpt3_mux_clk", 0,
+        clk = clk_register_gate(NULL, "gpt3_clk", "gpt3_mclk", 0,
                         PERIP1_CLK_ENB, GPT3_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "gpt3");
 
         /* clock derived from pll3 clk */
-        clk = clk_register_gate(NULL, "usbh0_clk", "pll3_48m_clk", 0,
+        clk = clk_register_gate(NULL, "usbh0_clk", "pll3_clk", 0,
                         PERIP1_CLK_ENB, USBH0_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "usbh.0_clk");
 
-        clk = clk_register_gate(NULL, "usbh1_clk", "pll3_48m_clk", 0,
+        clk = clk_register_gate(NULL, "usbh1_clk", "pll3_clk", 0,
                         PERIP1_CLK_ENB, USBH1_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "usbh.1_clk");
 
-        clk = clk_register_gate(NULL, "usbd_clk", "pll3_48m_clk", 0,
-                        PERIP1_CLK_ENB, USBD_CLK_ENB, 0, &_lock);
+        clk = clk_register_gate(NULL, "usbd_clk", "pll3_clk", 0, PERIP1_CLK_ENB,
+                        USBD_CLK_ENB, 0, &_lock);
         clk_register_clkdev(clk, NULL, "designware_udc");
 
         /* clock derived from ahb clk */
@@ -278,9 +277,8 @@ void __init spear6xx_clk_init(void)
         clk_register_clkdev(clk, "ahbmult2_clk", NULL);
 
         clk = clk_register_mux(NULL, "ddr_clk", ddr_parents,
-                        ARRAY_SIZE(ddr_parents),
-                        0, PLL_CLK_CFG, MCTR_CLK_SHIFT, MCTR_CLK_MASK, 0,
-                        &_lock);
+                        ARRAY_SIZE(ddr_parents), 0, PLL_CLK_CFG, MCTR_CLK_SHIFT,
+                        MCTR_CLK_MASK, 0, &_lock);
         clk_register_clkdev(clk, "ddr_clk", NULL);
 
         clk = clk_register_divider(NULL, "apb_clk", "ahb_clk",
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 7f2f149ae40f..fb8a5279c5d8 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -138,7 +138,7 @@ void disable_cpufreq(void)
 static LIST_HEAD(cpufreq_governor_list);
 static DEFINE_MUTEX(cpufreq_governor_mutex);
 
-struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
+static struct cpufreq_policy *__cpufreq_cpu_get(unsigned int cpu, bool sysfs)
 {
         struct cpufreq_policy *data;
         unsigned long flags;
@@ -162,7 +162,7 @@ struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
         if (!data)
                 goto err_out_put_module;
 
-        if (!kobject_get(&data->kobj))
+        if (!sysfs && !kobject_get(&data->kobj))
                 goto err_out_put_module;
 
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
@@ -175,16 +175,35 @@ err_out_unlock:
 err_out:
         return NULL;
 }
+
+struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
+{
+        return __cpufreq_cpu_get(cpu, false);
+}
 EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
 
+static struct cpufreq_policy *cpufreq_cpu_get_sysfs(unsigned int cpu)
+{
+        return __cpufreq_cpu_get(cpu, true);
+}
 
-void cpufreq_cpu_put(struct cpufreq_policy *data)
+static void __cpufreq_cpu_put(struct cpufreq_policy *data, bool sysfs)
 {
-        kobject_put(&data->kobj);
+        if (!sysfs)
+                kobject_put(&data->kobj);
         module_put(cpufreq_driver->owner);
 }
+
+void cpufreq_cpu_put(struct cpufreq_policy *data)
+{
+        __cpufreq_cpu_put(data, false);
+}
 EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
 
+static void cpufreq_cpu_put_sysfs(struct cpufreq_policy *data)
+{
+        __cpufreq_cpu_put(data, true);
+}
 
 /*********************************************************************
  *            EXTERNALLY AFFECTING FREQUENCY CHANGES                 *
@@ -617,7 +636,7 @@ static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
         struct cpufreq_policy *policy = to_policy(kobj);
         struct freq_attr *fattr = to_attr(attr);
         ssize_t ret = -EINVAL;
-        policy = cpufreq_cpu_get(policy->cpu);
+        policy = cpufreq_cpu_get_sysfs(policy->cpu);
         if (!policy)
                 goto no_policy;
 
@@ -631,7 +650,7 @@ static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
 
         unlock_policy_rwsem_read(policy->cpu);
 fail:
-        cpufreq_cpu_put(policy);
+        cpufreq_cpu_put_sysfs(policy);
 no_policy:
         return ret;
 }
@@ -642,7 +661,7 @@ static ssize_t store(struct kobject *kobj, struct attribute *attr,
         struct cpufreq_policy *policy = to_policy(kobj);
         struct freq_attr *fattr = to_attr(attr);
         ssize_t ret = -EINVAL;
-        policy = cpufreq_cpu_get(policy->cpu);
+        policy = cpufreq_cpu_get_sysfs(policy->cpu);
         if (!policy)
                 goto no_policy;
 
@@ -656,7 +675,7 @@ static ssize_t store(struct kobject *kobj, struct attribute *attr,
 
         unlock_policy_rwsem_write(policy->cpu);
 fail:
-        cpufreq_cpu_put(policy);
+        cpufreq_cpu_put_sysfs(policy);
 no_policy:
         return ret;
 }
diff --git a/drivers/cpufreq/exynos-cpufreq.c b/drivers/cpufreq/exynos-cpufreq.c
index b243a7ee01f6..af2d81e10f71 100644
--- a/drivers/cpufreq/exynos-cpufreq.c
+++ b/drivers/cpufreq/exynos-cpufreq.c
@@ -62,8 +62,18 @@ static int exynos_target(struct cpufreq_policy *policy,
                 goto out;
         }
 
-        if (cpufreq_frequency_table_target(policy, freq_table,
-                                           freqs.old, relation, &old_index)) {
+        /*
+         * The policy max have been changed so that we cannot get proper
+         * old_index with cpufreq_frequency_table_target(). Thus, ignore
+         * policy and get the index from the raw freqeuncy table.
+         */
+        for (old_index = 0;
+                freq_table[old_index].frequency != CPUFREQ_TABLE_END;
+                old_index++)
+                if (freq_table[old_index].frequency == freqs.old)
+                        break;
+
+        if (freq_table[old_index].frequency == CPUFREQ_TABLE_END) {
                 ret = -EINVAL;
                 goto out;
         }
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index d90519cec880..d6a533e68e0f 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -201,6 +201,22 @@ void cpuidle_resume_and_unlock(void)
 
 EXPORT_SYMBOL_GPL(cpuidle_resume_and_unlock);
 
+/* Currently used in suspend/resume path to suspend cpuidle */
+void cpuidle_pause(void)
+{
+        mutex_lock(&cpuidle_lock);
+        cpuidle_uninstall_idle_handler();
+        mutex_unlock(&cpuidle_lock);
+}
+
+/* Currently used in suspend/resume path to resume cpuidle */
+void cpuidle_resume(void)
+{
+        mutex_lock(&cpuidle_lock);
+        cpuidle_install_idle_handler();
+        mutex_unlock(&cpuidle_lock);
+}
+
 /**
  * cpuidle_wrap_enter - performs timekeeping and irqen around enter function
  * @dev: pointer to a valid cpuidle_device object
@@ -265,7 +281,7 @@ static void poll_idle_init(struct cpuidle_driver *drv)
         state->power_usage = -1;
         state->flags = 0;
         state->enter = poll_idle;
-        state->disable = 0;
+        state->disabled = false;
 }
 #else
 static void poll_idle_init(struct cpuidle_driver *drv) {}
diff --git a/drivers/cpuidle/driver.c b/drivers/cpuidle/driver.c
index 40cd3f3024df..58bf3b1ac9c4 100644
--- a/drivers/cpuidle/driver.c
+++ b/drivers/cpuidle/driver.c
@@ -16,6 +16,7 @@
 
 static struct cpuidle_driver *cpuidle_curr_driver;
 DEFINE_SPINLOCK(cpuidle_driver_lock);
+int cpuidle_driver_refcount;
 
 static void __cpuidle_register_driver(struct cpuidle_driver *drv)
 {
@@ -89,8 +90,34 @@ void cpuidle_unregister_driver(struct cpuidle_driver *drv)
         }
 
         spin_lock(&cpuidle_driver_lock);
-        cpuidle_curr_driver = NULL;
+
+        if (!WARN_ON(cpuidle_driver_refcount > 0))
+                cpuidle_curr_driver = NULL;
+
         spin_unlock(&cpuidle_driver_lock);
 }
 
 EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
+
+struct cpuidle_driver *cpuidle_driver_ref(void)
+{
+        struct cpuidle_driver *drv;
+
+        spin_lock(&cpuidle_driver_lock);
+
+        drv = cpuidle_curr_driver;
+        cpuidle_driver_refcount++;
+
+        spin_unlock(&cpuidle_driver_lock);
+        return drv;
+}
+
+void cpuidle_driver_unref(void)
+{
+        spin_lock(&cpuidle_driver_lock);
+
+        if (!WARN_ON(cpuidle_driver_refcount <= 0))
+                cpuidle_driver_refcount--;
+
+        spin_unlock(&cpuidle_driver_lock);
+}
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index 06335756ea14..5b1f2c372c1f 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -281,7 +281,8 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
          * unless the timer is happening really really soon.
          */
         if (data->expected_us > 5 &&
-                drv->states[CPUIDLE_DRIVER_STATE_START].disable == 0)
+            !drv->states[CPUIDLE_DRIVER_STATE_START].disabled &&
+                dev->states_usage[CPUIDLE_DRIVER_STATE_START].disable == 0)
                 data->last_state_idx = CPUIDLE_DRIVER_STATE_START;
 
         /*
@@ -290,8 +291,9 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
          */
         for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++) {
                 struct cpuidle_state *s = &drv->states[i];
+                struct cpuidle_state_usage *su = &dev->states_usage[i];
 
-                if (s->disable)
+                if (s->disabled || su->disable)
                         continue;
                 if (s->target_residency > data->predicted_us)
                         continue;
diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c
index 88032b4dc6d2..5f809e337b89 100644
--- a/drivers/cpuidle/sysfs.c
+++ b/drivers/cpuidle/sysfs.c
@@ -217,7 +217,8 @@ struct cpuidle_state_attr {
         struct attribute attr;
         ssize_t (*show)(struct cpuidle_state *, \
                                         struct cpuidle_state_usage *, char *);
-        ssize_t (*store)(struct cpuidle_state *, const char *, size_t);
+        ssize_t (*store)(struct cpuidle_state *, \
+                        struct cpuidle_state_usage *, const char *, size_t);
 };
 
 #define define_one_state_ro(_name, show) \
@@ -233,21 +234,22 @@ static ssize_t show_state_##_name(struct cpuidle_state *state, \
         return sprintf(buf, "%u\n", state->_name);\
 }
 
-#define define_store_state_function(_name) \
+#define define_store_state_ull_function(_name) \
 static ssize_t store_state_##_name(struct cpuidle_state *state, \
+                struct cpuidle_state_usage *state_usage, \
                 const char *buf, size_t size) \
 { \
-        long value; \
+        unsigned long long value; \
         int err; \
         if (!capable(CAP_SYS_ADMIN)) \
                 return -EPERM; \
-        err = kstrtol(buf, 0, &value); \
+        err = kstrtoull(buf, 0, &value); \
         if (err) \
                 return err; \
         if (value) \
-                state->disable = 1; \
+                state_usage->_name = 1; \
         else \
-                state->disable = 0; \
+                state_usage->_name = 0; \
         return size; \
 }
 
@@ -273,8 +275,8 @@ define_show_state_ull_function(usage)
 define_show_state_ull_function(time)
 define_show_state_str_function(name)
 define_show_state_str_function(desc)
-define_show_state_function(disable)
-define_store_state_function(disable)
+define_show_state_ull_function(disable)
+define_store_state_ull_function(disable)
 
 define_one_state_ro(name, show_state_name);
 define_one_state_ro(desc, show_state_desc);
@@ -318,10 +320,11 @@ static ssize_t cpuidle_state_store(struct kobject *kobj,
 {
         int ret = -EIO;
         struct cpuidle_state *state = kobj_to_state(kobj);
+        struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
         struct cpuidle_state_attr *cattr = attr_to_stateattr(attr);
 
         if (cattr->store)
-                ret = cattr->store(state, buf, size);
+                ret = cattr->store(state, state_usage, buf, size);
 
         return ret;
 }
diff --git a/drivers/crypto/ux500/cryp/cryp_core.c b/drivers/crypto/ux500/cryp/cryp_core.c
index 7cac12793a4b..1c307e1b840c 100644
--- a/drivers/crypto/ux500/cryp/cryp_core.c
+++ b/drivers/crypto/ux500/cryp/cryp_core.c
@@ -1661,27 +1661,26 @@ static void ux500_cryp_shutdown(struct platform_device *pdev)
 
 }
 
-static int ux500_cryp_suspend(struct platform_device *pdev, pm_message_t state)
+static int ux500_cryp_suspend(struct device *dev)
 {
         int ret;
+        struct platform_device *pdev = to_platform_device(dev);
         struct cryp_device_data *device_data;
         struct resource *res_irq;
         struct cryp_ctx *temp_ctx = NULL;
 
-        dev_dbg(&pdev->dev, "[%s]", __func__);
+        dev_dbg(dev, "[%s]", __func__);
 
         /* Handle state? */
         device_data = platform_get_drvdata(pdev);
         if (!device_data) {
-                dev_err(&pdev->dev, "[%s]: platform_get_drvdata() failed!",
-                        __func__);
+                dev_err(dev, "[%s]: platform_get_drvdata() failed!", __func__);
                 return -ENOMEM;
         }
 
         res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (!res_irq)
-                dev_err(&pdev->dev, "[%s]: IORESOURCE_IRQ, unavailable",
-                        __func__);
+                dev_err(dev, "[%s]: IORESOURCE_IRQ, unavailable", __func__);
         else
                 disable_irq(res_irq->start);
 
@@ -1692,32 +1691,32 @@ static int ux500_cryp_suspend(struct platform_device *pdev, pm_message_t state)
 
         if (device_data->current_ctx == ++temp_ctx) {
                 if (down_interruptible(&driver_data.device_allocation))
-                        dev_dbg(&pdev->dev, "[%s]: down_interruptible() "
-                                        "failed", __func__);
-                ret = cryp_disable_power(&pdev->dev, device_data, false);
+                        dev_dbg(dev, "[%s]: down_interruptible() failed",
+                                __func__);
+                ret = cryp_disable_power(dev, device_data, false);
 
         } else
-                ret = cryp_disable_power(&pdev->dev, device_data, true);
+                ret = cryp_disable_power(dev, device_data, true);
 
         if (ret)
-                dev_err(&pdev->dev, "[%s]: cryp_disable_power()", __func__);
+                dev_err(dev, "[%s]: cryp_disable_power()", __func__);
 
         return ret;
 }
 
-static int ux500_cryp_resume(struct platform_device *pdev)
+static int ux500_cryp_resume(struct device *dev)
 {
         int ret = 0;
+        struct platform_device *pdev = to_platform_device(dev);
         struct cryp_device_data *device_data;
         struct resource *res_irq;
         struct cryp_ctx *temp_ctx = NULL;
 
-        dev_dbg(&pdev->dev, "[%s]", __func__);
+        dev_dbg(dev, "[%s]", __func__);
 
         device_data = platform_get_drvdata(pdev);
         if (!device_data) {
-                dev_err(&pdev->dev, "[%s]: platform_get_drvdata() failed!",
-                        __func__);
+                dev_err(dev, "[%s]: platform_get_drvdata() failed!", __func__);
                 return -ENOMEM;
         }
 
@@ -1730,11 +1729,10 @@ static int ux500_cryp_resume(struct platform_device *pdev)
         if (!device_data->current_ctx)
                 up(&driver_data.device_allocation);
         else
-                ret = cryp_enable_power(&pdev->dev, device_data, true);
+                ret = cryp_enable_power(dev, device_data, true);
 
         if (ret)
-                dev_err(&pdev->dev, "[%s]: cryp_enable_power() failed!",
-                        __func__);
+                dev_err(dev, "[%s]: cryp_enable_power() failed!", __func__);
         else {
                 res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
                 if (res_irq)
@@ -1744,15 +1742,16 @@ static int ux500_cryp_resume(struct platform_device *pdev)
         return ret;
 }
 
+static SIMPLE_DEV_PM_OPS(ux500_cryp_pm, ux500_cryp_suspend, ux500_cryp_resume);
+
 static struct platform_driver cryp_driver = {
         .probe  = ux500_cryp_probe,
         .remove = ux500_cryp_remove,
         .shutdown = ux500_cryp_shutdown,
-        .suspend  = ux500_cryp_suspend,
-        .resume   = ux500_cryp_resume,
         .driver = {
                 .owner = THIS_MODULE,
                 .name  = "cryp1"
+                .pm    = &ux500_cryp_pm,
         }
 };
 
diff --git a/drivers/crypto/ux500/hash/hash_core.c b/drivers/crypto/ux500/hash/hash_core.c
index 6dbb9ec709a3..08d5032cb564 100644
--- a/drivers/crypto/ux500/hash/hash_core.c
+++ b/drivers/crypto/ux500/hash/hash_core.c
@@ -1894,19 +1894,17 @@ static void ux500_hash_shutdown(struct platform_device *pdev)
 
 /**
  * ux500_hash_suspend - Function that suspends the hash device.
- * @pdev:       The platform device.
- * @state:      -
+ * @dev:        Device to suspend.
  */
-static int ux500_hash_suspend(struct platform_device *pdev, pm_message_t state)
+static int ux500_hash_suspend(struct device *dev)
 {
         int ret;
         struct hash_device_data *device_data;
         struct hash_ctx *temp_ctx = NULL;
 
-        device_data = platform_get_drvdata(pdev);
+        device_data = dev_get_drvdata(dev);
         if (!device_data) {
-                dev_err(&pdev->dev, "[%s] platform_get_drvdata() failed!",
-                                __func__);
+                dev_err(dev, "[%s] platform_get_drvdata() failed!", __func__);
                 return -ENOMEM;
         }
 
@@ -1917,33 +1915,32 @@ static int ux500_hash_suspend(struct platform_device *pdev, pm_message_t state)
 
         if (device_data->current_ctx == ++temp_ctx) {
                 if (down_interruptible(&driver_data.device_allocation))
-                        dev_dbg(&pdev->dev, "[%s]: down_interruptible() "
-                                        "failed", __func__);
+                        dev_dbg(dev, "[%s]: down_interruptible() failed",
+                                __func__);
                 ret = hash_disable_power(device_data, false);
 
         } else
                 ret = hash_disable_power(device_data, true);
 
         if (ret)
-                dev_err(&pdev->dev, "[%s]: hash_disable_power()", __func__);
+                dev_err(dev, "[%s]: hash_disable_power()", __func__);
 
         return ret;
 }
 
 /**
  * ux500_hash_resume - Function that resume the hash device.
- * @pdev:       The platform device.
+ * @dev:        Device to resume.
  */
-static int ux500_hash_resume(struct platform_device *pdev)
+static int ux500_hash_resume(struct device *dev)
 {
         int ret = 0;
         struct hash_device_data *device_data;
         struct hash_ctx *temp_ctx = NULL;
 
-        device_data = platform_get_drvdata(pdev);
+        device_data = dev_get_drvdata(dev);
         if (!device_data) {
-                dev_err(&pdev->dev, "[%s] platform_get_drvdata() failed!",
-                                __func__);
+                dev_err(dev, "[%s] platform_get_drvdata() failed!", __func__);
                 return -ENOMEM;
         }
 
@@ -1958,21 +1955,21 @@ static int ux500_hash_resume(struct platform_device *pdev)
                 ret = hash_enable_power(device_data, true);
 
         if (ret)
-                dev_err(&pdev->dev, "[%s]: hash_enable_power() failed!",
-                        __func__);
+                dev_err(dev, "[%s]: hash_enable_power() failed!", __func__);
 
         return ret;
 }
 
+static SIMPLE_DEV_PM_OPS(ux500_hash_pm, ux500_hash_suspend, ux500_hash_resume);
+
 static struct platform_driver hash_driver = {
         .probe  = ux500_hash_probe,
         .remove = ux500_hash_remove,
         .shutdown = ux500_hash_shutdown,
-        .suspend  = ux500_hash_suspend,
-        .resume   = ux500_hash_resume,
         .driver = {
                 .owner = THIS_MODULE,
                 .name  = "hash1",
+                .pm    = &ux500_hash_pm,
         }
 };
 
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index c4067d0141f7..542f0c04b695 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -136,7 +136,7 @@ config GPIO_MPC8XXX
 
 config GPIO_MSM_V1
         tristate "Qualcomm MSM GPIO v1"
-        depends on GPIOLIB && ARCH_MSM
+        depends on GPIOLIB && ARCH_MSM && (ARCH_MSM7X00A || ARCH_MSM7X30 || ARCH_QSD8X50)
         help
           Say yes here to support the GPIO interface on ARM v6 based
           Qualcomm MSM chips.  Most of the pins on the MSM can be
diff --git a/drivers/gpio/devres.c b/drivers/gpio/devres.c
index 9e9947cb86a3..1077754f8289 100644
--- a/drivers/gpio/devres.c
+++ b/drivers/gpio/devres.c
@@ -98,6 +98,7 @@ int devm_gpio_request_one(struct device *dev, unsigned gpio,
 
         return 0;
 }
+EXPORT_SYMBOL(devm_gpio_request_one);
 
 /**
  *      devm_gpio_free - free an interrupt
diff --git a/drivers/gpio/gpio-mxc.c b/drivers/gpio/gpio-mxc.c
index c337143b18f8..c89c4c1e668d 100644
--- a/drivers/gpio/gpio-mxc.c
+++ b/drivers/gpio/gpio-mxc.c
@@ -398,10 +398,12 @@ static int __devinit mxc_gpio_probe(struct platform_device *pdev)
         writel(~0, port->base + GPIO_ISR);
 
         if (mxc_gpio_hwtype == IMX21_GPIO) {
-                /* setup one handler for all GPIO interrupts */
-                if (pdev->id == 0)
-                        irq_set_chained_handler(port->irq,
-                                                mx2_gpio_irq_handler);
+                /*
+                 * Setup one handler for all GPIO interrupts. Actually setting
+                 * the handler is needed only once, but doing it for every port
+                 * is more robust and easier.
+                 */
+                irq_set_chained_handler(port->irq, mx2_gpio_irq_handler);
         } else {
                 /* setup one handler for each entry */
                 irq_set_chained_handler(port->irq, mx3_gpio_irq_handler);
diff --git a/drivers/gpio/gpio-omap.c b/drivers/gpio/gpio-omap.c
index c4ed1722734c..4fbc208c32cf 100644
--- a/drivers/gpio/gpio-omap.c
+++ b/drivers/gpio/gpio-omap.c
@@ -174,12 +174,22 @@ static inline void _gpio_dbck_enable(struct gpio_bank *bank)
         if (bank->dbck_enable_mask && !bank->dbck_enabled) {
                 clk_enable(bank->dbck);
                 bank->dbck_enabled = true;
+
+                __raw_writel(bank->dbck_enable_mask,
+                             bank->base + bank->regs->debounce_en);
         }
 }
 
 static inline void _gpio_dbck_disable(struct gpio_bank *bank)
 {
         if (bank->dbck_enable_mask && bank->dbck_enabled) {
+                /*
+                 * Disable debounce before cutting it's clock. If debounce is
+                 * enabled but the clock is not, GPIO module seems to be unable
+                 * to detect events and generate interrupts at least on OMAP3.
+                 */
+                __raw_writel(0, bank->base + bank->regs->debounce_en);
+
                 clk_disable(bank->dbck);
                 bank->dbck_enabled = false;
         }
@@ -1081,7 +1091,6 @@ static int __devinit omap_gpio_probe(struct platform_device *pdev)
         bank->is_mpuio = pdata->is_mpuio;
         bank->non_wakeup_gpios = pdata->non_wakeup_gpios;
         bank->loses_context = pdata->loses_context;
-        bank->get_context_loss_count = pdata->get_context_loss_count;
         bank->regs = pdata->regs;
 #ifdef CONFIG_OF_GPIO
         bank->chip.of_node = of_node_get(node);
@@ -1135,6 +1144,9 @@ static int __devinit omap_gpio_probe(struct platform_device *pdev)
         omap_gpio_chip_init(bank);
         omap_gpio_show_rev(bank);
 
+        if (bank->loses_context)
+                bank->get_context_loss_count = pdata->get_context_loss_count;
+
         pm_runtime_put(bank->dev);
 
         list_add_tail(&bank->node, &omap_gpio_list);
diff --git a/drivers/gpio/gpio-sta2x11.c b/drivers/gpio/gpio-sta2x11.c
index 38416be8ba11..6064fb376e11 100644
--- a/drivers/gpio/gpio-sta2x11.c
+++ b/drivers/gpio/gpio-sta2x11.c
@@ -383,8 +383,9 @@ static int __devinit gsta_probe(struct platform_device *dev)
         }
         spin_lock_init(&chip->lock);
         gsta_gpio_setup(chip);
-        for (i = 0; i < GSTA_NR_GPIO; i++)
-                gsta_set_config(chip, i, gpio_pdata->pinconfig[i]);
+        if (gpio_pdata)
+                for (i = 0; i < GSTA_NR_GPIO; i++)
+                        gsta_set_config(chip, i, gpio_pdata->pinconfig[i]);
 
         /* 384 was used in previous code: be compatible for other drivers */
         err = irq_alloc_descs(-1, 384, GSTA_NR_GPIO, NUMA_NO_NODE);
diff --git a/drivers/gpio/gpio-tps65910.c b/drivers/gpio/gpio-tps65910.c
index c1ad2884f2ed..11f29c82253c 100644
--- a/drivers/gpio/gpio-tps65910.c
+++ b/drivers/gpio/gpio-tps65910.c
@@ -149,6 +149,9 @@ static int __devinit tps65910_gpio_probe(struct platform_device *pdev)
         tps65910_gpio->gpio_chip.set    = tps65910_gpio_set;
         tps65910_gpio->gpio_chip.get    = tps65910_gpio_get;
         tps65910_gpio->gpio_chip.dev = &pdev->dev;
+#ifdef CONFIG_OF_GPIO
+        tps65910_gpio->gpio_chip.of_node = tps65910->dev->of_node;
+#endif
         if (pdata && pdata->gpio_base)
                 tps65910_gpio->gpio_chip.base = pdata->gpio_base;
         else
diff --git a/drivers/gpio/gpio-wm8994.c b/drivers/gpio/gpio-wm8994.c
index 92ea5350dfe9..aa61ad2fcaaa 100644
--- a/drivers/gpio/gpio-wm8994.c
+++ b/drivers/gpio/gpio-wm8994.c
@@ -89,8 +89,11 @@ static int wm8994_gpio_direction_out(struct gpio_chip *chip,
         struct wm8994_gpio *wm8994_gpio = to_wm8994_gpio(chip);
         struct wm8994 *wm8994 = wm8994_gpio->wm8994;
 
+        if (value)
+                value = WM8994_GPN_LVL;
+
         return wm8994_set_bits(wm8994, WM8994_GPIO_1 + offset,
-                               WM8994_GPN_DIR, 0);
+                               WM8994_GPN_DIR | WM8994_GPN_LVL, value);
 }
 
 static void wm8994_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 5873e481e5d2..a8743c399e83 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -1039,6 +1039,24 @@ mode_in_range(const struct drm_display_mode *mode, struct edid *edid,
         return true;
 }
 
+static bool valid_inferred_mode(const struct drm_connector *connector,
+                                const struct drm_display_mode *mode)
+{
+        struct drm_display_mode *m;
+        bool ok = false;
+
+        list_for_each_entry(m, &connector->probed_modes, head) {
+                if (mode->hdisplay == m->hdisplay &&
+                    mode->vdisplay == m->vdisplay &&
+                    drm_mode_vrefresh(mode) == drm_mode_vrefresh(m))
+                        return false; /* duplicated */
+                if (mode->hdisplay <= m->hdisplay &&
+                    mode->vdisplay <= m->vdisplay)
+                        ok = true;
+        }
+        return ok;
+}
+
 static int
 drm_dmt_modes_for_range(struct drm_connector *connector, struct edid *edid,
                         struct detailed_timing *timing)
@@ -1048,7 +1066,8 @@ drm_dmt_modes_for_range(struct drm_connector *connector, struct edid *edid,
         struct drm_device *dev = connector->dev;
 
         for (i = 0; i < drm_num_dmt_modes; i++) {
-                if (mode_in_range(drm_dmt_modes + i, edid, timing)) {
+                if (mode_in_range(drm_dmt_modes + i, edid, timing) &&
+                    valid_inferred_mode(connector, drm_dmt_modes + i)) {
                         newmode = drm_mode_duplicate(dev, &drm_dmt_modes[i]);
                         if (newmode) {
                                 drm_mode_probed_add(connector, newmode);
@@ -1088,7 +1107,8 @@ drm_gtf_modes_for_range(struct drm_connector *connector, struct edid *edid,
                         return modes;
 
                 fixup_mode_1366x768(newmode);
-                if (!mode_in_range(newmode, edid, timing)) {
+                if (!mode_in_range(newmode, edid, timing) ||
+                    !valid_inferred_mode(connector, newmode)) {
                         drm_mode_destroy(dev, newmode);
                         continue;
                 }
@@ -1116,7 +1136,8 @@ drm_cvt_modes_for_range(struct drm_connector *connector, struct edid *edid,
                         return modes;
 
                 fixup_mode_1366x768(newmode);
-                if (!mode_in_range(newmode, edid, timing)) {
+                if (!mode_in_range(newmode, edid, timing) ||
+                    !valid_inferred_mode(connector, newmode)) {
                         drm_mode_destroy(dev, newmode);
                         continue;
                 }
diff --git a/drivers/gpu/drm/gma500/cdv_device.c b/drivers/gpu/drm/gma500/cdv_device.c
index 9764045428ce..b7e7b49d8f62 100644
--- a/drivers/gpu/drm/gma500/cdv_device.c
+++ b/drivers/gpu/drm/gma500/cdv_device.c
@@ -78,21 +78,6 @@ static int cdv_backlight_combination_mode(struct drm_device *dev)
         return REG_READ(BLC_PWM_CTL2) & PWM_LEGACY_MODE;
 }
 
-static int cdv_get_brightness(struct backlight_device *bd)
-{
-        struct drm_device *dev = bl_get_data(bd);
-        u32 val = REG_READ(BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
-
-        if (cdv_backlight_combination_mode(dev)) {
-                u8 lbpc;
-
-                val &= ~1;
-                pci_read_config_byte(dev->pdev, 0xF4, &lbpc);
-                val *= lbpc;
-        }
-        return val;
-}
-
 static u32 cdv_get_max_backlight(struct drm_device *dev)
 {
         u32 max = REG_READ(BLC_PWM_CTL);
@@ -110,6 +95,22 @@ static u32 cdv_get_max_backlight(struct drm_device *dev)
         return max;
 }
 
+static int cdv_get_brightness(struct backlight_device *bd)
+{
+        struct drm_device *dev = bl_get_data(bd);
+        u32 val = REG_READ(BLC_PWM_CTL) & BACKLIGHT_DUTY_CYCLE_MASK;
+
+        if (cdv_backlight_combination_mode(dev)) {
+                u8 lbpc;
+
+                val &= ~1;
+                pci_read_config_byte(dev->pdev, 0xF4, &lbpc);
+                val *= lbpc;
+        }
+        return (val * 100)/cdv_get_max_backlight(dev);
+
+}
+
 static int cdv_set_brightness(struct backlight_device *bd)
 {
         struct drm_device *dev = bl_get_data(bd);
@@ -120,6 +121,9 @@ static int cdv_set_brightness(struct backlight_device *bd)
         if (level < 1)
                 level = 1;
 
+        level *= cdv_get_max_backlight(dev);
+        level /= 100;
+
         if (cdv_backlight_combination_mode(dev)) {
                 u32 max = cdv_get_max_backlight(dev);
                 u8 lbpc;
@@ -157,7 +161,6 @@ static int cdv_backlight_init(struct drm_device *dev)
 
         cdv_backlight_device->props.brightness =
                         cdv_get_brightness(cdv_backlight_device);
-        cdv_backlight_device->props.max_brightness = cdv_get_max_backlight(dev);
         backlight_update_status(cdv_backlight_device);
         dev_priv->backlight_device = cdv_backlight_device;
         return 0;
diff --git a/drivers/gpu/drm/gma500/opregion.c b/drivers/gpu/drm/gma500/opregion.c
index 4f186eca3a30..c430bd424681 100644
--- a/drivers/gpu/drm/gma500/opregion.c
+++ b/drivers/gpu/drm/gma500/opregion.c
@@ -144,6 +144,8 @@ struct opregion_asle {
 
 #define ASLE_CBLV_VALID         (1<<31)
 
+static struct psb_intel_opregion *system_opregion;
+
 static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
 {
         struct drm_psb_private *dev_priv = dev->dev_private;
@@ -205,7 +207,7 @@ void psb_intel_opregion_enable_asle(struct drm_device *dev)
         struct drm_psb_private *dev_priv = dev->dev_private;
         struct opregion_asle *asle = dev_priv->opregion.asle;
 
-        if (asle) {
+        if (asle && system_opregion ) {
                 /* Don't do this on Medfield or other non PC like devices, they
                    use the bit for something different altogether */
                 psb_enable_pipestat(dev_priv, 0, PIPE_LEGACY_BLC_EVENT_ENABLE);
@@ -221,7 +223,6 @@ void psb_intel_opregion_enable_asle(struct drm_device *dev)
 #define ACPI_EV_LID            (1<<1)
 #define ACPI_EV_DOCK           (1<<2)
 
-static struct psb_intel_opregion *system_opregion;
 
 static int psb_intel_opregion_video_event(struct notifier_block *nb,
                                           unsigned long val, void *data)
@@ -266,9 +267,6 @@ void psb_intel_opregion_init(struct drm_device *dev)
                 system_opregion = opregion;
                 register_acpi_notifier(&psb_intel_opregion_notifier);
         }
-
-        if (opregion->asle)
-                psb_intel_opregion_enable_asle(dev);
 }
 
 void psb_intel_opregion_fini(struct drm_device *dev)
diff --git a/drivers/gpu/drm/gma500/opregion.h b/drivers/gpu/drm/gma500/opregion.h
index 72dc6b921265..4a90f8b0e16c 100644
--- a/drivers/gpu/drm/gma500/opregion.h
+++ b/drivers/gpu/drm/gma500/opregion.h
@@ -27,6 +27,7 @@ extern void psb_intel_opregion_asle_intr(struct drm_device *dev);
 extern void psb_intel_opregion_init(struct drm_device *dev);
 extern void psb_intel_opregion_fini(struct drm_device *dev);
 extern int psb_intel_opregion_setup(struct drm_device *dev);
+extern void psb_intel_opregion_enable_asle(struct drm_device *dev);
 
 #else
 
@@ -46,4 +47,8 @@ extern inline int psb_intel_opregion_setup(struct drm_device *dev)
 {
         return 0;
 }
+
+extern inline void psb_intel_opregion_enable_asle(struct drm_device *dev)
+{
+}
 #endif
diff --git a/drivers/gpu/drm/gma500/psb_device.c b/drivers/gpu/drm/gma500/psb_device.c
index eff039bf92d4..5971bc82b765 100644
--- a/drivers/gpu/drm/gma500/psb_device.c
+++ b/drivers/gpu/drm/gma500/psb_device.c
@@ -144,6 +144,10 @@ static int psb_backlight_init(struct drm_device *dev)
         psb_backlight_device->props.max_brightness = 100;
         backlight_update_status(psb_backlight_device);
         dev_priv->backlight_device = psb_backlight_device;
+
+        /* This must occur after the backlight is properly initialised */
+        psb_lid_timer_init(dev_priv);
+
         return 0;
 }
 
@@ -354,13 +358,6 @@ static int psb_chip_setup(struct drm_device *dev)
         return 0;
 }
 
-/* Not exactly an erratum more an irritation */
-static void psb_chip_errata(struct drm_device *dev)
-{
-        struct drm_psb_private *dev_priv = dev->dev_private;
-        psb_lid_timer_init(dev_priv);
-}
-
 static void psb_chip_teardown(struct drm_device *dev)
 {
         struct drm_psb_private *dev_priv = dev->dev_private;
@@ -379,7 +376,6 @@ const struct psb_ops psb_chip_ops = {
         .sgx_offset = PSB_SGX_OFFSET,
         .chip_setup = psb_chip_setup,
         .chip_teardown = psb_chip_teardown,
-        .errata = psb_chip_errata,
 
         .crtc_helper = &psb_intel_helper_funcs,
         .crtc_funcs = &psb_intel_crtc_funcs,
diff --git a/drivers/gpu/drm/gma500/psb_drv.c b/drivers/gpu/drm/gma500/psb_drv.c
index caba6e08693c..a8858a907f47 100644
--- a/drivers/gpu/drm/gma500/psb_drv.c
+++ b/drivers/gpu/drm/gma500/psb_drv.c
@@ -374,6 +374,7 @@ static int psb_driver_load(struct drm_device *dev, unsigned long chipset)
 
         if (ret)
                 return ret;
+        psb_intel_opregion_enable_asle(dev);
 #if 0
         /*enable runtime pm at last*/
         pm_runtime_enable(&dev->pdev->dev);
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index f94792626b94..36822b924eb1 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -1401,6 +1401,27 @@ i915_mtrr_setup(struct drm_i915_private *dev_priv, unsigned long base,
         }
 }
 
+static void i915_kick_out_firmware_fb(struct drm_i915_private *dev_priv)
+{
+        struct apertures_struct *ap;
+        struct pci_dev *pdev = dev_priv->dev->pdev;
+        bool primary;
+
+        ap = alloc_apertures(1);
+        if (!ap)
+                return;
+
+        ap->ranges[0].base = dev_priv->dev->agp->base;
+        ap->ranges[0].size =
+                dev_priv->mm.gtt->gtt_mappable_entries << PAGE_SHIFT;
+        primary =
+                pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
+
+        remove_conflicting_framebuffers(ap, "inteldrmfb", primary);
+
+        kfree(ap);
+}
+
 /**
  * i915_driver_load - setup chip and create an initial config
  * @dev: DRM device
@@ -1446,6 +1467,15 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
                 goto free_priv;
         }
 
+        dev_priv->mm.gtt = intel_gtt_get();
+        if (!dev_priv->mm.gtt) {
+                DRM_ERROR("Failed to initialize GTT\n");
+                ret = -ENODEV;
+                goto put_bridge;
+        }
+
+        i915_kick_out_firmware_fb(dev_priv);
+
         pci_set_master(dev->pdev);
 
         /* overlay on gen2 is broken and can't address above 1G */
@@ -1471,13 +1501,6 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
                 goto put_bridge;
         }
 
-        dev_priv->mm.gtt = intel_gtt_get();
-        if (!dev_priv->mm.gtt) {
-                DRM_ERROR("Failed to initialize GTT\n");
-                ret = -ENODEV;
-                goto out_rmmap;
-        }
-
         aperture_size = dev_priv->mm.gtt->gtt_mappable_entries << PAGE_SHIFT;
 
         dev_priv->mm.gtt_mapping =
diff --git a/drivers/gpu/drm/radeon/radeon_gart.c b/drivers/gpu/drm/radeon/radeon_gart.c
index 59d44937dd9f..84b648a7ddd8 100644
--- a/drivers/gpu/drm/radeon/radeon_gart.c
+++ b/drivers/gpu/drm/radeon/radeon_gart.c
@@ -289,8 +289,9 @@ int radeon_vm_manager_init(struct radeon_device *rdev)
         rdev->vm_manager.enabled = false;
 
         /* mark first vm as always in use, it's the system one */
+        /* allocate enough for 2 full VM pts */
         r = radeon_sa_bo_manager_init(rdev, &rdev->vm_manager.sa_manager,
-                                      rdev->vm_manager.max_pfn * 8,
+                                      rdev->vm_manager.max_pfn * 8 * 2,
                                       RADEON_GEM_DOMAIN_VRAM);
         if (r) {
                 dev_err(rdev->dev, "failed to allocate vm bo (%dKB)\n",
@@ -633,7 +634,15 @@ int radeon_vm_init(struct radeon_device *rdev, struct radeon_vm *vm)
         mutex_init(&vm->mutex);
         INIT_LIST_HEAD(&vm->list);
         INIT_LIST_HEAD(&vm->va);
-        vm->last_pfn = 0;
+        /* SI requires equal sized PTs for all VMs, so always set
+         * last_pfn to max_pfn.  cayman allows variable sized
+         * pts so we can grow then as needed.  Once we switch
+         * to two level pts we can unify this again.
+         */
+        if (rdev->family >= CHIP_TAHITI)
+                vm->last_pfn = rdev->vm_manager.max_pfn;
+        else
+                vm->last_pfn = 0;
         /* map the ib pool buffer at 0 in virtual address space, set
          * read only
          */
diff --git a/drivers/gpu/drm/radeon/radeon_gem.c b/drivers/gpu/drm/radeon/radeon_gem.c
index f28bd4b7ef98..21ec9f5653ce 100644
--- a/drivers/gpu/drm/radeon/radeon_gem.c
+++ b/drivers/gpu/drm/radeon/radeon_gem.c
@@ -292,6 +292,7 @@ int radeon_gem_mmap_ioctl(struct drm_device *dev, void *data,
 int radeon_gem_busy_ioctl(struct drm_device *dev, void *data,
                           struct drm_file *filp)
 {
+        struct radeon_device *rdev = dev->dev_private;
         struct drm_radeon_gem_busy *args = data;
         struct drm_gem_object *gobj;
         struct radeon_bo *robj;
@@ -317,13 +318,14 @@ int radeon_gem_busy_ioctl(struct drm_device *dev, void *data,
                 break;
         }
         drm_gem_object_unreference_unlocked(gobj);
-        r = radeon_gem_handle_lockup(robj->rdev, r);
+        r = radeon_gem_handle_lockup(rdev, r);
         return r;
 }
 
 int radeon_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
                               struct drm_file *filp)
 {
+        struct radeon_device *rdev = dev->dev_private;
         struct drm_radeon_gem_wait_idle *args = data;
         struct drm_gem_object *gobj;
         struct radeon_bo *robj;
@@ -336,10 +338,10 @@ int radeon_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
         robj = gem_to_radeon_bo(gobj);
         r = radeon_bo_wait(robj, NULL, false);
         /* callback hw specific functions if any */
-        if (robj->rdev->asic->ioctl_wait_idle)
-                robj->rdev->asic->ioctl_wait_idle(robj->rdev, robj);
+        if (rdev->asic->ioctl_wait_idle)
+                robj->rdev->asic->ioctl_wait_idle(rdev, robj);
         drm_gem_object_unreference_unlocked(gobj);
-        r = radeon_gem_handle_lockup(robj->rdev, r);
+        r = radeon_gem_handle_lockup(rdev, r);
         return r;
 }
 
diff --git a/drivers/gpu/drm/radeon/si.c b/drivers/gpu/drm/radeon/si.c
index c7b61f16ecfd..0b0279291a73 100644
--- a/drivers/gpu/drm/radeon/si.c
+++ b/drivers/gpu/drm/radeon/si.c
@@ -2365,12 +2365,12 @@ int si_pcie_gart_enable(struct radeon_device *rdev)
         WREG32(0x15DC, 0);
 
         /* empty context1-15 */
-        /* FIXME start with 1G, once using 2 level pt switch to full
+        /* FIXME start with 4G, once using 2 level pt switch to full
          * vm size space
          */
         /* set vm size, must be a multiple of 4 */
         WREG32(VM_CONTEXT1_PAGE_TABLE_START_ADDR, 0);
-        WREG32(VM_CONTEXT1_PAGE_TABLE_END_ADDR, (1 << 30) / RADEON_GPU_PAGE_SIZE);
+        WREG32(VM_CONTEXT1_PAGE_TABLE_END_ADDR, rdev->vm_manager.max_pfn);
         for (i = 1; i < 16; i++) {
                 if (i < 8)
                         WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR + (i << 2),
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index bef04c192768..3fda8c87f02c 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -386,6 +386,7 @@ config HID_MULTITOUCH
           - Unitec Panels
           - XAT optical touch panels
           - Xiroku optical touch panels
+          - Zytronic touch panels
 
           If unsure, say N.
 
diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c
index fa10f847f7db..585344b6d338 100644
--- a/drivers/hid/hid-apple.c
+++ b/drivers/hid/hid-apple.c
@@ -517,6 +517,12 @@ static const struct hid_device_id apple_devices[] = {
                 .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS),
                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI),
+                .driver_data = APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS),
+                .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 6ac0286b5375..4c87276c8ddb 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1503,6 +1503,9 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
@@ -1995,6 +1998,7 @@ static const struct hid_device_id hid_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_BEATPAD) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
@@ -2089,6 +2093,9 @@ static const struct hid_device_id hid_mouse_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
         { }
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index d1cdd2d28409..32039235cfee 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -125,6 +125,9 @@
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI    0x024c
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ISO     0x024d
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_JIS     0x024e
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI    0x0262
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_ISO     0x0263
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_JIS     0x0264
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI  0x0239
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO   0x023a
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS   0x023b
@@ -518,6 +521,9 @@
 #define USB_DEVICE_ID_CRYSTALTOUCH      0x0006
 #define USB_DEVICE_ID_CRYSTALTOUCH_DUAL 0x0007
 
+#define USB_VENDOR_ID_MADCATZ           0x0738
+#define USB_DEVICE_ID_MADCATZ_BEATPAD   0x4540
+
 #define USB_VENDOR_ID_MCC               0x09db
 #define USB_DEVICE_ID_MCC_PMD1024LS     0x0076
 #define USB_DEVICE_ID_MCC_PMD1208LS     0x007a
@@ -653,6 +659,9 @@
 #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
 #define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE        0x0600
 
+#define USB_VENDOR_ID_SENNHEISER        0x1395
+#define USB_DEVICE_ID_SENNHEISER_BTD500USB      0x002c
+
 #define USB_VENDOR_ID_SIGMA_MICRO       0x1c4f
 #define USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD      0x0002
 
@@ -802,6 +811,9 @@
 #define USB_VENDOR_ID_ZYDACRON  0x13EC
 #define USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL   0x0006
 
+#define USB_VENDOR_ID_ZYTRONIC          0x14c8
+#define USB_DEVICE_ID_ZYTRONIC_ZXY100   0x0005
+
 #define USB_VENDOR_ID_PRIMAX    0x0461
 #define USB_DEVICE_ID_PRIMAX_KEYBOARD   0x4e05
 
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 132b0019365e..5301006f6c15 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -301,6 +301,9 @@ static const struct hid_device_id hid_battery_quirks[] = {
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
                                USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI),
           HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
+                USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
+          HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
         {}
 };
 
diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
index 6e3332a99976..76479246d4ee 100644
--- a/drivers/hid/hid-multitouch.c
+++ b/drivers/hid/hid-multitouch.c
@@ -1048,6 +1048,11 @@ static const struct hid_device_id mt_devices[] = {
                 MT_USB_DEVICE(USB_VENDOR_ID_XIROKU,
                         USB_DEVICE_ID_XIROKU_CSR2) },
 
+        /* Zytronic panels */
+        { .driver_data = MT_CLS_SERIAL,
+                MT_USB_DEVICE(USB_VENDOR_ID_ZYTRONIC,
+                        USB_DEVICE_ID_ZYTRONIC_ZXY100) },
+
         /* Generic MT device */
         { HID_DEVICE(HID_BUS_ANY, HID_GROUP_MULTITOUCH, HID_ANY_ID, HID_ANY_ID) },
         { }
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 0597ee604f6e..903eef3d3e10 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -76,6 +76,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_PRODIGE, USB_DEVICE_ID_PRODIGE_CORDLESS, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008, HID_QUIRK_NOGET },
+        { USB_VENDOR_ID_SENNHEISER, USB_DEVICE_ID_SENNHEISER_BTD500USB, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_SYMBOL, USB_DEVICE_ID_SYMBOL_SCANNER_1, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_SYMBOL, USB_DEVICE_ID_SYMBOL_SCANNER_2, HID_QUIRK_NOGET },
diff --git a/drivers/hwmon/acpi_power_meter.c b/drivers/hwmon/acpi_power_meter.c
index 34ad5a27a7e9..e3fcf8146834 100644
--- a/drivers/hwmon/acpi_power_meter.c
+++ b/drivers/hwmon/acpi_power_meter.c
@@ -929,20 +929,25 @@ static int acpi_power_meter_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static int acpi_power_meter_resume(struct acpi_device *device)
+static int acpi_power_meter_resume(struct device *dev)
 {
         struct acpi_power_meter_resource *resource;
 
-        if (!device || !acpi_driver_data(device))
+        if (!dev)
+                return -EINVAL;
+
+        resource = acpi_driver_data(to_acpi_device(dev));
+        if (!resource)
                 return -EINVAL;
 
-        resource = acpi_driver_data(device);
         free_capabilities(resource);
         read_capabilities(resource);
 
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(acpi_power_meter_pm, NULL, acpi_power_meter_resume);
+
 static struct acpi_driver acpi_power_meter_driver = {
         .name = "power_meter",
         .class = ACPI_POWER_METER_CLASS,
@@ -950,9 +955,9 @@ static struct acpi_driver acpi_power_meter_driver = {
         .ops = {
                 .add = acpi_power_meter_add,
                 .remove = acpi_power_meter_remove,
-                .resume = acpi_power_meter_resume,
                 .notify = acpi_power_meter_notify,
                 },
+        .drv.pm = &acpi_power_meter_pm,
 };
 
 /* Module init/exit routines */
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index e7701d99f8e8..f1de3979181f 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -2341,7 +2341,7 @@ static void __devinit it87_init_device(struct platform_device *pdev)
 
         /* Start monitoring */
         it87_write_value(data, IT87_REG_CONFIG,
-                         (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
+                         (it87_read_value(data, IT87_REG_CONFIG) & 0x3e)
                          | (update_vbat ? 0x41 : 0x01));
 }
 
diff --git a/drivers/hwmon/k10temp.c b/drivers/hwmon/k10temp.c
index 7356b5ec8f67..f2fe8078633b 100644
--- a/drivers/hwmon/k10temp.c
+++ b/drivers/hwmon/k10temp.c
@@ -33,9 +33,6 @@ static bool force;
 module_param(force, bool, 0444);
 MODULE_PARM_DESC(force, "force loading on processors with erratum 319");
 
-/* PCI-IDs for Northbridge devices not used anywhere else */
-#define PCI_DEVICE_ID_AMD_15H_M10H_NB_F3        0x1403
-
 /* CPUID function 0x80000001, ebx */
 #define CPUID_PKGTYPE_MASK      0xf0000000
 #define CPUID_PKGTYPE_F         0x00000000
@@ -213,7 +210,7 @@ static DEFINE_PCI_DEVICE_TABLE(k10temp_id_table) = {
         { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_11H_NB_MISC) },
         { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_CNB17H_F3) },
         { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_NB_F3) },
-        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_M10H_NB_F3) },
+        { PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_15H_M10H_F3) },
         {}
 };
 MODULE_DEVICE_TABLE(pci, k10temp_id_table);
diff --git a/drivers/hwspinlock/hwspinlock_core.c b/drivers/hwspinlock/hwspinlock_core.c
index 61c9cf15fa52..1201a15784c3 100644
--- a/drivers/hwspinlock/hwspinlock_core.c
+++ b/drivers/hwspinlock/hwspinlock_core.c
@@ -345,7 +345,7 @@ int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
                 spin_lock_init(&hwlock->lock);
                 hwlock->bank = bank;
 
-                ret = hwspin_lock_register_single(hwlock, i);
+                ret = hwspin_lock_register_single(hwlock, base_id + i);
                 if (ret)
                         goto reg_failed;
         }
@@ -354,7 +354,7 @@ int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
 
 reg_failed:
         while (--i >= 0)
-                hwspin_lock_unregister_single(i);
+                hwspin_lock_unregister_single(base_id + i);
         return ret;
 }
 EXPORT_SYMBOL_GPL(hwspin_lock_register);
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
index d0f59c3f87ef..fe95d5464a02 100644
--- a/drivers/idle/intel_idle.c
+++ b/drivers/idle/intel_idle.c
@@ -96,6 +96,7 @@ static const struct idle_cpu *icpu;
 static struct cpuidle_device __percpu *intel_idle_cpuidle_devices;
 static int intel_idle(struct cpuidle_device *dev,
                         struct cpuidle_driver *drv, int index);
+static int intel_idle_cpu_init(int cpu);
 
 static struct cpuidle_state *cpuidle_state_table;
 
@@ -302,22 +303,35 @@ static void __setup_broadcast_timer(void *arg)
         clockevents_notify(reason, &cpu);
 }
 
-static int setup_broadcast_cpuhp_notify(struct notifier_block *n,
-                unsigned long action, void *hcpu)
+static int cpu_hotplug_notify(struct notifier_block *n,
+                              unsigned long action, void *hcpu)
 {
         int hotcpu = (unsigned long)hcpu;
+        struct cpuidle_device *dev;
 
         switch (action & 0xf) {
         case CPU_ONLINE:
-                smp_call_function_single(hotcpu, __setup_broadcast_timer,
-                        (void *)true, 1);
+
+                if (lapic_timer_reliable_states != LAPIC_TIMER_ALWAYS_RELIABLE)
+                        smp_call_function_single(hotcpu, __setup_broadcast_timer,
+                                                 (void *)true, 1);
+
+                /*
+                 * Some systems can hotplug a cpu at runtime after
+                 * the kernel has booted, we have to initialize the
+                 * driver in this case
+                 */
+                dev = per_cpu_ptr(intel_idle_cpuidle_devices, hotcpu);
+                if (!dev->registered)
+                        intel_idle_cpu_init(hotcpu);
+
                 break;
         }
         return NOTIFY_OK;
 }
 
-static struct notifier_block setup_broadcast_notifier = {
-        .notifier_call = setup_broadcast_cpuhp_notify,
+static struct notifier_block cpu_hotplug_notifier = {
+        .notifier_call = cpu_hotplug_notify,
 };
 
 static void auto_demotion_disable(void *dummy)
@@ -405,10 +419,10 @@ static int intel_idle_probe(void)
 
         if (boot_cpu_has(X86_FEATURE_ARAT))     /* Always Reliable APIC Timer */
                 lapic_timer_reliable_states = LAPIC_TIMER_ALWAYS_RELIABLE;
-        else {
+        else
                 on_each_cpu(__setup_broadcast_timer, (void *)true, 1);
-                register_cpu_notifier(&setup_broadcast_notifier);
-        }
+
+        register_cpu_notifier(&cpu_hotplug_notifier);
 
         pr_debug(PREFIX "v" INTEL_IDLE_VERSION
                 " model 0x%X\n", boot_cpu_data.x86_model);
@@ -494,7 +508,7 @@ static int intel_idle_cpuidle_driver_init(void)
  * allocate, initialize, register cpuidle_devices
  * @cpu: cpu/core to initialize
  */
-int intel_idle_cpu_init(int cpu)
+static int intel_idle_cpu_init(int cpu)
 {
         int cstate;
         struct cpuidle_device *dev;
@@ -539,7 +553,6 @@ int intel_idle_cpu_init(int cpu)
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(intel_idle_cpu_init);
 
 static int __init intel_idle_init(void)
 {
@@ -581,10 +594,10 @@ static void __exit intel_idle_exit(void)
         intel_idle_cpuidle_devices_uninit();
         cpuidle_unregister_driver(&intel_idle_driver);
 
-        if (lapic_timer_reliable_states != LAPIC_TIMER_ALWAYS_RELIABLE) {
+
+        if (lapic_timer_reliable_states != LAPIC_TIMER_ALWAYS_RELIABLE)
                 on_each_cpu(__setup_broadcast_timer, (void *)false, 1);
-                unregister_cpu_notifier(&setup_broadcast_notifier);
-        }
+        unregister_cpu_notifier(&cpu_hotplug_notifier);
 
         return;
 }
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_ib.c b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
index 5c1bc995e560..f10221f40803 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_ib.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
@@ -123,7 +123,7 @@ static void ipoib_ud_skb_put_frags(struct ipoib_dev_priv *priv,
 
                 skb_frag_size_set(frag, size);
                 skb->data_len += size;
-                skb->truesize += size;
+                skb->truesize += PAGE_SIZE;
         } else
                 skb_put(skb, length);
 
@@ -156,14 +156,18 @@ static struct sk_buff *ipoib_alloc_rx_skb(struct net_device *dev, int id)
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct sk_buff *skb;
         int buf_size;
+        int tailroom;
         u64 *mapping;
 
-        if (ipoib_ud_need_sg(priv->max_ib_mtu))
+        if (ipoib_ud_need_sg(priv->max_ib_mtu)) {
                 buf_size = IPOIB_UD_HEAD_SIZE;
-        else
+                tailroom = 128; /* reserve some tailroom for IP/TCP headers */
+        } else {
                 buf_size = IPOIB_UD_BUF_SIZE(priv->max_ib_mtu);
+                tailroom = 0;
+        }
 
-        skb = dev_alloc_skb(buf_size + 4);
+        skb = dev_alloc_skb(buf_size + tailroom + 4);
         if (unlikely(!skb))
                 return NULL;
 
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
index 5f6b7f63cdef..7a0ce8d42887 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
@@ -1377,10 +1377,14 @@ static int srpt_abort_cmd(struct srpt_send_ioctx *ioctx)
                 break;
         case SRPT_STATE_NEED_DATA:
                 /* DMA_TO_DEVICE (write) - RDMA read error. */
+
+                /* XXX(hch): this is a horrible layering violation.. */
                 spin_lock_irqsave(&ioctx->cmd.t_state_lock, flags);
                 ioctx->cmd.transport_state |= CMD_T_LUN_STOP;
+                ioctx->cmd.transport_state &= ~CMD_T_ACTIVE;
                 spin_unlock_irqrestore(&ioctx->cmd.t_state_lock, flags);
-                transport_generic_handle_data(&ioctx->cmd);
+
+                complete(&ioctx->cmd.transport_lun_stop_comp);
                 break;
         case SRPT_STATE_CMD_RSP_SENT:
                 /*
@@ -1463,9 +1467,10 @@ static void srpt_handle_send_comp(struct srpt_rdma_ch *ch,
 /**
  * srpt_handle_rdma_comp() - Process an IB RDMA completion notification.
  *
- * Note: transport_generic_handle_data() is asynchronous so unmapping the
- * data that has been transferred via IB RDMA must be postponed until the
- * check_stop_free() callback.
+ * XXX: what is now target_execute_cmd used to be asynchronous, and unmapping
+ * the data that has been transferred via IB RDMA had to be postponed until the
+ * check_stop_free() callback.  None of this is nessecary anymore and needs to
+ * be cleaned up.
  */
 static void srpt_handle_rdma_comp(struct srpt_rdma_ch *ch,
                                   struct srpt_send_ioctx *ioctx,
@@ -1477,7 +1482,7 @@ static void srpt_handle_rdma_comp(struct srpt_rdma_ch *ch,
         if (opcode == SRPT_RDMA_READ_LAST) {
                 if (srpt_test_and_set_cmd_state(ioctx, SRPT_STATE_NEED_DATA,
                                                 SRPT_STATE_DATA_IN))
-                        transport_generic_handle_data(&ioctx->cmd);
+                        target_execute_cmd(&ioctx->cmd);
                 else
                         printk(KERN_ERR "%s[%d]: wrong state = %d\n", __func__,
                                __LINE__, srpt_get_cmd_state(ioctx));
diff --git a/drivers/input/joystick/as5011.c b/drivers/input/joystick/as5011.c
index 57d19d4e0a2d..c96653b58867 100644
--- a/drivers/input/joystick/as5011.c
+++ b/drivers/input/joystick/as5011.c
@@ -282,7 +282,8 @@ static int __devinit as5011_probe(struct i2c_client *client,
 
         error = request_threaded_irq(as5011->button_irq,
                                      NULL, as5011_button_interrupt,
-                                     IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                     IRQF_TRIGGER_RISING |
+                                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                      "as5011_button", as5011);
         if (error < 0) {
                 dev_err(&client->dev,
@@ -296,7 +297,7 @@ static int __devinit as5011_probe(struct i2c_client *client,
 
         error = request_threaded_irq(as5011->axis_irq, NULL,
                                      as5011_axis_interrupt,
-                                     plat_data->axis_irqflags,
+                                     plat_data->axis_irqflags | IRQF_ONESHOT,
                                      "as5011_joystick", as5011);
         if (error) {
                 dev_err(&client->dev,
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index ee16fb67b7ae..83811e45d633 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -142,6 +142,7 @@ static const struct xpad_device {
         { 0x0c12, 0x880a, "Pelican Eclipse PL-2023", 0, XTYPE_XBOX },
         { 0x0c12, 0x8810, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
         { 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", 0, XTYPE_XBOX },
+        { 0x0d2f, 0x0002, "Andamiro Pump It Up pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
         { 0x0e4c, 0x1097, "Radica Gamester Controller", 0, XTYPE_XBOX },
         { 0x0e4c, 0x2390, "Radica Games Jtech Controller", 0, XTYPE_XBOX },
         { 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", 0, XTYPE_XBOX },
@@ -164,6 +165,7 @@ static const struct xpad_device {
         { 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
         { 0x0f0d, 0x0016, "Hori Real Arcade Pro.EX", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
         { 0x0f0d, 0x000d, "Hori Fighting Stick EX2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
+        { 0x1689, 0xfd00, "Razer Onza Tournament Edition", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
         { 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
         { 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
 };
@@ -238,12 +240,14 @@ static struct usb_device_id xpad_table [] = {
         XPAD_XBOX360_VENDOR(0x045e),            /* Microsoft X-Box 360 controllers */
         XPAD_XBOX360_VENDOR(0x046d),            /* Logitech X-Box 360 style controllers */
         XPAD_XBOX360_VENDOR(0x0738),            /* Mad Catz X-Box 360 controllers */
+        { USB_DEVICE(0x0738, 0x4540) },         /* Mad Catz Beat Pad */
         XPAD_XBOX360_VENDOR(0x0e6f),            /* 0x0e6f X-Box 360 controllers */
         XPAD_XBOX360_VENDOR(0x12ab),            /* X-Box 360 dance pads */
         XPAD_XBOX360_VENDOR(0x1430),            /* RedOctane X-Box 360 controllers */
         XPAD_XBOX360_VENDOR(0x146b),            /* BigBen Interactive Controllers */
         XPAD_XBOX360_VENDOR(0x1bad),            /* Harminix Rock Band Guitar and Drums */
-        XPAD_XBOX360_VENDOR(0x0f0d),            /* Hori Controllers */
+        XPAD_XBOX360_VENDOR(0x0f0d),            /* Hori Controllers */
+        XPAD_XBOX360_VENDOR(0x1689),            /* Razer Onza */
         { }
 };
 
diff --git a/drivers/input/keyboard/mcs_touchkey.c b/drivers/input/keyboard/mcs_touchkey.c
index 64a0ca4c92f3..0d77f6c84950 100644
--- a/drivers/input/keyboard/mcs_touchkey.c
+++ b/drivers/input/keyboard/mcs_touchkey.c
@@ -178,7 +178,8 @@ static int __devinit mcs_touchkey_probe(struct i2c_client *client,
         }
 
         error = request_threaded_irq(client->irq, NULL, mcs_touchkey_interrupt,
-                        IRQF_TRIGGER_FALLING, client->dev.driver->name, data);
+                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                     client->dev.driver->name, data);
         if (error) {
                 dev_err(&client->dev, "Failed to register interrupt\n");
                 goto err_free_mem;
diff --git a/drivers/input/keyboard/mpr121_touchkey.c b/drivers/input/keyboard/mpr121_touchkey.c
index caa218a51b5a..7613f1cac951 100644
--- a/drivers/input/keyboard/mpr121_touchkey.c
+++ b/drivers/input/keyboard/mpr121_touchkey.c
@@ -248,7 +248,7 @@ static int __devinit mpr_touchkey_probe(struct i2c_client *client,
 
         error = request_threaded_irq(client->irq, NULL,
                                      mpr_touchkey_interrupt,
-                                     IRQF_TRIGGER_FALLING,
+                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                      client->dev.driver->name, mpr121);
         if (error) {
                 dev_err(&client->dev, "Failed to register interrupt\n");
diff --git a/drivers/input/keyboard/qt1070.c b/drivers/input/keyboard/qt1070.c
index 0b7b2f891752..ca68f2992d72 100644
--- a/drivers/input/keyboard/qt1070.c
+++ b/drivers/input/keyboard/qt1070.c
@@ -201,7 +201,8 @@ static int __devinit qt1070_probe(struct i2c_client *client,
         msleep(QT1070_RESET_TIME);
 
         err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
-                IRQF_TRIGGER_NONE, client->dev.driver->name, data);
+                                   IRQF_TRIGGER_NONE | IRQF_ONESHOT,
+                                   client->dev.driver->name, data);
         if (err) {
                 dev_err(&client->dev, "fail to request irq\n");
                 goto err_free_mem;
diff --git a/drivers/input/keyboard/tca6416-keypad.c b/drivers/input/keyboard/tca6416-keypad.c
index 3afea3f89718..c355cdde8d22 100644
--- a/drivers/input/keyboard/tca6416-keypad.c
+++ b/drivers/input/keyboard/tca6416-keypad.c
@@ -278,7 +278,8 @@ static int __devinit tca6416_keypad_probe(struct i2c_client *client,
 
                 error = request_threaded_irq(chip->irqnum, NULL,
                                              tca6416_keys_isr,
-                                             IRQF_TRIGGER_FALLING,
+                                             IRQF_TRIGGER_FALLING |
+                                                IRQF_ONESHOT,
                                              "tca6416-keypad", chip);
                 if (error) {
                         dev_dbg(&client->dev,
diff --git a/drivers/input/keyboard/tca8418_keypad.c b/drivers/input/keyboard/tca8418_keypad.c
index 5f87b28b3192..893869b29ed9 100644
--- a/drivers/input/keyboard/tca8418_keypad.c
+++ b/drivers/input/keyboard/tca8418_keypad.c
@@ -360,7 +360,7 @@ static int __devinit tca8418_keypad_probe(struct i2c_client *client,
                 client->irq = gpio_to_irq(client->irq);
 
         error = request_threaded_irq(client->irq, NULL, tca8418_irq_handler,
-                                     IRQF_TRIGGER_FALLING,
+                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                      client->name, keypad_data);
         if (error) {
                 dev_dbg(&client->dev,
diff --git a/drivers/input/keyboard/tnetv107x-keypad.c b/drivers/input/keyboard/tnetv107x-keypad.c
index a4a445fb7020..4c34f21fbe2d 100644
--- a/drivers/input/keyboard/tnetv107x-keypad.c
+++ b/drivers/input/keyboard/tnetv107x-keypad.c
@@ -227,15 +227,15 @@ static int __devinit keypad_probe(struct platform_device *pdev)
                 goto error_clk;
         }
 
-        error = request_threaded_irq(kp->irq_press, NULL, keypad_irq, 0,
-                                     dev_name(dev), kp);
+        error = request_threaded_irq(kp->irq_press, NULL, keypad_irq,
+                                     IRQF_ONESHOT, dev_name(dev), kp);
         if (error < 0) {
                 dev_err(kp->dev, "Could not allocate keypad press key irq\n");
                 goto error_irq_press;
         }
 
-        error = request_threaded_irq(kp->irq_release, NULL, keypad_irq, 0,
-                                     dev_name(dev), kp);
+        error = request_threaded_irq(kp->irq_release, NULL, keypad_irq,
+                                     IRQF_ONESHOT, dev_name(dev), kp);
         if (error < 0) {
                 dev_err(kp->dev, "Could not allocate keypad release key irq\n");
                 goto error_irq_release;
diff --git a/drivers/input/misc/ad714x.c b/drivers/input/misc/ad714x.c
index 0ac75bbad4d6..2e5d5e1de647 100644
--- a/drivers/input/misc/ad714x.c
+++ b/drivers/input/misc/ad714x.c
@@ -972,6 +972,7 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
         struct ad714x_platform_data *plat_data = dev->platform_data;
         struct ad714x_chip *ad714x;
         void *drv_mem;
+        unsigned long irqflags;
 
         struct ad714x_button_drv *bt_drv;
         struct ad714x_slider_drv *sd_drv;
@@ -1162,10 +1163,11 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
                 alloc_idx++;
         }
 
+        irqflags = plat_data->irqflags ?: IRQF_TRIGGER_FALLING;
+        irqflags |= IRQF_ONESHOT;
+
         error = request_threaded_irq(ad714x->irq, NULL, ad714x_interrupt_thread,
-                                plat_data->irqflags ?
-                                        plat_data->irqflags : IRQF_TRIGGER_FALLING,
-                                "ad714x_captouch", ad714x);
+                                     irqflags, "ad714x_captouch", ad714x);
         if (error) {
                 dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
                 goto err_unreg_dev;
diff --git a/drivers/input/misc/dm355evm_keys.c b/drivers/input/misc/dm355evm_keys.c
index 35083c6836c3..c1313d8535c3 100644
--- a/drivers/input/misc/dm355evm_keys.c
+++ b/drivers/input/misc/dm355evm_keys.c
@@ -213,7 +213,8 @@ static int __devinit dm355evm_keys_probe(struct platform_device *pdev)
         /* REVISIT:  flush the event queue? */
 
         status = request_threaded_irq(keys->irq, NULL, dm355evm_keys_irq,
-                        IRQF_TRIGGER_FALLING, dev_name(&pdev->dev), keys);
+                                      IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                      dev_name(&pdev->dev), keys);
         if (status < 0)
                 goto fail2;
 
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c
index 2cf681d98c0d..d528c23e194f 100644
--- a/drivers/input/mouse/bcm5974.c
+++ b/drivers/input/mouse/bcm5974.c
@@ -79,6 +79,10 @@
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI   0x0252
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO    0x0253
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS    0x0254
+/* MacbookPro10,1 (unibody, June 2012) */
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI    0x0262
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_ISO     0x0263
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_JIS     0x0264
 
 #define BCM5974_DEVICE(prod) {                                  \
         .match_flags = (USB_DEVICE_ID_MATCH_DEVICE |            \
@@ -128,6 +132,10 @@ static const struct usb_device_id bcm5974_table[] = {
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS),
+        /* MacbookPro10,1 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7_JIS),
         /* Terminating entry */
         {}
 };
@@ -354,6 +362,18 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 { DIM_X, DIM_X / SN_COORD, -4620, 5140 },
                 { DIM_Y, DIM_Y / SN_COORD, -150, 6600 }
         },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING7_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING7_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4750, 5280 },
+                { DIM_Y, DIM_Y / SN_COORD, -150, 6730 }
+        },
         {}
 };
 
diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c
index cad5602d3ce4..8b31473a81fe 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -216,7 +216,7 @@ static void wacom_retrieve_report_data(struct usb_interface *intf,
 
                 rep_data[0] = 12;
                 result = wacom_get_report(intf, WAC_HID_FEATURE_REPORT,
-                                          rep_data[0], &rep_data, 2,
+                                          rep_data[0], rep_data, 2,
                                           WAC_MSG_RETRIES);
 
                 if (result >= 0 && rep_data[1] > 2)
@@ -401,7 +401,9 @@ static int wacom_parse_hid(struct usb_interface *intf,
                                 break;
 
                         case HID_USAGE_CONTACTMAX:
-                                wacom_retrieve_report_data(intf, features);
+                                /* leave touch_max as is if predefined */
+                                if (!features->touch_max)
+                                        wacom_retrieve_report_data(intf, features);
                                 i++;
                                 break;
                         }
diff --git a/drivers/input/touchscreen/ad7879.c b/drivers/input/touchscreen/ad7879.c
index e2482b40da51..bd4eb4277697 100644
--- a/drivers/input/touchscreen/ad7879.c
+++ b/drivers/input/touchscreen/ad7879.c
@@ -597,7 +597,7 @@ struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq,
                         AD7879_TMR(ts->pen_down_acc_interval);
 
         err = request_threaded_irq(ts->irq, NULL, ad7879_irq,
-                                   IRQF_TRIGGER_FALLING,
+                                   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                    dev_name(dev), ts);
         if (err) {
                 dev_err(dev, "irq %d busy?\n", ts->irq);
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 42e645062c20..25fd0561a17d 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -1149,7 +1149,8 @@ static int __devinit mxt_probe(struct i2c_client *client,
                 goto err_free_object;
 
         error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
-                        pdata->irqflags, client->dev.driver->name, data);
+                                     pdata->irqflags | IRQF_ONESHOT,
+                                     client->dev.driver->name, data);
         if (error) {
                 dev_err(&client->dev, "Failed to register interrupt\n");
                 goto err_free_object;
diff --git a/drivers/input/touchscreen/bu21013_ts.c b/drivers/input/touchscreen/bu21013_ts.c
index f2d03c06c2da..5c487d23f11c 100644
--- a/drivers/input/touchscreen/bu21013_ts.c
+++ b/drivers/input/touchscreen/bu21013_ts.c
@@ -509,7 +509,8 @@ static int __devinit bu21013_probe(struct i2c_client *client,
         input_set_drvdata(in_dev, bu21013_data);
 
         error = request_threaded_irq(pdata->irq, NULL, bu21013_gpio_irq,
-                                     IRQF_TRIGGER_FALLING | IRQF_SHARED,
+                                     IRQF_TRIGGER_FALLING | IRQF_SHARED |
+                                        IRQF_ONESHOT,
                                      DRIVER_TP, bu21013_data);
         if (error) {
                 dev_err(&client->dev, "request irq %d failed\n", pdata->irq);
diff --git a/drivers/input/touchscreen/cy8ctmg110_ts.c b/drivers/input/touchscreen/cy8ctmg110_ts.c
index 237753ad1031..464f1bf4b61d 100644
--- a/drivers/input/touchscreen/cy8ctmg110_ts.c
+++ b/drivers/input/touchscreen/cy8ctmg110_ts.c
@@ -251,7 +251,8 @@ static int __devinit cy8ctmg110_probe(struct i2c_client *client,
         }
 
         err = request_threaded_irq(client->irq, NULL, cy8ctmg110_irq_thread,
-                                   IRQF_TRIGGER_RISING, "touch_reset_key", ts);
+                                   IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+                                   "touch_reset_key", ts);
         if (err < 0) {
                 dev_err(&client->dev,
                         "irq %d busy? error %d\n", client->irq, err);
diff --git a/drivers/input/touchscreen/intel-mid-touch.c b/drivers/input/touchscreen/intel-mid-touch.c
index 3cd7a837f82b..cf299377fc49 100644
--- a/drivers/input/touchscreen/intel-mid-touch.c
+++ b/drivers/input/touchscreen/intel-mid-touch.c
@@ -620,7 +620,7 @@ static int __devinit mrstouch_probe(struct platform_device *pdev)
                              MRST_PRESSURE_MIN, MRST_PRESSURE_MAX, 0, 0);
 
         err = request_threaded_irq(tsdev->irq, NULL, mrstouch_pendet_irq,
-                                   0, "mrstouch", tsdev);
+                                   IRQF_ONESHOT, "mrstouch", tsdev);
         if (err) {
                 dev_err(tsdev->dev, "unable to allocate irq\n");
                 goto err_free_mem;
diff --git a/drivers/input/touchscreen/pixcir_i2c_ts.c b/drivers/input/touchscreen/pixcir_i2c_ts.c
index 72f6ba3a4709..953b4c105cad 100644
--- a/drivers/input/touchscreen/pixcir_i2c_ts.c
+++ b/drivers/input/touchscreen/pixcir_i2c_ts.c
@@ -165,7 +165,7 @@ static int __devinit pixcir_i2c_ts_probe(struct i2c_client *client,
         input_set_drvdata(input, tsdata);
 
         error = request_threaded_irq(client->irq, NULL, pixcir_ts_isr,
-                                     IRQF_TRIGGER_FALLING,
+                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                      client->name, tsdata);
         if (error) {
                 dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
diff --git a/drivers/input/touchscreen/tnetv107x-ts.c b/drivers/input/touchscreen/tnetv107x-ts.c
index 7e7488097359..368d2c6cf780 100644
--- a/drivers/input/touchscreen/tnetv107x-ts.c
+++ b/drivers/input/touchscreen/tnetv107x-ts.c
@@ -297,7 +297,7 @@ static int __devinit tsc_probe(struct platform_device *pdev)
                 goto error_clk;
         }
 
-        error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, 0,
+        error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, IRQF_ONESHOT,
                                      dev_name(dev), ts);
         if (error < 0) {
                 dev_err(ts->dev, "Could not allocate ts irq\n");
diff --git a/drivers/input/touchscreen/tsc2005.c b/drivers/input/touchscreen/tsc2005.c
index b6adeaee9cc5..5ce3fa8ce646 100644
--- a/drivers/input/touchscreen/tsc2005.c
+++ b/drivers/input/touchscreen/tsc2005.c
@@ -650,7 +650,8 @@ static int __devinit tsc2005_probe(struct spi_device *spi)
         tsc2005_stop_scan(ts);
 
         error = request_threaded_irq(spi->irq, NULL, tsc2005_irq_thread,
-                                     IRQF_TRIGGER_RISING, "tsc2005", ts);
+                                     IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+                                     "tsc2005", ts);
         if (error) {
                 dev_err(&spi->dev, "Failed to request irq, err: %d\n", error);
                 goto err_free_mem;
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index a2e418cba0ff..625626391f2d 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -83,6 +83,8 @@ static struct iommu_ops amd_iommu_ops;
 static ATOMIC_NOTIFIER_HEAD(ppr_notifier);
 int amd_iommu_max_glx_val = -1;
 
+static struct dma_map_ops amd_iommu_dma_ops;
+
 /*
  * general struct to manage commands send to an IOMMU
  */
@@ -402,7 +404,7 @@ static void amd_iommu_stats_init(void)
                 return;
 
         de_fflush  = debugfs_create_bool("fullflush", 0444, stats_dir,
-                                         (u32 *)&amd_iommu_unmap_flush);
+                                         &amd_iommu_unmap_flush);
 
         amd_iommu_stats_add(&compl_wait);
         amd_iommu_stats_add(&cnt_map_single);
@@ -2267,6 +2269,13 @@ static int device_change_notifier(struct notifier_block *nb,
                 list_add_tail(&dma_domain->list, &iommu_pd_list);
                 spin_unlock_irqrestore(&iommu_pd_list_lock, flags);
 
+                dev_data = get_dev_data(dev);
+
+                if (!dev_data->passthrough)
+                        dev->archdata.dma_ops = &amd_iommu_dma_ops;
+                else
+                        dev->archdata.dma_ops = &nommu_dma_ops;
+
                 break;
         case BUS_NOTIFY_DEL_DEVICE:
 
diff --git a/drivers/iommu/amd_iommu_init.c b/drivers/iommu/amd_iommu_init.c
index 542024ba6dba..a33612f3206f 100644
--- a/drivers/iommu/amd_iommu_init.c
+++ b/drivers/iommu/amd_iommu_init.c
@@ -129,7 +129,7 @@ u16 amd_iommu_last_bdf;			/* largest PCI device id we have
                                            to handle */
 LIST_HEAD(amd_iommu_unity_map);         /* a list of required unity mappings
                                            we find in ACPI */
-bool amd_iommu_unmap_flush;             /* if true, flush on every unmap */
+u32 amd_iommu_unmap_flush;              /* if true, flush on every unmap */
 
 LIST_HEAD(amd_iommu_list);              /* list of all AMD IOMMUs in the
                                            system */
@@ -1641,6 +1641,8 @@ static int __init amd_iommu_init(void)
 
         amd_iommu_init_api();
 
+        x86_platform.iommu_shutdown = disable_iommus;
+
         if (iommu_pass_through)
                 goto out;
 
@@ -1649,8 +1651,6 @@ static int __init amd_iommu_init(void)
         else
                 printk(KERN_INFO "AMD-Vi: Lazy IO/TLB flushing enabled\n");
 
-        x86_platform.iommu_shutdown = disable_iommus;
-
 out:
         return ret;
 
diff --git a/drivers/iommu/amd_iommu_types.h b/drivers/iommu/amd_iommu_types.h
index 24355559a2ad..c1b1d489817e 100644
--- a/drivers/iommu/amd_iommu_types.h
+++ b/drivers/iommu/amd_iommu_types.h
@@ -652,7 +652,7 @@ extern unsigned long *amd_iommu_pd_alloc_bitmap;
  * If true, the addresses will be flushed on unmap time, not when
  * they are reused
  */
-extern bool amd_iommu_unmap_flush;
+extern u32 amd_iommu_unmap_flush;
 
 /* Smallest number of PASIDs supported by any IOMMU in the system */
 extern u32 amd_iommu_max_pasids;
diff --git a/drivers/iommu/dmar.c b/drivers/iommu/dmar.c
index 3a74e4410fc0..86e2f4a62b9a 100644
--- a/drivers/iommu/dmar.c
+++ b/drivers/iommu/dmar.c
@@ -26,6 +26,8 @@
  * These routines are used by both DMA-remapping and Interrupt-remapping
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt /* has to precede printk.h */
+
 #include <linux/pci.h>
 #include <linux/dmar.h>
 #include <linux/iova.h>
@@ -39,8 +41,6 @@
 #include <asm/irq_remapping.h>
 #include <asm/iommu_table.h>
 
-#define PREFIX "DMAR: "
-
 /* No locks are needed as DMA remapping hardware unit
  * list is constructed at boot time and hotplug of
  * these units are not supported by the architecture.
@@ -83,16 +83,12 @@ static int __init dmar_parse_one_dev_scope(struct acpi_dmar_device_scope *scope,
                  * ignore it
                  */
                 if (!bus) {
-                        printk(KERN_WARNING
-                        PREFIX "Device scope bus [%d] not found\n",
-                        scope->bus);
+                        pr_warn("Device scope bus [%d] not found\n", scope->bus);
                         break;
                 }
                 pdev = pci_get_slot(bus, PCI_DEVFN(path->dev, path->fn));
                 if (!pdev) {
-                        printk(KERN_WARNING PREFIX
-                        "Device scope device [%04x:%02x:%02x.%02x] not found\n",
-                                segment, bus->number, path->dev, path->fn);
+                        /* warning will be printed below */
                         break;
                 }
                 path ++;
@@ -100,9 +96,8 @@ static int __init dmar_parse_one_dev_scope(struct acpi_dmar_device_scope *scope,
                 bus = pdev->subordinate;
         }
         if (!pdev) {
-                printk(KERN_WARNING PREFIX
-                "Device scope device [%04x:%02x:%02x.%02x] not found\n",
-                segment, scope->bus, path->dev, path->fn);
+                pr_warn("Device scope device [%04x:%02x:%02x.%02x] not found\n",
+                        segment, scope->bus, path->dev, path->fn);
                 *dev = NULL;
                 return 0;
         }
@@ -110,9 +105,8 @@ static int __init dmar_parse_one_dev_scope(struct acpi_dmar_device_scope *scope,
                         pdev->subordinate) || (scope->entry_type == \
                         ACPI_DMAR_SCOPE_TYPE_BRIDGE && !pdev->subordinate)) {
                 pci_dev_put(pdev);
-                printk(KERN_WARNING PREFIX
-                        "Device scope type does not match for %s\n",
-                         pci_name(pdev));
+                pr_warn("Device scope type does not match for %s\n",
+                        pci_name(pdev));
                 return -EINVAL;
         }
         *dev = pdev;
@@ -134,8 +128,7 @@ int __init dmar_parse_dev_scope(void *start, void *end, int *cnt,
                     scope->entry_type == ACPI_DMAR_SCOPE_TYPE_BRIDGE)
                         (*cnt)++;
                 else if (scope->entry_type != ACPI_DMAR_SCOPE_TYPE_IOAPIC) {
-                        printk(KERN_WARNING PREFIX
-                               "Unsupported device scope\n");
+                        pr_warn("Unsupported device scope\n");
                 }
                 start += scope->length;
         }
@@ -261,25 +254,23 @@ dmar_table_print_dmar_entry(struct acpi_dmar_header *header)
         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
                 drhd = container_of(header, struct acpi_dmar_hardware_unit,
                                     header);
-                printk (KERN_INFO PREFIX
-                        "DRHD base: %#016Lx flags: %#x\n",
+                pr_info("DRHD base: %#016Lx flags: %#x\n",
                         (unsigned long long)drhd->address, drhd->flags);
                 break;
         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
                 rmrr = container_of(header, struct acpi_dmar_reserved_memory,
                                     header);
-                printk (KERN_INFO PREFIX
-                        "RMRR base: %#016Lx end: %#016Lx\n",
+                pr_info("RMRR base: %#016Lx end: %#016Lx\n",
                         (unsigned long long)rmrr->base_address,
                         (unsigned long long)rmrr->end_address);
                 break;
         case ACPI_DMAR_TYPE_ATSR:
                 atsr = container_of(header, struct acpi_dmar_atsr, header);
-                printk(KERN_INFO PREFIX "ATSR flags: %#x\n", atsr->flags);
+                pr_info("ATSR flags: %#x\n", atsr->flags);
                 break;
         case ACPI_DMAR_HARDWARE_AFFINITY:
                 rhsa = container_of(header, struct acpi_dmar_rhsa, header);
-                printk(KERN_INFO PREFIX "RHSA base: %#016Lx proximity domain: %#x\n",
+                pr_info("RHSA base: %#016Lx proximity domain: %#x\n",
                        (unsigned long long)rhsa->base_address,
                        rhsa->proximity_domain);
                 break;
@@ -299,7 +290,7 @@ static int __init dmar_table_detect(void)
                                 &dmar_tbl_size);
 
         if (ACPI_SUCCESS(status) && !dmar_tbl) {
-                printk (KERN_WARNING PREFIX "Unable to map DMAR\n");
+                pr_warn("Unable to map DMAR\n");
                 status = AE_NOT_FOUND;
         }
 
@@ -333,20 +324,18 @@ parse_dmar_table(void)
                 return -ENODEV;
 
         if (dmar->width < PAGE_SHIFT - 1) {
-                printk(KERN_WARNING PREFIX "Invalid DMAR haw\n");
+                pr_warn("Invalid DMAR haw\n");
                 return -EINVAL;
         }
 
-        printk (KERN_INFO PREFIX "Host address width %d\n",
-                dmar->width + 1);
+        pr_info("Host address width %d\n", dmar->width + 1);
 
         entry_header = (struct acpi_dmar_header *)(dmar + 1);
         while (((unsigned long)entry_header) <
                         (((unsigned long)dmar) + dmar_tbl->length)) {
                 /* Avoid looping forever on bad ACPI tables */
                 if (entry_header->length == 0) {
-                        printk(KERN_WARNING PREFIX
-                                "Invalid 0-length structure\n");
+                        pr_warn("Invalid 0-length structure\n");
                         ret = -EINVAL;
                         break;
                 }
@@ -369,8 +358,7 @@ parse_dmar_table(void)
 #endif
                         break;
                 default:
-                        printk(KERN_WARNING PREFIX
-                                "Unknown DMAR structure type %d\n",
+                        pr_warn("Unknown DMAR structure type %d\n",
                                 entry_header->type);
                         ret = 0; /* for forward compatibility */
                         break;
@@ -469,12 +457,12 @@ int __init dmar_table_init(void)
         ret = parse_dmar_table();
         if (ret) {
                 if (ret != -ENODEV)
-                        printk(KERN_INFO PREFIX "parse DMAR table failure.\n");
+                        pr_info("parse DMAR table failure.\n");
                 return ret;
         }
 
         if (list_empty(&dmar_drhd_units)) {
-                printk(KERN_INFO PREFIX "No DMAR devices found\n");
+                pr_info("No DMAR devices found\n");
                 return -ENODEV;
         }
 
@@ -506,8 +494,7 @@ int __init check_zero_address(void)
                         (((unsigned long)dmar) + dmar_tbl->length)) {
                 /* Avoid looping forever on bad ACPI tables */
                 if (entry_header->length == 0) {
-                        printk(KERN_WARNING PREFIX
-                                "Invalid 0-length structure\n");
+                        pr_warn("Invalid 0-length structure\n");
                         return 0;
                 }
 
@@ -558,8 +545,7 @@ int __init detect_intel_iommu(void)
 
                 if (ret && irq_remapping_enabled && cpu_has_x2apic &&
                     dmar->flags & 0x1)
-                        printk(KERN_INFO
-                               "Queued invalidation will be enabled to support x2apic and Intr-remapping.\n");
+                        pr_info("Queued invalidation will be enabled to support x2apic and Intr-remapping.\n");
 
                 if (ret && !no_iommu && !iommu_detected && !dmar_disabled) {
                         iommu_detected = 1;
@@ -579,14 +565,89 @@ int __init detect_intel_iommu(void)
 }
 
 
+static void unmap_iommu(struct intel_iommu *iommu)
+{
+        iounmap(iommu->reg);
+        release_mem_region(iommu->reg_phys, iommu->reg_size);
+}
+
+/**
+ * map_iommu: map the iommu's registers
+ * @iommu: the iommu to map
+ * @phys_addr: the physical address of the base resgister
+ *
+ * Memory map the iommu's registers.  Start w/ a single page, and
+ * possibly expand if that turns out to be insufficent.
+ */
+static int map_iommu(struct intel_iommu *iommu, u64 phys_addr)
+{
+        int map_size, err=0;
+
+        iommu->reg_phys = phys_addr;
+        iommu->reg_size = VTD_PAGE_SIZE;
+
+        if (!request_mem_region(iommu->reg_phys, iommu->reg_size, iommu->name)) {
+                pr_err("IOMMU: can't reserve memory\n");
+                err = -EBUSY;
+                goto out;
+        }
+
+        iommu->reg = ioremap(iommu->reg_phys, iommu->reg_size);
+        if (!iommu->reg) {
+                pr_err("IOMMU: can't map the region\n");
+                err = -ENOMEM;
+                goto release;
+        }
+
+        iommu->cap = dmar_readq(iommu->reg + DMAR_CAP_REG);
+        iommu->ecap = dmar_readq(iommu->reg + DMAR_ECAP_REG);
+
+        if (iommu->cap == (uint64_t)-1 && iommu->ecap == (uint64_t)-1) {
+                err = -EINVAL;
+                warn_invalid_dmar(phys_addr, " returns all ones");
+                goto unmap;
+        }
+
+        /* the registers might be more than one page */
+        map_size = max_t(int, ecap_max_iotlb_offset(iommu->ecap),
+                         cap_max_fault_reg_offset(iommu->cap));
+        map_size = VTD_PAGE_ALIGN(map_size);
+        if (map_size > iommu->reg_size) {
+                iounmap(iommu->reg);
+                release_mem_region(iommu->reg_phys, iommu->reg_size);
+                iommu->reg_size = map_size;
+                if (!request_mem_region(iommu->reg_phys, iommu->reg_size,
+                                        iommu->name)) {
+                        pr_err("IOMMU: can't reserve memory\n");
+                        err = -EBUSY;
+                        goto out;
+                }
+                iommu->reg = ioremap(iommu->reg_phys, iommu->reg_size);
+                if (!iommu->reg) {
+                        pr_err("IOMMU: can't map the region\n");
+                        err = -ENOMEM;
+                        goto release;
+                }
+        }
+        err = 0;
+        goto out;
+
+unmap:
+        iounmap(iommu->reg);
+release:
+        release_mem_region(iommu->reg_phys, iommu->reg_size);
+out:
+        return err;
+}
+
 int alloc_iommu(struct dmar_drhd_unit *drhd)
 {
         struct intel_iommu *iommu;
-        int map_size;
         u32 ver;
         static int iommu_allocated = 0;
         int agaw = 0;
         int msagaw = 0;
+        int err;
 
         if (!drhd->reg_base_addr) {
                 warn_invalid_dmar(0, "");
@@ -600,30 +661,22 @@ int alloc_iommu(struct dmar_drhd_unit *drhd)
         iommu->seq_id = iommu_allocated++;
         sprintf (iommu->name, "dmar%d", iommu->seq_id);
 
-        iommu->reg = ioremap(drhd->reg_base_addr, VTD_PAGE_SIZE);
-        if (!iommu->reg) {
-                printk(KERN_ERR "IOMMU: can't map the region\n");
+        err = map_iommu(iommu, drhd->reg_base_addr);
+        if (err) {
+                pr_err("IOMMU: failed to map %s\n", iommu->name);
                 goto error;
         }
-        iommu->cap = dmar_readq(iommu->reg + DMAR_CAP_REG);
-        iommu->ecap = dmar_readq(iommu->reg + DMAR_ECAP_REG);
-
-        if (iommu->cap == (uint64_t)-1 && iommu->ecap == (uint64_t)-1) {
-                warn_invalid_dmar(drhd->reg_base_addr, " returns all ones");
-                goto err_unmap;
-        }
 
+        err = -EINVAL;
         agaw = iommu_calculate_agaw(iommu);
         if (agaw < 0) {
-                printk(KERN_ERR
-                       "Cannot get a valid agaw for iommu (seq_id = %d)\n",
-                       iommu->seq_id);
+                pr_err("Cannot get a valid agaw for iommu (seq_id = %d)\n",
+                        iommu->seq_id);
                 goto err_unmap;
         }
         msagaw = iommu_calculate_max_sagaw(iommu);
         if (msagaw < 0) {
-                printk(KERN_ERR
-                        "Cannot get a valid max agaw for iommu (seq_id = %d)\n",
+                pr_err("Cannot get a valid max agaw for iommu (seq_id = %d)\n",
                         iommu->seq_id);
                 goto err_unmap;
         }
@@ -632,19 +685,6 @@ int alloc_iommu(struct dmar_drhd_unit *drhd)
 
         iommu->node = -1;
 
-        /* the registers might be more than one page */
-        map_size = max_t(int, ecap_max_iotlb_offset(iommu->ecap),
-                cap_max_fault_reg_offset(iommu->cap));
-        map_size = VTD_PAGE_ALIGN(map_size);
-        if (map_size > VTD_PAGE_SIZE) {
-                iounmap(iommu->reg);
-                iommu->reg = ioremap(drhd->reg_base_addr, map_size);
-                if (!iommu->reg) {
-                        printk(KERN_ERR "IOMMU: can't map the region\n");
-                        goto error;
-                }
-        }
-
         ver = readl(iommu->reg + DMAR_VER_REG);
         pr_info("IOMMU %d: reg_base_addr %llx ver %d:%d cap %llx ecap %llx\n",
                 iommu->seq_id,
@@ -659,10 +699,10 @@ int alloc_iommu(struct dmar_drhd_unit *drhd)
         return 0;
 
  err_unmap:
-        iounmap(iommu->reg);
+        unmap_iommu(iommu);
  error:
         kfree(iommu);
-        return -1;
+        return err;
 }
 
 void free_iommu(struct intel_iommu *iommu)
@@ -673,7 +713,8 @@ void free_iommu(struct intel_iommu *iommu)
         free_dmar_iommu(iommu);
 
         if (iommu->reg)
-                iounmap(iommu->reg);
+                unmap_iommu(iommu);
+
         kfree(iommu);
 }
 
@@ -710,7 +751,7 @@ static int qi_check_fault(struct intel_iommu *iommu, int index)
         if (fault & DMA_FSTS_IQE) {
                 head = readl(iommu->reg + DMAR_IQH_REG);
                 if ((head >> DMAR_IQ_SHIFT) == index) {
-                        printk(KERN_ERR "VT-d detected invalid descriptor: "
+                        pr_err("VT-d detected invalid descriptor: "
                                 "low=%llx, high=%llx\n",
                                 (unsigned long long)qi->desc[index].low,
                                 (unsigned long long)qi->desc[index].high);
@@ -1129,15 +1170,14 @@ static int dmar_fault_do_one(struct intel_iommu *iommu, int type,
         reason = dmar_get_fault_reason(fault_reason, &fault_type);
 
         if (fault_type == INTR_REMAP)
-                printk(KERN_ERR "INTR-REMAP: Request device [[%02x:%02x.%d] "
+                pr_err("INTR-REMAP: Request device [[%02x:%02x.%d] "
                        "fault index %llx\n"
                         "INTR-REMAP:[fault reason %02d] %s\n",
                         (source_id >> 8), PCI_SLOT(source_id & 0xFF),
                         PCI_FUNC(source_id & 0xFF), addr >> 48,
                         fault_reason, reason);
         else
-                printk(KERN_ERR
-                       "DMAR:[%s] Request device [%02x:%02x.%d] "
+                pr_err("DMAR:[%s] Request device [%02x:%02x.%d] "
                        "fault addr %llx \n"
                        "DMAR:[fault reason %02d] %s\n",
                        (type ? "DMA Read" : "DMA Write"),
@@ -1157,8 +1197,7 @@ irqreturn_t dmar_fault(int irq, void *dev_id)
         raw_spin_lock_irqsave(&iommu->register_lock, flag);
         fault_status = readl(iommu->reg + DMAR_FSTS_REG);
         if (fault_status)
-                printk(KERN_ERR "DRHD: handling fault status reg %x\n",
-                       fault_status);
+                pr_err("DRHD: handling fault status reg %x\n", fault_status);
 
         /* TBD: ignore advanced fault log currently */
         if (!(fault_status & DMA_FSTS_PPF))
@@ -1224,7 +1263,7 @@ int dmar_set_interrupt(struct intel_iommu *iommu)
 
         irq = create_irq();
         if (!irq) {
-                printk(KERN_ERR "IOMMU: no free vectors\n");
+                pr_err("IOMMU: no free vectors\n");
                 return -EINVAL;
         }
 
@@ -1241,7 +1280,7 @@ int dmar_set_interrupt(struct intel_iommu *iommu)
 
         ret = request_irq(irq, dmar_fault, IRQF_NO_THREAD, iommu->name, iommu);
         if (ret)
-                printk(KERN_ERR "IOMMU: can't request irq\n");
+                pr_err("IOMMU: can't request irq\n");
         return ret;
 }
 
@@ -1258,8 +1297,7 @@ int __init enable_drhd_fault_handling(void)
                 ret = dmar_set_interrupt(iommu);
 
                 if (ret) {
-                        printk(KERN_ERR "DRHD %Lx: failed to enable fault, "
-                               " interrupt, ret %d\n",
+                        pr_err("DRHD %Lx: failed to enable fault, interrupt, ret %d\n",
                                (unsigned long long)drhd->reg_base_addr, ret);
                         return -1;
                 }
diff --git a/drivers/iommu/intel_irq_remapping.c b/drivers/iommu/intel_irq_remapping.c
index 6d347064b8b0..e0b18f3ae9a8 100644
--- a/drivers/iommu/intel_irq_remapping.c
+++ b/drivers/iommu/intel_irq_remapping.c
@@ -902,7 +902,6 @@ static int intel_setup_ioapic_entry(int irq,
         return 0;
 }
 
-#ifdef CONFIG_SMP
 /*
  * Migrate the IO-APIC irq in the presence of intr-remapping.
  *
@@ -924,6 +923,10 @@ intel_ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
         struct irq_cfg *cfg = data->chip_data;
         unsigned int dest, irq = data->irq;
         struct irte irte;
+        int err;
+
+        if (!config_enabled(CONFIG_SMP))
+                return -EINVAL;
 
         if (!cpumask_intersects(mask, cpu_online_mask))
                 return -EINVAL;
@@ -931,10 +934,16 @@ intel_ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
         if (get_irte(irq, &irte))
                 return -EBUSY;
 
-        if (assign_irq_vector(irq, cfg, mask))
-                return -EBUSY;
+        err = assign_irq_vector(irq, cfg, mask);
+        if (err)
+                return err;
 
-        dest = apic->cpu_mask_to_apicid_and(cfg->domain, mask);
+        err = apic->cpu_mask_to_apicid_and(cfg->domain, mask, &dest);
+        if (err) {
+                if (assign_irq_vector(irq, cfg, data->affinity))
+                        pr_err("Failed to recover vector for irq %d\n", irq);
+                return err;
+        }
 
         irte.vector = cfg->vector;
         irte.dest_id = IRTE_DEST(dest);
@@ -956,7 +965,6 @@ intel_ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
         cpumask_copy(data->affinity, mask);
         return 0;
 }
-#endif
 
 static void intel_compose_msi_msg(struct pci_dev *pdev,
                                   unsigned int irq, unsigned int dest,
@@ -1058,9 +1066,7 @@ struct irq_remap_ops intel_irq_remap_ops = {
         .reenable               = reenable_irq_remapping,
         .enable_faulting        = enable_drhd_fault_handling,
         .setup_ioapic_entry     = intel_setup_ioapic_entry,
-#ifdef CONFIG_SMP
         .set_affinity           = intel_ioapic_set_affinity,
-#endif
         .free_irq               = free_irte,
         .compose_msi_msg        = intel_compose_msi_msg,
         .msi_alloc_irq          = intel_msi_alloc_irq,
diff --git a/drivers/iommu/irq_remapping.c b/drivers/iommu/irq_remapping.c
index 40cda8e98d87..1d29b1c66e72 100644
--- a/drivers/iommu/irq_remapping.c
+++ b/drivers/iommu/irq_remapping.c
@@ -111,16 +111,15 @@ int setup_ioapic_remapped_entry(int irq,
                                              vector, attr);
 }
 
-#ifdef CONFIG_SMP
 int set_remapped_irq_affinity(struct irq_data *data, const struct cpumask *mask,
                               bool force)
 {
-        if (!remap_ops || !remap_ops->set_affinity)
+        if (!config_enabled(CONFIG_SMP) || !remap_ops ||
+            !remap_ops->set_affinity)
                 return 0;
 
         return remap_ops->set_affinity(data, mask, force);
 }
-#endif
 
 void free_remapped_irq(int irq)
 {
diff --git a/drivers/iommu/irq_remapping.h b/drivers/iommu/irq_remapping.h
index be9d72950c51..b12974cc1dfe 100644
--- a/drivers/iommu/irq_remapping.h
+++ b/drivers/iommu/irq_remapping.h
@@ -59,11 +59,9 @@ struct irq_remap_ops {
                                   unsigned int, int,
                                   struct io_apic_irq_attr *);
 
-#ifdef CONFIG_SMP
         /* Set the CPU affinity of a remapped interrupt */
         int (*set_affinity)(struct irq_data *data, const struct cpumask *mask,
                             bool force);
-#endif
 
         /* Free an IRQ */
         int (*free_irq)(int);
diff --git a/drivers/iommu/tegra-smmu.c b/drivers/iommu/tegra-smmu.c
index ecd679043d77..3f3d09d560ea 100644
--- a/drivers/iommu/tegra-smmu.c
+++ b/drivers/iommu/tegra-smmu.c
@@ -550,13 +550,13 @@ static int alloc_pdir(struct smmu_as *as)
                 return 0;
 
         as->pte_count = devm_kzalloc(smmu->dev,
-                     sizeof(as->pte_count[0]) * SMMU_PDIR_COUNT, GFP_KERNEL);
+                     sizeof(as->pte_count[0]) * SMMU_PDIR_COUNT, GFP_ATOMIC);
         if (!as->pte_count) {
                 dev_err(smmu->dev,
                         "failed to allocate smmu_device PTE cunters\n");
                 return -ENOMEM;
         }
-        as->pdir_page = alloc_page(GFP_KERNEL | __GFP_DMA);
+        as->pdir_page = alloc_page(GFP_ATOMIC | __GFP_DMA);
         if (!as->pdir_page) {
                 dev_err(smmu->dev,
                         "failed to allocate smmu_device page directory\n");
diff --git a/drivers/isdn/mISDN/stack.c b/drivers/isdn/mISDN/stack.c
index 1a0ae4445ff2..5f21f629b7ae 100644
--- a/drivers/isdn/mISDN/stack.c
+++ b/drivers/isdn/mISDN/stack.c
@@ -135,8 +135,8 @@ send_layer2(struct mISDNstack *st, struct sk_buff *skb)
                         skb = NULL;
                 else if (*debug & DEBUG_SEND_ERR)
                         printk(KERN_DEBUG
-                               "%s ch%d mgr prim(%x) addr(%x) err %d\n",
-                               __func__, ch->nr, hh->prim, ch->addr, ret);
+                               "%s mgr prim(%x) err %d\n",
+                               __func__, hh->prim, ret);
         }
 out:
         mutex_unlock(&st->lmutex);
diff --git a/drivers/leds/ledtrig-heartbeat.c b/drivers/leds/ledtrig-heartbeat.c
index 41dc76db4311..a019fbb70880 100644
--- a/drivers/leds/ledtrig-heartbeat.c
+++ b/drivers/leds/ledtrig-heartbeat.c
@@ -21,6 +21,8 @@
 #include <linux/reboot.h>
 #include "leds.h"
 
+static int panic_heartbeats;
+
 struct heartbeat_trig_data {
         unsigned int phase;
         unsigned int period;
@@ -34,6 +36,11 @@ static void led_heartbeat_function(unsigned long data)
         unsigned long brightness = LED_OFF;
         unsigned long delay = 0;
 
+        if (unlikely(panic_heartbeats)) {
+                led_set_brightness(led_cdev, LED_OFF);
+                return;
+        }
+
         /* acts like an actual heart beat -- ie thump-thump-pause... */
         switch (heartbeat_data->phase) {
         case 0:
@@ -111,12 +118,19 @@ static int heartbeat_reboot_notifier(struct notifier_block *nb,
         return NOTIFY_DONE;
 }
 
+static int heartbeat_panic_notifier(struct notifier_block *nb,
+                                     unsigned long code, void *unused)
+{
+        panic_heartbeats = 1;
+        return NOTIFY_DONE;
+}
+
 static struct notifier_block heartbeat_reboot_nb = {
         .notifier_call = heartbeat_reboot_notifier,
 };
 
 static struct notifier_block heartbeat_panic_nb = {
-        .notifier_call = heartbeat_reboot_notifier,
+        .notifier_call = heartbeat_panic_notifier,
 };
 
 static int __init heartbeat_trig_init(void)
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index d039de8322f0..b58b7a33914a 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -1084,6 +1084,7 @@ static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         ti->split_io = dm_rh_get_region_size(ms->rh);
         ti->num_flush_requests = 1;
         ti->num_discard_requests = 1;
+        ti->discard_zeroes_data_unsupported = 1;
 
         ms->kmirrord_wq = alloc_workqueue("kmirrord",
                                           WQ_NON_REENTRANT | WQ_MEM_RECLAIM, 0);
@@ -1214,7 +1215,7 @@ static int mirror_end_io(struct dm_target *ti, struct bio *bio,
          * We need to dec pending if this was a write.
          */
         if (rw == WRITE) {
-                if (!(bio->bi_rw & REQ_FLUSH))
+                if (!(bio->bi_rw & (REQ_FLUSH | REQ_DISCARD)))
                         dm_rh_dec(ms->rh, map_context->ll);
                 return error;
         }
diff --git a/drivers/md/dm-region-hash.c b/drivers/md/dm-region-hash.c
index 7771ed212182..69732e03eb34 100644
--- a/drivers/md/dm-region-hash.c
+++ b/drivers/md/dm-region-hash.c
@@ -404,6 +404,9 @@ void dm_rh_mark_nosync(struct dm_region_hash *rh, struct bio *bio)
                 return;
         }
 
+        if (bio->bi_rw & REQ_DISCARD)
+                return;
+
         /* We must inform the log that the sync count has changed. */
         log->type->set_region_sync(log, region, 0);
 
@@ -524,7 +527,7 @@ void dm_rh_inc_pending(struct dm_region_hash *rh, struct bio_list *bios)
         struct bio *bio;
 
         for (bio = bios->head; bio; bio = bio->bi_next) {
-                if (bio->bi_rw & REQ_FLUSH)
+                if (bio->bi_rw & (REQ_FLUSH | REQ_DISCARD))
                         continue;
                 rh_inc(rh, dm_rh_bio_to_region(rh, bio));
         }
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index 37fdaf81bd1f..68694da0d21d 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -1245,7 +1245,10 @@ static void process_discard(struct thin_c *tc, struct bio *bio)
 
                         cell_release_singleton(cell, bio);
                         cell_release_singleton(cell2, bio);
-                        remap_and_issue(tc, bio, lookup_result.block);
+                        if ((!lookup_result.shared) && pool->pf.discard_passdown)
+                                remap_and_issue(tc, bio, lookup_result.block);
+                        else
+                                bio_endio(bio, 0);
                 }
                 break;
 
@@ -2292,6 +2295,13 @@ static int process_reserve_metadata_snap_mesg(unsigned argc, char **argv, struct
         if (r)
                 return r;
 
+        r = dm_pool_commit_metadata(pool->pmd);
+        if (r) {
+                DMERR("%s: dm_pool_commit_metadata() failed, error = %d",
+                      __func__, r);
+                return r;
+        }
+
         r = dm_pool_reserve_metadata_snap(pool->pmd);
         if (r)
                 DMWARN("reserve_metadata_snap message failed.");
@@ -2621,6 +2631,7 @@ static int thin_ctr(struct dm_target *ti, unsigned argc, char **argv)
         if (tc->pool->pf.discard_enabled) {
                 ti->discards_supported = 1;
                 ti->num_discard_requests = 1;
+                ti->discard_zeroes_data_unsupported = 1;
         }
 
         dm_put(pool_md);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 1c2f9048e1ae..d5ab4493c8be 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2931,6 +2931,7 @@ offset_store(struct md_rdev *rdev, const char *buf, size_t len)
                  * can be sane */
                 return -EBUSY;
         rdev->data_offset = offset;
+        rdev->new_data_offset = offset;
         return len;
 }
 
@@ -3926,8 +3927,8 @@ array_state_show(struct mddev *mddev, char *page)
         return sprintf(page, "%s\n", array_states[st]);
 }
 
-static int do_md_stop(struct mddev * mddev, int ro, int is_open);
-static int md_set_readonly(struct mddev * mddev, int is_open);
+static int do_md_stop(struct mddev * mddev, int ro, struct block_device *bdev);
+static int md_set_readonly(struct mddev * mddev, struct block_device *bdev);
 static int do_md_run(struct mddev * mddev);
 static int restart_array(struct mddev *mddev);
 
@@ -3943,14 +3944,14 @@ array_state_store(struct mddev *mddev, const char *buf, size_t len)
                 /* stopping an active array */
                 if (atomic_read(&mddev->openers) > 0)
                         return -EBUSY;
-                err = do_md_stop(mddev, 0, 0);
+                err = do_md_stop(mddev, 0, NULL);
                 break;
         case inactive:
                 /* stopping an active array */
                 if (mddev->pers) {
                         if (atomic_read(&mddev->openers) > 0)
                                 return -EBUSY;
-                        err = do_md_stop(mddev, 2, 0);
+                        err = do_md_stop(mddev, 2, NULL);
                 } else
                         err = 0; /* already inactive */
                 break;
@@ -3958,7 +3959,7 @@ array_state_store(struct mddev *mddev, const char *buf, size_t len)
                 break; /* not supported yet */
         case readonly:
                 if (mddev->pers)
-                        err = md_set_readonly(mddev, 0);
+                        err = md_set_readonly(mddev, NULL);
                 else {
                         mddev->ro = 1;
                         set_disk_ro(mddev->gendisk, 1);
@@ -3968,7 +3969,7 @@ array_state_store(struct mddev *mddev, const char *buf, size_t len)
         case read_auto:
                 if (mddev->pers) {
                         if (mddev->ro == 0)
-                                err = md_set_readonly(mddev, 0);
+                                err = md_set_readonly(mddev, NULL);
                         else if (mddev->ro == 1)
                                 err = restart_array(mddev);
                         if (err == 0) {
@@ -5351,15 +5352,17 @@ void md_stop(struct mddev *mddev)
 }
 EXPORT_SYMBOL_GPL(md_stop);
 
-static int md_set_readonly(struct mddev *mddev, int is_open)
+static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
 {
         int err = 0;
         mutex_lock(&mddev->open_mutex);
-        if (atomic_read(&mddev->openers) > is_open) {
+        if (atomic_read(&mddev->openers) > !!bdev) {
                 printk("md: %s still in use.\n",mdname(mddev));
                 err = -EBUSY;
                 goto out;
         }
+        if (bdev)
+                sync_blockdev(bdev);
         if (mddev->pers) {
                 __md_stop_writes(mddev);
 
@@ -5381,18 +5384,26 @@ out:
  *   0 - completely stop and dis-assemble array
  *   2 - stop but do not disassemble array
  */
-static int do_md_stop(struct mddev * mddev, int mode, int is_open)
+static int do_md_stop(struct mddev * mddev, int mode,
+                      struct block_device *bdev)
 {
         struct gendisk *disk = mddev->gendisk;
         struct md_rdev *rdev;
 
         mutex_lock(&mddev->open_mutex);
-        if (atomic_read(&mddev->openers) > is_open ||
+        if (atomic_read(&mddev->openers) > !!bdev ||
             mddev->sysfs_active) {
                 printk("md: %s still in use.\n",mdname(mddev));
                 mutex_unlock(&mddev->open_mutex);
                 return -EBUSY;
         }
+        if (bdev)
+                /* It is possible IO was issued on some other
+                 * open file which was closed before we took ->open_mutex.
+                 * As that was not the last close __blkdev_put will not
+                 * have called sync_blockdev, so we must.
+                 */
+                sync_blockdev(bdev);
 
         if (mddev->pers) {
                 if (mddev->ro)
@@ -5466,7 +5477,7 @@ static void autorun_array(struct mddev *mddev)
         err = do_md_run(mddev);
         if (err) {
                 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
-                do_md_stop(mddev, 0, 0);
+                do_md_stop(mddev, 0, NULL);
         }
 }
 
@@ -5784,8 +5795,7 @@ static int add_new_disk(struct mddev * mddev, mdu_disk_info_t *info)
                         super_types[mddev->major_version].
                                 validate_super(mddev, rdev);
                 if ((info->state & (1<<MD_DISK_SYNC)) &&
-                    (!test_bit(In_sync, &rdev->flags) ||
-                     rdev->raid_disk != info->raid_disk)) {
+                     rdev->raid_disk != info->raid_disk) {
                         /* This was a hot-add request, but events doesn't
                          * match, so reject it.
                          */
@@ -6482,11 +6492,11 @@ static int md_ioctl(struct block_device *bdev, fmode_t mode,
                         goto done_unlock;
 
                 case STOP_ARRAY:
-                        err = do_md_stop(mddev, 0, 1);
+                        err = do_md_stop(mddev, 0, bdev);
                         goto done_unlock;
 
                 case STOP_ARRAY_RO:
-                        err = md_set_readonly(mddev, 1);
+                        err = md_set_readonly(mddev, bdev);
                         goto done_unlock;
 
                 case BLKROSET:
@@ -6751,7 +6761,7 @@ struct md_thread *md_register_thread(void (*run) (struct mddev *), struct mddev
         thread->tsk = kthread_run(md_thread, thread,
                                   "%s_%s",
                                   mdname(thread->mddev),
-                                  name ?: mddev->pers->name);
+                                  name);
         if (IS_ERR(thread->tsk)) {
                 kfree(thread);
                 return NULL;
@@ -7298,6 +7308,7 @@ void md_do_sync(struct mddev *mddev)
         int skipped = 0;
         struct md_rdev *rdev;
         char *desc;
+        struct blk_plug plug;
 
         /* just incase thread restarts... */
         if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
@@ -7447,6 +7458,7 @@ void md_do_sync(struct mddev *mddev)
         }
         mddev->curr_resync_completed = j;
 
+        blk_start_plug(&plug);
         while (j < max_sectors) {
                 sector_t sectors;
 
@@ -7552,6 +7564,7 @@ void md_do_sync(struct mddev *mddev)
          * this also signals 'finished resyncing' to md_stop
          */
  out:
+        blk_finish_plug(&plug);
         wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
 
         /* tell personality that we are finished */
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 9339e67fcc79..61a1833ebaf3 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -474,7 +474,8 @@ static int multipath_run (struct mddev *mddev)
         }
 
         {
-                mddev->thread = md_register_thread(multipathd, mddev, NULL);
+                mddev->thread = md_register_thread(multipathd, mddev,
+                                                   "multipath");
                 if (!mddev->thread) {
                         printk(KERN_ERR "multipath: couldn't allocate thread"
                                 " for %s\n", mdname(mddev));
diff --git a/drivers/md/persistent-data/dm-space-map-checker.c b/drivers/md/persistent-data/dm-space-map-checker.c
index 50ed53bf4aa2..fc90c11620ad 100644
--- a/drivers/md/persistent-data/dm-space-map-checker.c
+++ b/drivers/md/persistent-data/dm-space-map-checker.c
@@ -8,6 +8,7 @@
 
 #include <linux/device-mapper.h>
 #include <linux/export.h>
+#include <linux/vmalloc.h>
 
 #ifdef CONFIG_DM_DEBUG_SPACE_MAPS
 
@@ -89,13 +90,23 @@ static int ca_create(struct count_array *ca, struct dm_space_map *sm)
 
         ca->nr = nr_blocks;
         ca->nr_free = nr_blocks;
-        ca->counts = kzalloc(sizeof(*ca->counts) * nr_blocks, GFP_KERNEL);
-        if (!ca->counts)
-                return -ENOMEM;
+
+        if (!nr_blocks)
+                ca->counts = NULL;
+        else {
+                ca->counts = vzalloc(sizeof(*ca->counts) * nr_blocks);
+                if (!ca->counts)
+                        return -ENOMEM;
+        }
 
         return 0;
 }
 
+static void ca_destroy(struct count_array *ca)
+{
+        vfree(ca->counts);
+}
+
 static int ca_load(struct count_array *ca, struct dm_space_map *sm)
 {
         int r;
@@ -126,12 +137,14 @@ static int ca_load(struct count_array *ca, struct dm_space_map *sm)
 static int ca_extend(struct count_array *ca, dm_block_t extra_blocks)
 {
         dm_block_t nr_blocks = ca->nr + extra_blocks;
-        uint32_t *counts = kzalloc(sizeof(*counts) * nr_blocks, GFP_KERNEL);
+        uint32_t *counts = vzalloc(sizeof(*counts) * nr_blocks);
         if (!counts)
                 return -ENOMEM;
 
-        memcpy(counts, ca->counts, sizeof(*counts) * ca->nr);
-        kfree(ca->counts);
+        if (ca->counts) {
+                memcpy(counts, ca->counts, sizeof(*counts) * ca->nr);
+                ca_destroy(ca);
+        }
         ca->nr = nr_blocks;
         ca->nr_free += extra_blocks;
         ca->counts = counts;
@@ -151,11 +164,6 @@ static int ca_commit(struct count_array *old, struct count_array *new)
         return 0;
 }
 
-static void ca_destroy(struct count_array *ca)
-{
-        kfree(ca->counts);
-}
-
 /*----------------------------------------------------------------*/
 
 struct sm_checker {
@@ -343,25 +351,25 @@ struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
         int r;
         struct sm_checker *smc;
 
-        if (!sm)
-                return NULL;
+        if (IS_ERR_OR_NULL(sm))
+                return ERR_PTR(-EINVAL);
 
         smc = kmalloc(sizeof(*smc), GFP_KERNEL);
         if (!smc)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         memcpy(&smc->sm, &ops_, sizeof(smc->sm));
         r = ca_create(&smc->old_counts, sm);
         if (r) {
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         r = ca_create(&smc->counts, sm);
         if (r) {
                 ca_destroy(&smc->old_counts);
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         smc->real_sm = sm;
@@ -371,7 +379,7 @@ struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
                 ca_destroy(&smc->counts);
                 ca_destroy(&smc->old_counts);
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         r = ca_commit(&smc->old_counts, &smc->counts);
@@ -379,7 +387,7 @@ struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
                 ca_destroy(&smc->counts);
                 ca_destroy(&smc->old_counts);
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         return &smc->sm;
@@ -391,25 +399,25 @@ struct dm_space_map *dm_sm_checker_create_fresh(struct dm_space_map *sm)
         int r;
         struct sm_checker *smc;
 
-        if (!sm)
-                return NULL;
+        if (IS_ERR_OR_NULL(sm))
+                return ERR_PTR(-EINVAL);
 
         smc = kmalloc(sizeof(*smc), GFP_KERNEL);
         if (!smc)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         memcpy(&smc->sm, &ops_, sizeof(smc->sm));
         r = ca_create(&smc->old_counts, sm);
         if (r) {
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         r = ca_create(&smc->counts, sm);
         if (r) {
                 ca_destroy(&smc->old_counts);
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         smc->real_sm = sm;
diff --git a/drivers/md/persistent-data/dm-space-map-disk.c b/drivers/md/persistent-data/dm-space-map-disk.c
index fc469ba9f627..3d0ed5332883 100644
--- a/drivers/md/persistent-data/dm-space-map-disk.c
+++ b/drivers/md/persistent-data/dm-space-map-disk.c
@@ -290,7 +290,16 @@ struct dm_space_map *dm_sm_disk_create(struct dm_transaction_manager *tm,
                                        dm_block_t nr_blocks)
 {
         struct dm_space_map *sm = dm_sm_disk_create_real(tm, nr_blocks);
-        return dm_sm_checker_create_fresh(sm);
+        struct dm_space_map *smc;
+
+        if (IS_ERR_OR_NULL(sm))
+                return sm;
+
+        smc = dm_sm_checker_create_fresh(sm);
+        if (IS_ERR(smc))
+                dm_sm_destroy(sm);
+
+        return smc;
 }
 EXPORT_SYMBOL_GPL(dm_sm_disk_create);
 
diff --git a/drivers/md/persistent-data/dm-transaction-manager.c b/drivers/md/persistent-data/dm-transaction-manager.c
index 400fe144c0cd..e5604b32d91f 100644
--- a/drivers/md/persistent-data/dm-transaction-manager.c
+++ b/drivers/md/persistent-data/dm-transaction-manager.c
@@ -138,6 +138,9 @@ EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);
 
 void dm_tm_destroy(struct dm_transaction_manager *tm)
 {
+        if (!tm->is_clone)
+                wipe_shadow_table(tm);
+
         kfree(tm);
 }
 EXPORT_SYMBOL_GPL(dm_tm_destroy);
@@ -344,8 +347,10 @@ static int dm_tm_create_internal(struct dm_block_manager *bm,
                 }
 
                 *sm = dm_sm_checker_create(inner);
-                if (!*sm)
+                if (IS_ERR(*sm)) {
+                        r = PTR_ERR(*sm);
                         goto bad2;
+                }
 
         } else {
                 r = dm_bm_write_lock(dm_tm_get_bm(*tm), sb_location,
@@ -364,8 +369,10 @@ static int dm_tm_create_internal(struct dm_block_manager *bm,
                 }
 
                 *sm = dm_sm_checker_create(inner);
-                if (!*sm)
+                if (IS_ERR(*sm)) {
+                        r = PTR_ERR(*sm);
                         goto bad2;
+                }
         }
 
         return 0;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index a9c7981ddd24..cacd008d6864 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -517,8 +517,8 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect
                 int bad_sectors;
 
                 int disk = start_disk + i;
-                if (disk >= conf->raid_disks)
-                        disk -= conf->raid_disks;
+                if (disk >= conf->raid_disks * 2)
+                        disk -= conf->raid_disks * 2;
 
                 rdev = rcu_dereference(conf->mirrors[disk].rdev);
                 if (r1_bio->bios[disk] == IO_BLOCKED
@@ -883,7 +883,6 @@ static void make_request(struct mddev *mddev, struct bio * bio)
         const unsigned long do_sync = (bio->bi_rw & REQ_SYNC);
         const unsigned long do_flush_fua = (bio->bi_rw & (REQ_FLUSH | REQ_FUA));
         struct md_rdev *blocked_rdev;
-        int plugged;
         int first_clone;
         int sectors_handled;
         int max_sectors;
@@ -1034,7 +1033,6 @@ read_again:
          * the bad blocks.  Each set of writes gets it's own r1bio
          * with a set of bios attached.
          */
-        plugged = mddev_check_plugged(mddev);
 
         disks = conf->raid_disks * 2;
  retry_write:
@@ -1191,6 +1189,8 @@ read_again:
                 bio_list_add(&conf->pending_bio_list, mbio);
                 conf->pending_count++;
                 spin_unlock_irqrestore(&conf->device_lock, flags);
+                if (!mddev_check_plugged(mddev))
+                        md_wakeup_thread(mddev->thread);
         }
         /* Mustn't call r1_bio_write_done before this next test,
          * as it could result in the bio being freed.
@@ -1213,9 +1213,6 @@ read_again:
 
         /* In case raid1d snuck in to freeze_array */
         wake_up(&conf->wait_barrier);
-
-        if (do_sync || !bitmap || !plugged)
-                md_wakeup_thread(mddev->thread);
 }
 
 static void status(struct seq_file *seq, struct mddev *mddev)
@@ -1821,8 +1818,14 @@ static void sync_request_write(struct mddev *mddev, struct r1bio *r1_bio)
 
         if (atomic_dec_and_test(&r1_bio->remaining)) {
                 /* if we're here, all write(s) have completed, so clean up */
-                md_done_sync(mddev, r1_bio->sectors, 1);
-                put_buf(r1_bio);
+                int s = r1_bio->sectors;
+                if (test_bit(R1BIO_MadeGood, &r1_bio->state) ||
+                    test_bit(R1BIO_WriteError, &r1_bio->state))
+                        reschedule_retry(r1_bio);
+                else {
+                        put_buf(r1_bio);
+                        md_done_sync(mddev, s, 1);
+                }
         }
 }
 
@@ -2488,9 +2491,10 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
          */
         if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
                 atomic_set(&r1_bio->remaining, read_targets);
-                for (i = 0; i < conf->raid_disks * 2; i++) {
+                for (i = 0; i < conf->raid_disks * 2 && read_targets; i++) {
                         bio = r1_bio->bios[i];
                         if (bio->bi_end_io == end_sync_read) {
+                                read_targets--;
                                 md_sync_acct(bio->bi_bdev, nr_sectors);
                                 generic_make_request(bio);
                         }
@@ -2621,7 +2625,7 @@ static struct r1conf *setup_conf(struct mddev *mddev)
                 goto abort;
         }
         err = -ENOMEM;
-        conf->thread = md_register_thread(raid1d, mddev, NULL);
+        conf->thread = md_register_thread(raid1d, mddev, "raid1");
         if (!conf->thread) {
                 printk(KERN_ERR
                        "md/raid1:%s: couldn't allocate thread\n",
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 99ae6068e456..8da6282254c3 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1039,7 +1039,6 @@ static void make_request(struct mddev *mddev, struct bio * bio)
         const unsigned long do_fua = (bio->bi_rw & REQ_FUA);
         unsigned long flags;
         struct md_rdev *blocked_rdev;
-        int plugged;
         int sectors_handled;
         int max_sectors;
         int sectors;
@@ -1239,7 +1238,6 @@ read_again:
          * of r10_bios is recored in bio->bi_phys_segments just as with
          * the read case.
          */
-        plugged = mddev_check_plugged(mddev);
 
         r10_bio->read_slot = -1; /* make sure repl_bio gets freed */
         raid10_find_phys(conf, r10_bio);
@@ -1396,6 +1394,8 @@ retry_write:
                 bio_list_add(&conf->pending_bio_list, mbio);
                 conf->pending_count++;
                 spin_unlock_irqrestore(&conf->device_lock, flags);
+                if (!mddev_check_plugged(mddev))
+                        md_wakeup_thread(mddev->thread);
 
                 if (!r10_bio->devs[i].repl_bio)
                         continue;
@@ -1423,6 +1423,8 @@ retry_write:
                 bio_list_add(&conf->pending_bio_list, mbio);
                 conf->pending_count++;
                 spin_unlock_irqrestore(&conf->device_lock, flags);
+                if (!mddev_check_plugged(mddev))
+                        md_wakeup_thread(mddev->thread);
         }
 
         /* Don't remove the bias on 'remaining' (one_write_done) until
@@ -1448,9 +1450,6 @@ retry_write:
 
         /* In case raid10d snuck in to freeze_array */
         wake_up(&conf->wait_barrier);
-
-        if (do_sync || !mddev->bitmap || !plugged)
-                md_wakeup_thread(mddev->thread);
 }
 
 static void status(struct seq_file *seq, struct mddev *mddev)
@@ -2310,7 +2309,7 @@ static void fix_read_error(struct r10conf *conf, struct mddev *mddev, struct r10
                         if (r10_sync_page_io(rdev,
                                              r10_bio->devs[sl].addr +
                                              sect,
-                                             s<<9, conf->tmppage, WRITE)
+                                             s, conf->tmppage, WRITE)
                             == 0) {
                                 /* Well, this device is dead */
                                 printk(KERN_NOTICE
@@ -2349,7 +2348,7 @@ static void fix_read_error(struct r10conf *conf, struct mddev *mddev, struct r10
                         switch (r10_sync_page_io(rdev,
                                              r10_bio->devs[sl].addr +
                                              sect,
-                                             s<<9, conf->tmppage,
+                                             s, conf->tmppage,
                                                  READ)) {
                         case 0:
                                 /* Well, this device is dead */
@@ -2512,7 +2511,7 @@ read_more:
         slot = r10_bio->read_slot;
         printk_ratelimited(
                 KERN_ERR
-                "md/raid10:%s: %s: redirecting"
+                "md/raid10:%s: %s: redirecting "
                 "sector %llu to another mirror\n",
                 mdname(mddev),
                 bdevname(rdev->bdev, b),
@@ -2661,7 +2660,8 @@ static void raid10d(struct mddev *mddev)
         blk_start_plug(&plug);
         for (;;) {
 
-                flush_pending_writes(conf);
+                if (atomic_read(&mddev->plug_cnt) == 0)
+                        flush_pending_writes(conf);
 
                 spin_lock_irqsave(&conf->device_lock, flags);
                 if (list_empty(head)) {
@@ -2890,6 +2890,12 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                         /* want to reconstruct this device */
                         rb2 = r10_bio;
                         sect = raid10_find_virt(conf, sector_nr, i);
+                        if (sect >= mddev->resync_max_sectors) {
+                                /* last stripe is not complete - don't
+                                 * try to recover this sector.
+                                 */
+                                continue;
+                        }
                         /* Unless we are doing a full sync, or a replacement
                          * we only need to recover the block if it is set in
                          * the bitmap
@@ -3421,7 +3427,7 @@ static struct r10conf *setup_conf(struct mddev *mddev)
         spin_lock_init(&conf->resync_lock);
         init_waitqueue_head(&conf->wait_barrier);
 
-        conf->thread = md_register_thread(raid10d, mddev, NULL);
+        conf->thread = md_register_thread(raid10d, mddev, "raid10");
         if (!conf->thread)
                 goto out;
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index d26767246d26..04348d76bb30 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -196,12 +196,14 @@ static void __release_stripe(struct r5conf *conf, struct stripe_head *sh)
                 BUG_ON(!list_empty(&sh->lru));
                 BUG_ON(atomic_read(&conf->active_stripes)==0);
                 if (test_bit(STRIPE_HANDLE, &sh->state)) {
-                        if (test_bit(STRIPE_DELAYED, &sh->state))
+                        if (test_bit(STRIPE_DELAYED, &sh->state) &&
+                            !test_bit(STRIPE_PREREAD_ACTIVE, &sh->state))
                                 list_add_tail(&sh->lru, &conf->delayed_list);
                         else if (test_bit(STRIPE_BIT_DELAY, &sh->state) &&
                                    sh->bm_seq - conf->seq_write > 0)
                                 list_add_tail(&sh->lru, &conf->bitmap_list);
                         else {
+                                clear_bit(STRIPE_DELAYED, &sh->state);
                                 clear_bit(STRIPE_BIT_DELAY, &sh->state);
                                 list_add_tail(&sh->lru, &conf->handle_list);
                         }
@@ -606,6 +608,12 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
                                          * a chance*/
                                         md_check_recovery(conf->mddev);
                                 }
+                                /*
+                                 * Because md_wait_for_blocked_rdev
+                                 * will dec nr_pending, we must
+                                 * increment it first.
+                                 */
+                                atomic_inc(&rdev->nr_pending);
                                 md_wait_for_blocked_rdev(rdev, conf->mddev);
                         } else {
                                 /* Acknowledged bad block - skip the write */
@@ -1737,6 +1745,7 @@ static void raid5_end_read_request(struct bio * bi, int error)
         } else {
                 const char *bdn = bdevname(rdev->bdev, b);
                 int retry = 0;
+                int set_bad = 0;
 
                 clear_bit(R5_UPTODATE, &sh->dev[i].flags);
                 atomic_inc(&rdev->read_errors);
@@ -1748,7 +1757,8 @@ static void raid5_end_read_request(struct bio * bi, int error)
                                 mdname(conf->mddev),
                                 (unsigned long long)s,
                                 bdn);
-                else if (conf->mddev->degraded >= conf->max_degraded)
+                else if (conf->mddev->degraded >= conf->max_degraded) {
+                        set_bad = 1;
                         printk_ratelimited(
                                 KERN_WARNING
                                 "md/raid:%s: read error not correctable "
@@ -1756,8 +1766,9 @@ static void raid5_end_read_request(struct bio * bi, int error)
                                 mdname(conf->mddev),
                                 (unsigned long long)s,
                                 bdn);
-                else if (test_bit(R5_ReWrite, &sh->dev[i].flags))
+                } else if (test_bit(R5_ReWrite, &sh->dev[i].flags)) {
                         /* Oh, no!!! */
+                        set_bad = 1;
                         printk_ratelimited(
                                 KERN_WARNING
                                 "md/raid:%s: read error NOT corrected!! "
@@ -1765,7 +1776,7 @@ static void raid5_end_read_request(struct bio * bi, int error)
                                 mdname(conf->mddev),
                                 (unsigned long long)s,
                                 bdn);
-                else if (atomic_read(&rdev->read_errors)
+                } else if (atomic_read(&rdev->read_errors)
                          > conf->max_nr_stripes)
                         printk(KERN_WARNING
                                "md/raid:%s: Too many read errors, failing device %s.\n",
@@ -1777,7 +1788,11 @@ static void raid5_end_read_request(struct bio * bi, int error)
                 else {
                         clear_bit(R5_ReadError, &sh->dev[i].flags);
                         clear_bit(R5_ReWrite, &sh->dev[i].flags);
-                        md_error(conf->mddev, rdev);
+                        if (!(set_bad
+                              && test_bit(In_sync, &rdev->flags)
+                              && rdev_set_badblocks(
+                                      rdev, sh->sector, STRIPE_SECTORS, 0)))
+                                md_error(conf->mddev, rdev);
                 }
         }
         rdev_dec_pending(rdev, conf->mddev);
@@ -3582,8 +3597,18 @@ static void handle_stripe(struct stripe_head *sh)
 
 finish:
         /* wait for this device to become unblocked */
-        if (conf->mddev->external && unlikely(s.blocked_rdev))
-                md_wait_for_blocked_rdev(s.blocked_rdev, conf->mddev);
+        if (unlikely(s.blocked_rdev)) {
+                if (conf->mddev->external)
+                        md_wait_for_blocked_rdev(s.blocked_rdev,
+                                                 conf->mddev);
+                else
+                        /* Internal metadata will immediately
+                         * be written by raid5d, so we don't
+                         * need to wait here.
+                         */
+                        rdev_dec_pending(s.blocked_rdev,
+                                         conf->mddev);
+        }
 
         if (s.handle_bad_blocks)
                 for (i = disks; i--; ) {
@@ -3881,8 +3906,6 @@ static int chunk_aligned_read(struct mddev *mddev, struct bio * raid_bio)
                 raid_bio->bi_next = (void*)rdev;
                 align_bi->bi_bdev =  rdev->bdev;
                 align_bi->bi_flags &= ~(1 << BIO_SEG_VALID);
-                /* No reshape active, so we can trust rdev->data_offset */
-                align_bi->bi_sector += rdev->data_offset;
 
                 if (!bio_fits_rdev(align_bi) ||
                     is_badblock(rdev, align_bi->bi_sector, align_bi->bi_size>>9,
@@ -3893,6 +3916,9 @@ static int chunk_aligned_read(struct mddev *mddev, struct bio * raid_bio)
                         return 0;
                 }
 
+                /* No reshape active, so we can trust rdev->data_offset */
+                align_bi->bi_sector += rdev->data_offset;
+
                 spin_lock_irq(&conf->device_lock);
                 wait_event_lock_irq(conf->wait_for_stripe,
                                     conf->quiesce == 0,
@@ -3971,7 +3997,6 @@ static void make_request(struct mddev *mddev, struct bio * bi)
         struct stripe_head *sh;
         const int rw = bio_data_dir(bi);
         int remaining;
-        int plugged;
 
         if (unlikely(bi->bi_rw & REQ_FLUSH)) {
                 md_flush_request(mddev, bi);
@@ -3990,7 +4015,6 @@ static void make_request(struct mddev *mddev, struct bio * bi)
         bi->bi_next = NULL;
         bi->bi_phys_segments = 1;       /* over-loaded to count active stripes */
 
-        plugged = mddev_check_plugged(mddev);
         for (;logical_sector < last_sector; logical_sector += STRIPE_SECTORS) {
                 DEFINE_WAIT(w);
                 int previous;
@@ -4092,6 +4116,7 @@ static void make_request(struct mddev *mddev, struct bio * bi)
                         if ((bi->bi_rw & REQ_SYNC) &&
                             !test_and_set_bit(STRIPE_PREREAD_ACTIVE, &sh->state))
                                 atomic_inc(&conf->preread_active_stripes);
+                        mddev_check_plugged(mddev);
                         release_stripe(sh);
                 } else {
                         /* cannot get stripe for read-ahead, just give-up */
@@ -4099,10 +4124,7 @@ static void make_request(struct mddev *mddev, struct bio * bi)
                         finish_wait(&conf->wait_for_overlap, &w);
                         break;
                 }
-                        
         }
-        if (!plugged)
-                md_wakeup_thread(mddev->thread);
 
         spin_lock_irq(&conf->device_lock);
         remaining = raid5_dec_bi_phys_segments(bi);
@@ -4823,6 +4845,7 @@ static struct r5conf *setup_conf(struct mddev *mddev)
         int raid_disk, memory, max_disks;
         struct md_rdev *rdev;
         struct disk_info *disk;
+        char pers_name[6];
 
         if (mddev->new_level != 5
             && mddev->new_level != 4
@@ -4946,7 +4969,8 @@ static struct r5conf *setup_conf(struct mddev *mddev)
                 printk(KERN_INFO "md/raid:%s: allocated %dkB\n",
                        mdname(mddev), memory);
 
-        conf->thread = md_register_thread(raid5d, mddev, NULL);
+        sprintf(pers_name, "raid%d", mddev->new_level);
+        conf->thread = md_register_thread(raid5d, mddev, pers_name);
         if (!conf->thread) {
                 printk(KERN_ERR
                        "md/raid:%s: couldn't allocate thread.\n",
@@ -5465,10 +5489,9 @@ static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
         if (rdev->saved_raid_disk >= 0 &&
             rdev->saved_raid_disk >= first &&
             conf->disks[rdev->saved_raid_disk].rdev == NULL)
-                disk = rdev->saved_raid_disk;
-        else
-                disk = first;
-        for ( ; disk <= last ; disk++) {
+                first = rdev->saved_raid_disk;
+
+        for (disk = first; disk <= last; disk++) {
                 p = conf->disks + disk;
                 if (p->rdev == NULL) {
                         clear_bit(In_sync, &rdev->flags);
@@ -5477,8 +5500,11 @@ static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
                         if (rdev->saved_raid_disk != disk)
                                 conf->fullsync = 1;
                         rcu_assign_pointer(p->rdev, rdev);
-                        break;
+                        goto out;
                 }
+        }
+        for (disk = first; disk <= last; disk++) {
+                p = conf->disks + disk;
                 if (test_bit(WantReplacement, &p->rdev->flags) &&
                     p->replacement == NULL) {
                         clear_bit(In_sync, &rdev->flags);
@@ -5490,6 +5516,7 @@ static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
                         break;
                 }
         }
+out:
         print_raid5_conf(conf);
         return err;
 }
diff --git a/drivers/media/dvb/dvb-core/dvbdev.c b/drivers/media/dvb/dvb-core/dvbdev.c
index 00a67326c193..39eab73b01ae 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/drivers/media/dvb/dvb-core/dvbdev.c
@@ -243,6 +243,7 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
         if (minor == MAX_DVB_MINORS) {
                 kfree(dvbdevfops);
                 kfree(dvbdev);
+                up_write(&minor_rwsem);
                 mutex_unlock(&dvbdev_register_lock);
                 return -EINVAL;
         }
diff --git a/drivers/media/rc/winbond-cir.c b/drivers/media/rc/winbond-cir.c
index 342c2c8c1ddf..54ee34872d14 100644
--- a/drivers/media/rc/winbond-cir.c
+++ b/drivers/media/rc/winbond-cir.c
@@ -232,7 +232,7 @@ MODULE_PARM_DESC(invert, "Invert the signal from the IR receiver");
 
 static bool txandrx; /* default = 0 */
 module_param(txandrx, bool, 0444);
-MODULE_PARM_DESC(invert, "Allow simultaneous TX and RX");
+MODULE_PARM_DESC(txandrx, "Allow simultaneous TX and RX");
 
 static unsigned int wake_sc = 0x800F040C;
 module_param(wake_sc, uint, 0644);
@@ -1032,6 +1032,8 @@ wbcir_probe(struct pnp_dev *device, const struct pnp_device_id *dev_id)
         data->dev->tx_ir = wbcir_tx;
         data->dev->priv = data;
         data->dev->dev.parent = &device->dev;
+        data->dev->timeout = MS_TO_NS(100);
+        data->dev->allowed_protos = RC_TYPE_ALL;
 
         if (!request_region(data->wbase, WAKEUP_IOMEM_LEN, DRVNAME)) {
                 dev_err(dev, "Region 0x%lx-0x%lx already in use!\n",
diff --git a/drivers/media/video/cx231xx/cx231xx-audio.c b/drivers/media/video/cx231xx/cx231xx-audio.c
index 068f78dc5d13..b4c99c7270cf 100644
--- a/drivers/media/video/cx231xx/cx231xx-audio.c
+++ b/drivers/media/video/cx231xx/cx231xx-audio.c
@@ -307,7 +307,7 @@ static int cx231xx_init_audio_isoc(struct cx231xx *dev)
                 urb->context = dev;
                 urb->pipe = usb_rcvisocpipe(dev->udev,
                                                 dev->adev.end_point_addr);
-                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
+                urb->transfer_flags = URB_ISO_ASAP;
                 urb->transfer_buffer = dev->adev.transfer_buffer[i];
                 urb->interval = 1;
                 urb->complete = cx231xx_audio_isocirq;
@@ -368,7 +368,7 @@ static int cx231xx_init_audio_bulk(struct cx231xx *dev)
                 urb->context = dev;
                 urb->pipe = usb_rcvbulkpipe(dev->udev,
                                                 dev->adev.end_point_addr);
-                urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+                urb->transfer_flags = 0;
                 urb->transfer_buffer = dev->adev.transfer_buffer[i];
                 urb->complete = cx231xx_audio_bulkirq;
                 urb->transfer_buffer_length = sb_size;
diff --git a/drivers/media/video/cx231xx/cx231xx-vbi.c b/drivers/media/video/cx231xx/cx231xx-vbi.c
index 3d15314e1f88..ac7db52f404f 100644
--- a/drivers/media/video/cx231xx/cx231xx-vbi.c
+++ b/drivers/media/video/cx231xx/cx231xx-vbi.c
@@ -448,7 +448,7 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
                         return -ENOMEM;
                 }
                 dev->vbi_mode.bulk_ctl.urb[i] = urb;
-                urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+                urb->transfer_flags = 0;
 
                 dev->vbi_mode.bulk_ctl.transfer_buffer[i] =
                     kzalloc(sb_size, GFP_KERNEL);
diff --git a/drivers/media/video/cx23885/cx23885-cards.c b/drivers/media/video/cx23885/cx23885-cards.c
index 13739e002a63..080e11157e5f 100644
--- a/drivers/media/video/cx23885/cx23885-cards.c
+++ b/drivers/media/video/cx23885/cx23885-cards.c
@@ -127,22 +127,37 @@ struct cx23885_board cx23885_boards[] = {
         },
         [CX23885_BOARD_HAUPPAUGE_HVR1250] = {
                 .name           = "Hauppauge WinTV-HVR1250",
+                .porta          = CX23885_ANALOG_VIDEO,
                 .portc          = CX23885_MPEG_DVB,
+#ifdef MT2131_NO_ANALOG_SUPPORT_YET
+                .tuner_type     = TUNER_PHILIPS_TDA8290,
+                .tuner_addr     = 0x42, /* 0x84 >> 1 */
+                .tuner_bus      = 1,
+#endif
+                .force_bff      = 1,
                 .input          = {{
+#ifdef MT2131_NO_ANALOG_SUPPORT_YET
                         .type   = CX23885_VMUX_TELEVISION,
-                        .vmux   = 0,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN5_CH2 |
+                                        CX25840_VIN2_CH1,
+                        .amux   = CX25840_AUDIO8,
                         .gpio0  = 0xff00,
                 }, {
-                        .type   = CX23885_VMUX_DEBUG,
-                        .vmux   = 0,
-                        .gpio0  = 0xff01,
-                }, {
+#endif
                         .type   = CX23885_VMUX_COMPOSITE1,
-                        .vmux   = 1,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN6_CH1,
+                        .amux   = CX25840_AUDIO7,
                         .gpio0  = 0xff02,
                 }, {
                         .type   = CX23885_VMUX_SVIDEO,
-                        .vmux   = 2,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN8_CH1 |
+                                        CX25840_SVIDEO_ON,
+                        .amux   = CX25840_AUDIO7,
                         .gpio0  = 0xff02,
                 } },
         },
@@ -267,7 +282,55 @@ struct cx23885_board cx23885_boards[] = {
         },
         [CX23885_BOARD_HAUPPAUGE_HVR1255] = {
                 .name           = "Hauppauge WinTV-HVR1255",
+                .porta          = CX23885_ANALOG_VIDEO,
+                .portc          = CX23885_MPEG_DVB,
+                .tuner_type     = TUNER_ABSENT,
+                .tuner_addr     = 0x42, /* 0x84 >> 1 */
+                .force_bff      = 1,
+                .input          = {{
+                        .type   = CX23885_VMUX_TELEVISION,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN5_CH2 |
+                                        CX25840_VIN2_CH1 |
+                                        CX25840_DIF_ON,
+                        .amux   = CX25840_AUDIO8,
+                }, {
+                        .type   = CX23885_VMUX_COMPOSITE1,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN6_CH1,
+                        .amux   = CX25840_AUDIO7,
+                }, {
+                        .type   = CX23885_VMUX_SVIDEO,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN8_CH1 |
+                                        CX25840_SVIDEO_ON,
+                        .amux   = CX25840_AUDIO7,
+                } },
+        },
+        [CX23885_BOARD_HAUPPAUGE_HVR1255_22111] = {
+                .name           = "Hauppauge WinTV-HVR1255",
+                .porta          = CX23885_ANALOG_VIDEO,
                 .portc          = CX23885_MPEG_DVB,
+                .tuner_type     = TUNER_ABSENT,
+                .tuner_addr     = 0x42, /* 0x84 >> 1 */
+                .force_bff      = 1,
+                .input          = {{
+                        .type   = CX23885_VMUX_TELEVISION,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN5_CH2 |
+                                        CX25840_VIN2_CH1 |
+                                        CX25840_DIF_ON,
+                        .amux   = CX25840_AUDIO8,
+                }, {
+                        .type   = CX23885_VMUX_SVIDEO,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN8_CH1 |
+                                        CX25840_SVIDEO_ON,
+                        .amux   = CX25840_AUDIO7,
+                } },
         },
         [CX23885_BOARD_HAUPPAUGE_HVR1210] = {
                 .name           = "Hauppauge WinTV-HVR1210",
@@ -624,7 +687,7 @@ struct cx23885_subid cx23885_subids[] = {
         }, {
                 .subvendor = 0x0070,
                 .subdevice = 0x2259,
-                .card      = CX23885_BOARD_HAUPPAUGE_HVR1255,
+                .card      = CX23885_BOARD_HAUPPAUGE_HVR1255_22111,
         }, {
                 .subvendor = 0x0070,
                 .subdevice = 0x2291,
@@ -900,7 +963,7 @@ int cx23885_tuner_callback(void *priv, int component, int command, int arg)
         struct cx23885_dev *dev = port->dev;
         u32 bitmask = 0;
 
-        if (command == XC2028_RESET_CLK)
+        if ((command == XC2028_RESET_CLK) || (command == XC2028_I2C_FLUSH))
                 return 0;
 
         if (command != 0) {
@@ -1130,6 +1193,7 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1270:
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
                 /* GPIO-5 RF Control: 0 = RF1 Terrestrial, 1 = RF2 Cable */
                 /* GPIO-6 I2C Gate which can isolate the demod from the bus */
@@ -1267,6 +1331,7 @@ int cx23885_ir_init(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1400:
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
                 /* FIXME: Implement me */
                 break;
@@ -1424,6 +1489,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1270:
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
         case CX23885_BOARD_HAUPPAUGE_HVR1850:
         case CX23885_BOARD_HAUPPAUGE_HVR1290:
@@ -1511,6 +1577,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1270:
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
         case CX23885_BOARD_HAUPPAUGE_HVR1290:
@@ -1526,10 +1593,10 @@ void cx23885_card_setup(struct cx23885_dev *dev)
          */
         switch (dev->board) {
         case CX23885_BOARD_TEVII_S470:
-        case CX23885_BOARD_HAUPPAUGE_HVR1250:
                 /* Currently only enabled for the integrated IR controller */
                 if (!enable_885_ir)
                         break;
+        case CX23885_BOARD_HAUPPAUGE_HVR1250:
         case CX23885_BOARD_HAUPPAUGE_HVR1800:
         case CX23885_BOARD_HAUPPAUGE_HVR1800lp:
         case CX23885_BOARD_HAUPPAUGE_HVR1700:
@@ -1539,6 +1606,8 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_NETUP_DUAL_DVBS2_CI:
         case CX23885_BOARD_NETUP_DUAL_DVB_T_C_CI_RF:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1270:
         case CX23885_BOARD_HAUPPAUGE_HVR1850:
         case CX23885_BOARD_MYGICA_X8506:
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index a80a92c47455..cd542684ba02 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -712,6 +712,7 @@ static int dvb_register(struct cx23885_tsport *port)
                 }
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
                 i2c_bus = &dev->i2c_bus[0];
                 fe0->dvb.frontend = dvb_attach(s5h1411_attach,
                                                &hcw_s5h1411_config,
@@ -721,6 +722,11 @@ static int dvb_register(struct cx23885_tsport *port)
                                    0x60, &dev->i2c_bus[1].i2c_adap,
                                    &hauppauge_tda18271_config);
                 }
+
+                tda18271_attach(&dev->ts1.analog_fe,
+                        0x60, &dev->i2c_bus[1].i2c_adap,
+                        &hauppauge_tda18271_config);
+
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1800:
                 i2c_bus = &dev->i2c_bus[0];
diff --git a/drivers/media/video/cx23885/cx23885-video.c b/drivers/media/video/cx23885/cx23885-video.c
index c654bdc7ccb2..22f8e7fbd665 100644
--- a/drivers/media/video/cx23885/cx23885-video.c
+++ b/drivers/media/video/cx23885/cx23885-video.c
@@ -505,6 +505,9 @@ static int cx23885_video_mux(struct cx23885_dev *dev, unsigned int input)
 
         if ((dev->board == CX23885_BOARD_HAUPPAUGE_HVR1800) ||
                 (dev->board == CX23885_BOARD_MPX885) ||
+                (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1250) ||
+                (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255) ||
+                (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255_22111) ||
                 (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850)) {
                 /* Configure audio routing */
                 v4l2_subdev_call(dev->sd_cx25840, audio, s_routing,
@@ -1578,7 +1581,9 @@ static int cx23885_set_freq_via_ops(struct cx23885_dev *dev,
 
         fe = vfe->dvb.frontend;
 
-        if (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850)
+        if ((dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850) ||
+            (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255) ||
+            (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255_22111))
                 fe = &dev->ts1.analog_fe;
 
         if (fe && fe->ops.tuner_ops.set_analog_params) {
@@ -1608,6 +1613,8 @@ int cx23885_set_frequency(struct file *file, void *priv,
         int ret;
 
         switch (dev->board) {
+        case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1850:
                 ret = cx23885_set_freq_via_ops(dev, f);
                 break;
diff --git a/drivers/media/video/cx23885/cx23885.h b/drivers/media/video/cx23885/cx23885.h
index d884784a1c85..13c37ec07ae7 100644
--- a/drivers/media/video/cx23885/cx23885.h
+++ b/drivers/media/video/cx23885/cx23885.h
@@ -90,6 +90,7 @@
 #define CX23885_BOARD_MYGICA_X8507             33
 #define CX23885_BOARD_TERRATEC_CINERGY_T_PCIE_DUAL 34
 #define CX23885_BOARD_TEVII_S471               35
+#define CX23885_BOARD_HAUPPAUGE_HVR1255_22111  36
 
 #define GPIO_0 0x00000001
 #define GPIO_1 0x00000002
diff --git a/drivers/media/video/cx25821/cx25821-core.c b/drivers/media/video/cx25821/cx25821-core.c
index 83c1aa6b2e6c..f11f6f07e915 100644
--- a/drivers/media/video/cx25821/cx25821-core.c
+++ b/drivers/media/video/cx25821/cx25821-core.c
@@ -904,9 +904,6 @@ static int cx25821_dev_setup(struct cx25821_dev *dev)
         list_add_tail(&dev->devlist, &cx25821_devlist);
         mutex_unlock(&cx25821_devlist_mutex);
 
-        strcpy(cx25821_boards[UNKNOWN_BOARD].name, "unknown");
-        strcpy(cx25821_boards[CX25821_BOARD].name, "cx25821");
-
         if (dev->pci->device != 0x8210) {
                 pr_info("%s(): Exiting. Incorrect Hardware device = 0x%02x\n",
                         __func__, dev->pci->device);
diff --git a/drivers/media/video/cx25821/cx25821.h b/drivers/media/video/cx25821/cx25821.h
index b9aa801b00a7..029f2934a6d8 100644
--- a/drivers/media/video/cx25821/cx25821.h
+++ b/drivers/media/video/cx25821/cx25821.h
@@ -187,7 +187,7 @@ enum port {
 };
 
 struct cx25821_board {
-        char *name;
+        const char *name;
         enum port porta;
         enum port portb;
         enum port portc;
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index fc1ff69cffd0..d8eac3e30a7e 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -84,7 +84,7 @@ MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
 
 
 /* ----------------------------------------------------------------------- */
-static void cx23885_std_setup(struct i2c_client *client);
+static void cx23888_std_setup(struct i2c_client *client);
 
 int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
 {
@@ -638,10 +638,13 @@ static void cx23885_initialize(struct i2c_client *client)
         finish_wait(&state->fw_wait, &wait);
         destroy_workqueue(q);
 
-        /* Call the cx23885 specific std setup func, we no longer rely on
+        /* Call the cx23888 specific std setup func, we no longer rely on
          * the generic cx24840 func.
          */
-        cx23885_std_setup(client);
+        if (is_cx23888(state))
+                cx23888_std_setup(client);
+        else
+                cx25840_std_setup(client);
 
         /* (re)set input */
         set_input(client, state->vid_input, state->aud_input);
@@ -1103,9 +1106,23 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
 
                         cx25840_write4(client, 0x410, 0xffff0dbf);
                         cx25840_write4(client, 0x414, 0x00137d03);
-                        cx25840_write4(client, 0x418, 0x01008080);
+
+                        /* on the 887, 0x418 is HSCALE_CTRL, on the 888 it is 
+                           CHROMA_CTRL */
+                        if (is_cx23888(state))
+                                cx25840_write4(client, 0x418, 0x01008080);
+                        else
+                                cx25840_write4(client, 0x418, 0x01000000);
+
                         cx25840_write4(client, 0x41c, 0x00000000);
-                        cx25840_write4(client, 0x420, 0x001c3e0f);
+
+                        /* on the 887, 0x420 is CHROMA_CTRL, on the 888 it is 
+                           CRUSH_CTRL */
+                        if (is_cx23888(state))
+                                cx25840_write4(client, 0x420, 0x001c3e0f);
+                        else
+                                cx25840_write4(client, 0x420, 0x001c8282);
+
                         cx25840_write4(client, 0x42c, 0x42600000);
                         cx25840_write4(client, 0x430, 0x0000039b);
                         cx25840_write4(client, 0x438, 0x00000000);
@@ -1233,7 +1250,7 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
                 cx25840_write4(client, 0x8d0, 0x1f063870);
         }
 
-        if (is_cx2388x(state)) {
+        if (is_cx23888(state)) {
                 /* HVR1850 */
                 /* AUD_IO_CTRL - I2S Input, Parallel1*/
                 /*  - Channel 1 src - Parallel1 (Merlin out) */
@@ -1298,8 +1315,8 @@ static int set_v4lstd(struct i2c_client *client)
         }
         cx25840_and_or(client, 0x400, ~0xf, fmt);
         cx25840_and_or(client, 0x403, ~0x3, pal_m);
-        if (is_cx2388x(state))
-                cx23885_std_setup(client);
+        if (is_cx23888(state))
+                cx23888_std_setup(client);
         else
                 cx25840_std_setup(client);
         if (!is_cx2583x(state))
@@ -1312,6 +1329,7 @@ static int set_v4lstd(struct i2c_client *client)
 static int cx25840_s_ctrl(struct v4l2_ctrl *ctrl)
 {
         struct v4l2_subdev *sd = to_sd(ctrl);
+        struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
         switch (ctrl->id) {
@@ -1324,12 +1342,20 @@ static int cx25840_s_ctrl(struct v4l2_ctrl *ctrl)
                 break;
 
         case V4L2_CID_SATURATION:
-                cx25840_write(client, 0x420, ctrl->val << 1);
-                cx25840_write(client, 0x421, ctrl->val << 1);
+                if (is_cx23888(state)) {
+                        cx25840_write(client, 0x418, ctrl->val << 1);
+                        cx25840_write(client, 0x419, ctrl->val << 1);
+                } else {
+                        cx25840_write(client, 0x420, ctrl->val << 1);
+                        cx25840_write(client, 0x421, ctrl->val << 1);
+                }
                 break;
 
         case V4L2_CID_HUE:
-                cx25840_write(client, 0x422, ctrl->val);
+                if (is_cx23888(state))
+                        cx25840_write(client, 0x41a, ctrl->val);
+                else
+                        cx25840_write(client, 0x422, ctrl->val);
                 break;
 
         default:
@@ -1354,11 +1380,21 @@ static int cx25840_s_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt
         fmt->field = V4L2_FIELD_INTERLACED;
         fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 
-        Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
-        Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
+        if (is_cx23888(state)) {
+                Vsrc = (cx25840_read(client, 0x42a) & 0x3f) << 4;
+                Vsrc |= (cx25840_read(client, 0x429) & 0xf0) >> 4;
+        } else {
+                Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
+                Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
+        }
 
-        Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
-        Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
+        if (is_cx23888(state)) {
+                Hsrc = (cx25840_read(client, 0x426) & 0x3f) << 4;
+                Hsrc |= (cx25840_read(client, 0x425) & 0xf0) >> 4;
+        } else {
+                Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
+                Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
+        }
 
         Vlines = fmt->height + (is_50Hz ? 4 : 7);
 
@@ -1782,8 +1818,8 @@ static int cx25840_s_video_routing(struct v4l2_subdev *sd,
         struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (is_cx2388x(state))
-                cx23885_std_setup(client);
+        if (is_cx23888(state))
+                cx23888_std_setup(client);
 
         return set_input(client, input, state->aud_input);
 }
@@ -1794,8 +1830,8 @@ static int cx25840_s_audio_routing(struct v4l2_subdev *sd,
         struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (is_cx2388x(state))
-                cx23885_std_setup(client);
+        if (is_cx23888(state))
+                cx23888_std_setup(client);
         return set_input(client, state->vid_input, input);
 }
 
@@ -4939,7 +4975,7 @@ void cx23885_dif_setup(struct i2c_client *client, u32 ifHz)
         }
 }
 
-static void cx23885_std_setup(struct i2c_client *client)
+static void cx23888_std_setup(struct i2c_client *client)
 {
         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
         v4l2_std_id std = state->std;
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 92da7c28b6f0..862c6575c557 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -2893,7 +2893,7 @@ static void request_module_async(struct work_struct *work)
 
         if (dev->board.has_dvb)
                 request_module("em28xx-dvb");
-        if (dev->board.has_ir_i2c && !disable_ir)
+        if (dev->board.ir_codes && !disable_ir)
                 request_module("em28xx-rc");
 }
 
diff --git a/drivers/media/video/gspca/sn9c20x.c b/drivers/media/video/gspca/sn9c20x.c
index 6c31e46a1fd2..b9c6f17eabb2 100644
--- a/drivers/media/video/gspca/sn9c20x.c
+++ b/drivers/media/video/gspca/sn9c20x.c
@@ -2070,10 +2070,13 @@ static int sd_start(struct gspca_dev *gspca_dev)
         set_gamma(gspca_dev, v4l2_ctrl_g_ctrl(sd->gamma));
         set_redblue(gspca_dev, v4l2_ctrl_g_ctrl(sd->blue),
                         v4l2_ctrl_g_ctrl(sd->red));
-        set_gain(gspca_dev, v4l2_ctrl_g_ctrl(sd->gain));
-        set_exposure(gspca_dev, v4l2_ctrl_g_ctrl(sd->exposure));
-        set_hvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip),
-                        v4l2_ctrl_g_ctrl(sd->vflip));
+        if (sd->gain)
+                set_gain(gspca_dev, v4l2_ctrl_g_ctrl(sd->gain));
+        if (sd->exposure)
+                set_exposure(gspca_dev, v4l2_ctrl_g_ctrl(sd->exposure));
+        if (sd->hflip)
+                set_hvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip),
+                                v4l2_ctrl_g_ctrl(sd->vflip));
 
         reg_w1(gspca_dev, 0x1007, 0x20);
         reg_w1(gspca_dev, 0x1061, 0x03);
@@ -2176,7 +2179,7 @@ static void sd_dqcallback(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         int avg_lum;
 
-        if (!v4l2_ctrl_g_ctrl(sd->autogain))
+        if (sd->autogain == NULL || !v4l2_ctrl_g_ctrl(sd->autogain))
                 return;
 
         avg_lum = atomic_read(&sd->avg_lum);
diff --git a/drivers/media/video/mx2_camera.c b/drivers/media/video/mx2_camera.c
index 41f9a254b245..637bde8aca28 100644
--- a/drivers/media/video/mx2_camera.c
+++ b/drivers/media/video/mx2_camera.c
@@ -83,6 +83,7 @@
 #define CSICR1_INV_DATA         (1 << 3)
 #define CSICR1_INV_PCLK         (1 << 2)
 #define CSICR1_REDGE            (1 << 1)
+#define CSICR1_FMT_MASK         (CSICR1_PACK_DIR | CSICR1_SWAP16_EN)
 
 #define SHIFT_STATFF_LEVEL      22
 #define SHIFT_RXFF_LEVEL        19
@@ -230,6 +231,7 @@ struct mx2_prp_cfg {
         u32 src_pixel;
         u32 ch1_pixel;
         u32 irq_flags;
+        u32 csicr1;
 };
 
 /* prp resizing parameters */
@@ -330,6 +332,7 @@ static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
                         .ch1_pixel      = 0x2ca00565, /* RGB565 */
                         .irq_flags      = PRP_INTR_RDERR | PRP_INTR_CH1WERR |
                                                 PRP_INTR_CH1FC | PRP_INTR_LBOVF,
+                        .csicr1         = 0,
                 }
         },
         {
@@ -343,6 +346,21 @@ static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
                         .irq_flags      = PRP_INTR_RDERR | PRP_INTR_CH2WERR |
                                         PRP_INTR_CH2FC | PRP_INTR_LBOVF |
                                         PRP_INTR_CH2OVF,
+                        .csicr1         = CSICR1_PACK_DIR,
+                }
+        },
+        {
+                .in_fmt         = V4L2_MBUS_FMT_UYVY8_2X8,
+                .out_fmt        = V4L2_PIX_FMT_YUV420,
+                .cfg            = {
+                        .channel        = 2,
+                        .in_fmt         = PRP_CNTL_DATA_IN_YUV422,
+                        .out_fmt        = PRP_CNTL_CH2_OUT_YUV420,
+                        .src_pixel      = 0x22000888, /* YUV422 (YUYV) */
+                        .irq_flags      = PRP_INTR_RDERR | PRP_INTR_CH2WERR |
+                                        PRP_INTR_CH2FC | PRP_INTR_LBOVF |
+                                        PRP_INTR_CH2OVF,
+                        .csicr1         = CSICR1_SWAP16_EN,
                 }
         },
 };
@@ -1015,14 +1033,14 @@ static int mx2_camera_set_bus_param(struct soc_camera_device *icd)
                 return ret;
         }
 
+        csicr1 = (csicr1 & ~CSICR1_FMT_MASK) | pcdev->emma_prp->cfg.csicr1;
+
         if (common_flags & V4L2_MBUS_PCLK_SAMPLE_RISING)
                 csicr1 |= CSICR1_REDGE;
         if (common_flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH)
                 csicr1 |= CSICR1_SOF_POL;
         if (common_flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH)
                 csicr1 |= CSICR1_HSYNC_POL;
-        if (pcdev->platform_flags & MX2_CAMERA_SWAP16)
-                csicr1 |= CSICR1_SWAP16_EN;
         if (pcdev->platform_flags & MX2_CAMERA_EXT_VSYNC)
                 csicr1 |= CSICR1_EXT_VSYNC;
         if (pcdev->platform_flags & MX2_CAMERA_CCIR)
@@ -1033,8 +1051,6 @@ static int mx2_camera_set_bus_param(struct soc_camera_device *icd)
                 csicr1 |= CSICR1_GCLK_MODE;
         if (pcdev->platform_flags & MX2_CAMERA_INV_DATA)
                 csicr1 |= CSICR1_INV_DATA;
-        if (pcdev->platform_flags & MX2_CAMERA_PACK_DIR_MSB)
-                csicr1 |= CSICR1_PACK_DIR;
 
         pcdev->csicr1 = csicr1;
 
@@ -1109,7 +1125,8 @@ static int mx2_camera_get_formats(struct soc_camera_device *icd,
                 return 0;
         }
 
-        if (code == V4L2_MBUS_FMT_YUYV8_2X8) {
+        if (code == V4L2_MBUS_FMT_YUYV8_2X8 ||
+            code == V4L2_MBUS_FMT_UYVY8_2X8) {
                 formats++;
                 if (xlate) {
                         /*
diff --git a/drivers/media/video/omap3isp/isppreview.c b/drivers/media/video/omap3isp/isppreview.c
index 8a4935ecc655..dd91da26f1b0 100644
--- a/drivers/media/video/omap3isp/isppreview.c
+++ b/drivers/media/video/omap3isp/isppreview.c
@@ -888,12 +888,12 @@ static const struct preview_update update_attrs[] = {
                 preview_config_contrast,
                 NULL,
                 offsetof(struct prev_params, contrast),
-                0, true,
+                0, 0, true,
         }, /* OMAP3ISP_PREV_BRIGHTNESS */ {
                 preview_config_brightness,
                 NULL,
                 offsetof(struct prev_params, brightness),
-                0, true,
+                0, 0, true,
         },
 };
 
@@ -1102,7 +1102,7 @@ static void preview_config_input_size(struct isp_prev_device *prev, u32 active)
         unsigned int elv = prev->crop.top + prev->crop.height - 1;
         u32 features;
 
-        if (format->code == V4L2_MBUS_FMT_Y10_1X10) {
+        if (format->code != V4L2_MBUS_FMT_Y10_1X10) {
                 sph -= 2;
                 eph += 2;
                 slv -= 2;
diff --git a/drivers/media/video/pms.c b/drivers/media/video/pms.c
index c370c2d87c17..b4c679b3fb0f 100644
--- a/drivers/media/video/pms.c
+++ b/drivers/media/video/pms.c
@@ -26,6 +26,7 @@
 #include <linux/fs.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/mutex.h>
diff --git a/drivers/media/video/s5p-fimc/fimc-capture.c b/drivers/media/video/s5p-fimc/fimc-capture.c
index 354574591908..725812aa0c30 100644
--- a/drivers/media/video/s5p-fimc/fimc-capture.c
+++ b/drivers/media/video/s5p-fimc/fimc-capture.c
@@ -350,7 +350,8 @@ static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *pfmt,
                 if (pixm)
                         sizes[i] = max(size, pixm->plane_fmt[i].sizeimage);
                 else
-                        sizes[i] = size;
+                        sizes[i] = max_t(u32, size, frame->payload[i]);
+
                 allocators[i] = ctx->fimc_dev->alloc_ctx;
         }
 
@@ -479,37 +480,39 @@ static int fimc_capture_set_default_format(struct fimc_dev *fimc);
 static int fimc_capture_open(struct file *file)
 {
         struct fimc_dev *fimc = video_drvdata(file);
-        int ret = v4l2_fh_open(file);
-
-        if (ret)
-                return ret;
+        int ret;
 
         dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
 
-        /* Return if the corresponding video mem2mem node is already opened. */
         if (fimc_m2m_active(fimc))
                 return -EBUSY;
 
         set_bit(ST_CAPT_BUSY, &fimc->state);
-        pm_runtime_get_sync(&fimc->pdev->dev);
+        ret = pm_runtime_get_sync(&fimc->pdev->dev);
+        if (ret < 0)
+                return ret;
 
-        if (++fimc->vid_cap.refcnt == 1) {
-                ret = fimc_pipeline_initialize(&fimc->pipeline,
-                               &fimc->vid_cap.vfd->entity, true);
-                if (ret < 0) {
-                        dev_err(&fimc->pdev->dev,
-                                "Video pipeline initialization failed\n");
-                        pm_runtime_put_sync(&fimc->pdev->dev);
-                        fimc->vid_cap.refcnt--;
-                        v4l2_fh_release(file);
-                        clear_bit(ST_CAPT_BUSY, &fimc->state);
-                        return ret;
-                }
-                ret = fimc_capture_ctrls_create(fimc);
+        ret = v4l2_fh_open(file);
+        if (ret)
+                return ret;
 
-                if (!ret && !fimc->vid_cap.user_subdev_api)
-                        ret = fimc_capture_set_default_format(fimc);
+        if (++fimc->vid_cap.refcnt != 1)
+                return 0;
+
+        ret = fimc_pipeline_initialize(&fimc->pipeline,
+                                       &fimc->vid_cap.vfd->entity, true);
+        if (ret < 0) {
+                clear_bit(ST_CAPT_BUSY, &fimc->state);
+                pm_runtime_put_sync(&fimc->pdev->dev);
+                fimc->vid_cap.refcnt--;
+                v4l2_fh_release(file);
+                return ret;
         }
+        ret = fimc_capture_ctrls_create(fimc);
+
+        if (!ret && !fimc->vid_cap.user_subdev_api)
+                ret = fimc_capture_set_default_format(fimc);
+
         return ret;
 }
 
@@ -818,9 +821,6 @@ static int fimc_cap_g_fmt_mplane(struct file *file, void *fh,
         struct fimc_dev *fimc = video_drvdata(file);
         struct fimc_ctx *ctx = fimc->vid_cap.ctx;
 
-        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
-                return -EINVAL;
-
         return fimc_fill_format(&ctx->d_frame, f);
 }
 
@@ -833,9 +833,6 @@ static int fimc_cap_try_fmt_mplane(struct file *file, void *fh,
         struct v4l2_mbus_framefmt mf;
         struct fimc_fmt *ffmt = NULL;
 
-        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
-                return -EINVAL;
-
         if (pix->pixelformat == V4L2_PIX_FMT_JPEG) {
                 fimc_capture_try_format(ctx, &pix->width, &pix->height,
                                         NULL, &pix->pixelformat,
@@ -887,8 +884,6 @@ static int fimc_capture_set_format(struct fimc_dev *fimc, struct v4l2_format *f)
         struct fimc_fmt *s_fmt = NULL;
         int ret, i;
 
-        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
-                return -EINVAL;
         if (vb2_is_busy(&fimc->vid_cap.vbq))
                 return -EBUSY;
 
@@ -924,10 +919,10 @@ static int fimc_capture_set_format(struct fimc_dev *fimc, struct v4l2_format *f)
                 pix->width  = mf->width;
                 pix->height = mf->height;
         }
+
         fimc_adjust_mplane_format(ff->fmt, pix->width, pix->height, pix);
         for (i = 0; i < ff->fmt->colplanes; i++)
-                ff->payload[i] =
-                        (pix->width * pix->height * ff->fmt->depth[i]) / 8;
+                ff->payload[i] = pix->plane_fmt[i].sizeimage;
 
         set_frame_bounds(ff, pix->width, pix->height);
         /* Reset the composition rectangle if not yet configured */
@@ -1045,18 +1040,22 @@ static int fimc_cap_streamon(struct file *file, void *priv,
 {
         struct fimc_dev *fimc = video_drvdata(file);
         struct fimc_pipeline *p = &fimc->pipeline;
+        struct v4l2_subdev *sd = p->subdevs[IDX_SENSOR];
         int ret;
 
         if (fimc_capture_active(fimc))
                 return -EBUSY;
 
-        media_entity_pipeline_start(&p->subdevs[IDX_SENSOR]->entity,
-                                    p->m_pipeline);
+        ret = media_entity_pipeline_start(&sd->entity, p->m_pipeline);
+        if (ret < 0)
+                return ret;
 
         if (fimc->vid_cap.user_subdev_api) {
                 ret = fimc_pipeline_validate(fimc);
-                if (ret)
+                if (ret < 0) {
+                        media_entity_pipeline_stop(&sd->entity);
                         return ret;
+                }
         }
         return vb2_streamon(&fimc->vid_cap.vbq, type);
 }
diff --git a/drivers/media/video/s5p-fimc/fimc-core.c b/drivers/media/video/s5p-fimc/fimc-core.c
index 92fc5a20fb76..a4646ca1d56f 100644
--- a/drivers/media/video/s5p-fimc/fimc-core.c
+++ b/drivers/media/video/s5p-fimc/fimc-core.c
@@ -153,7 +153,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .colplanes      = 2,
                 .flags          = FMT_FLAGS_M2M,
         }, {
-                .name           = "YUV 4:2:0 non-contiguous 2-planar, Y/CbCr",
+                .name           = "YUV 4:2:0 non-contig. 2p, Y/CbCr",
                 .fourcc         = V4L2_PIX_FMT_NV12M,
                 .color          = FIMC_FMT_YCBCR420,
                 .depth          = { 8, 4 },
@@ -161,7 +161,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .colplanes      = 2,
                 .flags          = FMT_FLAGS_M2M,
         }, {
-                .name           = "YUV 4:2:0 non-contiguous 3-planar, Y/Cb/Cr",
+                .name           = "YUV 4:2:0 non-contig. 3p, Y/Cb/Cr",
                 .fourcc         = V4L2_PIX_FMT_YUV420M,
                 .color          = FIMC_FMT_YCBCR420,
                 .depth          = { 8, 2, 2 },
@@ -169,7 +169,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .colplanes      = 3,
                 .flags          = FMT_FLAGS_M2M,
         }, {
-                .name           = "YUV 4:2:0 non-contiguous 2-planar, Y/CbCr, tiled",
+                .name           = "YUV 4:2:0 non-contig. 2p, tiled",
                 .fourcc         = V4L2_PIX_FMT_NV12MT,
                 .color          = FIMC_FMT_YCBCR420,
                 .depth          = { 8, 4 },
@@ -641,7 +641,7 @@ void fimc_ctrls_activate(struct fimc_ctx *ctx, bool active)
         if (!ctrls->ready)
                 return;
 
-        mutex_lock(&ctrls->handler.lock);
+        mutex_lock(ctrls->handler.lock);
         v4l2_ctrl_activate(ctrls->rotate, active);
         v4l2_ctrl_activate(ctrls->hflip, active);
         v4l2_ctrl_activate(ctrls->vflip, active);
@@ -660,7 +660,7 @@ void fimc_ctrls_activate(struct fimc_ctx *ctx, bool active)
                 ctx->hflip    = 0;
                 ctx->vflip    = 0;
         }
-        mutex_unlock(&ctrls->handler.lock);
+        mutex_unlock(ctrls->handler.lock);
 }
 
 /* Update maximum value of the alpha color control */
@@ -741,8 +741,8 @@ void fimc_adjust_mplane_format(struct fimc_fmt *fmt, u32 width, u32 height,
         pix->width = width;
 
         for (i = 0; i < pix->num_planes; ++i) {
-                u32 bpl = pix->plane_fmt[i].bytesperline;
-                u32 *sizeimage = &pix->plane_fmt[i].sizeimage;
+                struct v4l2_plane_pix_format *plane_fmt = &pix->plane_fmt[i];
+                u32 bpl = plane_fmt->bytesperline;
 
                 if (fmt->colplanes > 1 && (bpl == 0 || bpl < pix->width))
                         bpl = pix->width; /* Planar */
@@ -754,8 +754,9 @@ void fimc_adjust_mplane_format(struct fimc_fmt *fmt, u32 width, u32 height,
                 if (i == 0) /* Same bytesperline for each plane. */
                         bytesperline = bpl;
 
-                pix->plane_fmt[i].bytesperline = bytesperline;
-                *sizeimage = (pix->width * pix->height * fmt->depth[i]) / 8;
+                plane_fmt->bytesperline = bytesperline;
+                plane_fmt->sizeimage = max((pix->width * pix->height *
+                                   fmt->depth[i]) / 8, plane_fmt->sizeimage);
         }
 }
 
diff --git a/drivers/media/video/s5p-fimc/fimc-lite.c b/drivers/media/video/s5p-fimc/fimc-lite.c
index 400d701aef04..74ff310db30c 100644
--- a/drivers/media/video/s5p-fimc/fimc-lite.c
+++ b/drivers/media/video/s5p-fimc/fimc-lite.c
@@ -451,34 +451,44 @@ static void fimc_lite_clear_event_counters(struct fimc_lite *fimc)
 static int fimc_lite_open(struct file *file)
 {
         struct fimc_lite *fimc = video_drvdata(file);
-        int ret = v4l2_fh_open(file);
+        int ret;
 
-        if (ret)
-                return ret;
+        if (mutex_lock_interruptible(&fimc->lock))
+                return -ERESTARTSYS;
 
         set_bit(ST_FLITE_IN_USE, &fimc->state);
-        pm_runtime_get_sync(&fimc->pdev->dev);
+        ret = pm_runtime_get_sync(&fimc->pdev->dev);
+        if (ret < 0)
+                goto done;
 
-        if (++fimc->ref_count != 1 || fimc->out_path != FIMC_IO_DMA)
-                return ret;
+        ret = v4l2_fh_open(file);
+        if (ret < 0)
+                goto done;
 
-        ret = fimc_pipeline_initialize(&fimc->pipeline, &fimc->vfd->entity,
-                                       true);
-        if (ret < 0) {
-                v4l2_err(fimc->vfd, "Video pipeline initialization failed\n");
-                pm_runtime_put_sync(&fimc->pdev->dev);
-                fimc->ref_count--;
-                v4l2_fh_release(file);
-                clear_bit(ST_FLITE_IN_USE, &fimc->state);
-        }
+        if (++fimc->ref_count == 1 && fimc->out_path == FIMC_IO_DMA) {
+                ret = fimc_pipeline_initialize(&fimc->pipeline,
+                                               &fimc->vfd->entity, true);
+                if (ret < 0) {
+                        pm_runtime_put_sync(&fimc->pdev->dev);
+                        fimc->ref_count--;
+                        v4l2_fh_release(file);
+                        clear_bit(ST_FLITE_IN_USE, &fimc->state);
+                }
 
-        fimc_lite_clear_event_counters(fimc);
+                fimc_lite_clear_event_counters(fimc);
+        }
+done:
+        mutex_unlock(&fimc->lock);
         return ret;
 }
 
 static int fimc_lite_close(struct file *file)
 {
         struct fimc_lite *fimc = video_drvdata(file);
+        int ret;
+
+        if (mutex_lock_interruptible(&fimc->lock))
+                return -ERESTARTSYS;
 
         if (--fimc->ref_count == 0 && fimc->out_path == FIMC_IO_DMA) {
                 clear_bit(ST_FLITE_IN_USE, &fimc->state);
@@ -492,20 +502,39 @@ static int fimc_lite_close(struct file *file)
         if (fimc->ref_count == 0)
                 vb2_queue_release(&fimc->vb_queue);
 
-        return v4l2_fh_release(file);
+        ret = v4l2_fh_release(file);
+
+        mutex_unlock(&fimc->lock);
+        return ret;
 }
 
 static unsigned int fimc_lite_poll(struct file *file,
                                    struct poll_table_struct *wait)
 {
         struct fimc_lite *fimc = video_drvdata(file);
-        return vb2_poll(&fimc->vb_queue, file, wait);
+        int ret;
+
+        if (mutex_lock_interruptible(&fimc->lock))
+                return POLL_ERR;
+
+        ret = vb2_poll(&fimc->vb_queue, file, wait);
+        mutex_unlock(&fimc->lock);
+
+        return ret;
 }
 
 static int fimc_lite_mmap(struct file *file, struct vm_area_struct *vma)
 {
         struct fimc_lite *fimc = video_drvdata(file);
-        return vb2_mmap(&fimc->vb_queue, vma);
+        int ret;
+
+        if (mutex_lock_interruptible(&fimc->lock))
+                return -ERESTARTSYS;
+
+        ret = vb2_mmap(&fimc->vb_queue, vma);
+        mutex_unlock(&fimc->lock);
+
+        return ret;
 }
 
 static const struct v4l2_file_operations fimc_lite_fops = {
@@ -762,7 +791,9 @@ static int fimc_lite_streamon(struct file *file, void *priv,
         if (fimc_lite_active(fimc))
                 return -EBUSY;
 
-        media_entity_pipeline_start(&sensor->entity, p->m_pipeline);
+        ret = media_entity_pipeline_start(&sensor->entity, p->m_pipeline);
+        if (ret < 0)
+                return ret;
 
         ret = fimc_pipeline_validate(fimc);
         if (ret) {
@@ -1508,7 +1539,7 @@ static int fimc_lite_suspend(struct device *dev)
                 return 0;
 
         ret = fimc_lite_stop_capture(fimc, suspend);
-        if (ret)
+        if (ret < 0 || !fimc_lite_active(fimc))
                 return ret;
 
         return fimc_pipeline_shutdown(&fimc->pipeline);
diff --git a/drivers/media/video/s5p-fimc/fimc-mdevice.c b/drivers/media/video/s5p-fimc/fimc-mdevice.c
index 6753c45631b8..52cef4865423 100644
--- a/drivers/media/video/s5p-fimc/fimc-mdevice.c
+++ b/drivers/media/video/s5p-fimc/fimc-mdevice.c
@@ -193,9 +193,13 @@ int __fimc_pipeline_shutdown(struct fimc_pipeline *p)
 
 int fimc_pipeline_shutdown(struct fimc_pipeline *p)
 {
-        struct media_entity *me = &p->subdevs[IDX_SENSOR]->entity;
+        struct media_entity *me;
         int ret;
 
+        if (!p || !p->subdevs[IDX_SENSOR])
+                return -EINVAL;
+
+        me = &p->subdevs[IDX_SENSOR]->entity;
         mutex_lock(&me->parent->graph_mutex);
         ret = __fimc_pipeline_shutdown(p);
         mutex_unlock(&me->parent->graph_mutex);
@@ -498,12 +502,12 @@ static void fimc_md_unregister_entities(struct fimc_md *fmd)
  * @source: the source entity to create links to all fimc entities from
  * @sensor: sensor subdev linked to FIMC[fimc_id] entity, may be null
  * @pad: the source entity pad index
- * @fimc_id: index of the fimc device for which link should be enabled
+ * @link_mask: bitmask of the fimc devices for which link should be enabled
  */
 static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                                             struct media_entity *source,
                                             struct v4l2_subdev *sensor,
-                                            int pad, int fimc_id)
+                                            int pad, int link_mask)
 {
         struct fimc_sensor_info *s_info;
         struct media_entity *sink;
@@ -520,7 +524,7 @@ static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                 if (!fmd->fimc[i]->variant->has_cam_if)
                         continue;
 
-                flags = (i == fimc_id) ? MEDIA_LNK_FL_ENABLED : 0;
+                flags = ((1 << i) & link_mask) ? MEDIA_LNK_FL_ENABLED : 0;
 
                 sink = &fmd->fimc[i]->vid_cap.subdev.entity;
                 ret = media_entity_create_link(source, pad, sink,
@@ -552,7 +556,10 @@ static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                 if (!fmd->fimc_lite[i])
                         continue;
 
-                flags = (i == fimc_id) ? MEDIA_LNK_FL_ENABLED : 0;
+                if (link_mask & (1 << (i + FIMC_MAX_DEVS)))
+                        flags = MEDIA_LNK_FL_ENABLED;
+                else
+                        flags = 0;
 
                 sink = &fmd->fimc_lite[i]->subdev.entity;
                 ret = media_entity_create_link(source, pad, sink,
@@ -614,9 +621,8 @@ static int fimc_md_create_links(struct fimc_md *fmd)
         struct s5p_fimc_isp_info *pdata;
         struct fimc_sensor_info *s_info;
         struct media_entity *source, *sink;
-        int i, pad, fimc_id = 0;
-        int ret = 0;
-        u32 flags;
+        int i, pad, fimc_id = 0, ret = 0;
+        u32 flags, link_mask = 0;
 
         for (i = 0; i < fmd->num_sensors; i++) {
                 if (fmd->sensor[i].subdev == NULL)
@@ -668,19 +674,20 @@ static int fimc_md_create_links(struct fimc_md *fmd)
                 if (source == NULL)
                         continue;
 
+                link_mask = 1 << fimc_id++;
                 ret = __fimc_md_create_fimc_sink_links(fmd, source, sensor,
-                                                       pad, fimc_id++);
+                                                       pad, link_mask);
         }
 
-        fimc_id = 0;
         for (i = 0; i < ARRAY_SIZE(fmd->csis); i++) {
                 if (fmd->csis[i].sd == NULL)
                         continue;
                 source = &fmd->csis[i].sd->entity;
                 pad = CSIS_PAD_SOURCE;
 
+                link_mask = 1 << fimc_id++;
                 ret = __fimc_md_create_fimc_sink_links(fmd, source, NULL,
-                                                       pad, fimc_id++);
+                                                       pad, link_mask);
         }
 
         /* Create immutable links between each FIMC's subdev and video node */
@@ -734,8 +741,8 @@ static void fimc_md_put_clocks(struct fimc_md *fmd)
 }
 
 static int __fimc_md_set_camclk(struct fimc_md *fmd,
-                                         struct fimc_sensor_info *s_info,
-                                         bool on)
+                                struct fimc_sensor_info *s_info,
+                                bool on)
 {
         struct s5p_fimc_isp_info *pdata = s_info->pdata;
         struct fimc_camclk_info *camclk;
@@ -744,12 +751,10 @@ static int __fimc_md_set_camclk(struct fimc_md *fmd,
         if (WARN_ON(pdata->clk_id >= FIMC_MAX_CAMCLKS) || fmd == NULL)
                 return -EINVAL;
 
-        if (s_info->clk_on == on)
-                return 0;
         camclk = &fmd->camclk[pdata->clk_id];
 
-        dbg("camclk %d, f: %lu, clk: %p, on: %d",
-            pdata->clk_id, pdata->clk_frequency, camclk, on);
+        dbg("camclk %d, f: %lu, use_count: %d, on: %d",
+            pdata->clk_id, pdata->clk_frequency, camclk->use_count, on);
 
         if (on) {
                 if (camclk->use_count > 0 &&
@@ -760,11 +765,9 @@ static int __fimc_md_set_camclk(struct fimc_md *fmd,
                         clk_set_rate(camclk->clock, pdata->clk_frequency);
                         camclk->frequency = pdata->clk_frequency;
                         ret = clk_enable(camclk->clock);
+                        dbg("Enabled camclk %d: f: %lu", pdata->clk_id,
+                            clk_get_rate(camclk->clock));
                 }
-                s_info->clk_on = 1;
-                dbg("Enabled camclk %d: f: %lu", pdata->clk_id,
-                    clk_get_rate(camclk->clock));
-
                 return ret;
         }
 
@@ -773,7 +776,6 @@ static int __fimc_md_set_camclk(struct fimc_md *fmd,
 
         if (--camclk->use_count == 0) {
                 clk_disable(camclk->clock);
-                s_info->clk_on = 0;
                 dbg("Disabled camclk %d", pdata->clk_id);
         }
         return ret;
@@ -789,8 +791,6 @@ static int __fimc_md_set_camclk(struct fimc_md *fmd,
  * devices to which sensors can be attached, either directly or through
  * the MIPI CSI receiver. The clock is allowed here to be used by
  * multiple sensors concurrently if they use same frequency.
- * The per sensor subdev clk_on attribute helps to synchronize accesses
- * to the sclk_cam clocks from the video and media device nodes.
  * This function should only be called when the graph mutex is held.
  */
 int fimc_md_set_camclk(struct v4l2_subdev *sd, bool on)
diff --git a/drivers/media/video/s5p-fimc/fimc-mdevice.h b/drivers/media/video/s5p-fimc/fimc-mdevice.h
index 3b8a3492a176..1f5dbaff5442 100644
--- a/drivers/media/video/s5p-fimc/fimc-mdevice.h
+++ b/drivers/media/video/s5p-fimc/fimc-mdevice.h
@@ -47,7 +47,6 @@ struct fimc_camclk_info {
  * @pdata: sensor's atrributes passed as media device's platform data
  * @subdev: image sensor v4l2 subdev
  * @host: fimc device the sensor is currently linked to
- * @clk_on: sclk_cam clock's state associated with this subdev
  *
  * This data structure applies to image sensor and the writeback subdevs.
  */
@@ -55,7 +54,6 @@ struct fimc_sensor_info {
         struct s5p_fimc_isp_info *pdata;
         struct v4l2_subdev *subdev;
         struct fimc_dev *host;
-        bool clk_on;
 };
 
 /**
diff --git a/drivers/media/video/s5p-mfc/s5p_mfc_dec.c b/drivers/media/video/s5p-mfc/s5p_mfc_dec.c
index 4dd32fc8fd82..feea867f318c 100644
--- a/drivers/media/video/s5p-mfc/s5p_mfc_dec.c
+++ b/drivers/media/video/s5p-mfc/s5p_mfc_dec.c
@@ -996,6 +996,7 @@ int s5p_mfc_dec_ctrls_setup(struct s5p_mfc_ctx *ctx)
 
         for (i = 0; i < NUM_CTRLS; i++) {
                 if (IS_MFC51_PRIV(controls[i].id)) {
+                        memset(&cfg, 0, sizeof(struct v4l2_ctrl_config));
                         cfg.ops = &s5p_mfc_dec_ctrl_ops;
                         cfg.id = controls[i].id;
                         cfg.min = controls[i].minimum;
diff --git a/drivers/media/video/s5p-mfc/s5p_mfc_enc.c b/drivers/media/video/s5p-mfc/s5p_mfc_enc.c
index 03d83340e7fb..158b78989b89 100644
--- a/drivers/media/video/s5p-mfc/s5p_mfc_enc.c
+++ b/drivers/media/video/s5p-mfc/s5p_mfc_enc.c
@@ -1773,6 +1773,7 @@ int s5p_mfc_enc_ctrls_setup(struct s5p_mfc_ctx *ctx)
         }
         for (i = 0; i < NUM_CTRLS; i++) {
                 if (IS_MFC51_PRIV(controls[i].id)) {
+                        memset(&cfg, 0, sizeof(struct v4l2_ctrl_config));
                         cfg.ops = &s5p_mfc_enc_ctrl_ops;
                         cfg.id = controls[i].id;
                         cfg.min = controls[i].minimum;
diff --git a/drivers/media/video/smiapp/smiapp-core.c b/drivers/media/video/smiapp/smiapp-core.c
index e8c93c89265a..9cf5bda35fbe 100644
--- a/drivers/media/video/smiapp/smiapp-core.c
+++ b/drivers/media/video/smiapp/smiapp-core.c
@@ -31,6 +31,7 @@
 #include <linux/device.h>
 #include <linux/gpio.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <linux/v4l2-mediabus.h>
diff --git a/drivers/media/video/v4l2-dev.c b/drivers/media/video/v4l2-dev.c
index 83dbb2ddff10..0cbada18f6f5 100644
--- a/drivers/media/video/v4l2-dev.c
+++ b/drivers/media/video/v4l2-dev.c
@@ -681,6 +681,7 @@ static void determine_valid_ioctls(struct video_device *vdev)
         SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
         SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
         SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
+        SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
         /* yes, really vidioc_subscribe_event */
         SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
         SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
diff --git a/drivers/media/video/zoran/zoran.h b/drivers/media/video/zoran/zoran.h
index d7166afc255e..ca2754a3cd63 100644
--- a/drivers/media/video/zoran/zoran.h
+++ b/drivers/media/video/zoran/zoran.h
@@ -172,8 +172,10 @@ struct zoran_jpg_settings {
         struct v4l2_jpegcompression jpg_comp;   /* JPEG-specific capture settings */
 };
 
+struct zoran_fh;
+
 struct zoran_mapping {
-        struct file *file;
+        struct zoran_fh *fh;
         int count;
 };
 
diff --git a/drivers/media/video/zoran/zoran_driver.c b/drivers/media/video/zoran/zoran_driver.c
index c57310931810..c6ccdeb6d8d6 100644
--- a/drivers/media/video/zoran/zoran_driver.c
+++ b/drivers/media/video/zoran/zoran_driver.c
@@ -2811,7 +2811,7 @@ static void
 zoran_vm_close (struct vm_area_struct *vma)
 {
         struct zoran_mapping *map = vma->vm_private_data;
-        struct zoran_fh *fh = map->file->private_data;
+        struct zoran_fh *fh = map->fh;
         struct zoran *zr = fh->zr;
         int i;
 
@@ -2938,7 +2938,7 @@ zoran_mmap (struct file           *file,
                 res = -ENOMEM;
                 goto mmap_unlock_and_return;
         }
-        map->file = file;
+        map->fh = fh;
         map->count = 1;
 
         vma->vm_ops = &zoran_vm_ops;
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index e129c820df7d..92144ed1ad46 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -286,6 +286,7 @@ config TWL6040_CORE
         depends on I2C=y && GENERIC_HARDIRQS
         select MFD_CORE
         select REGMAP_I2C
+        select IRQ_DOMAIN
         default n
         help
           Say yes here if you want support for Texas Instruments TWL6040 audio
diff --git a/drivers/mfd/ab5500-core.h b/drivers/mfd/ab5500-core.h
deleted file mode 100644
index 63b30b17e4f3..000000000000
--- a/drivers/mfd/ab5500-core.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (C) 2011 ST-Ericsson
- * License terms: GNU General Public License (GPL) version 2
- * Shared definitions and data structures for the AB5500 MFD driver
- */
-
-/* Read/write operation values. */
-#define AB5500_PERM_RD (0x01)
-#define AB5500_PERM_WR (0x02)
-
-/* Read/write permissions. */
-#define AB5500_PERM_RO (AB5500_PERM_RD)
-#define AB5500_PERM_RW (AB5500_PERM_RD | AB5500_PERM_WR)
-
-#define AB5500_MASK_BASE (0x60)
-#define AB5500_MASK_END (0x79)
-#define AB5500_CHIP_ID (0x20)
-
-/**
- * struct ab5500_reg_range
- * @first: the first address of the range
- * @last: the last address of the range
- * @perm: access permissions for the range
- */
-struct ab5500_reg_range {
-        u8 first;
-        u8 last;
-        u8 perm;
-};
-
-/**
- * struct ab5500_i2c_ranges
- * @count: the number of ranges in the list
- * @range: the list of register ranges
- */
-struct ab5500_i2c_ranges {
-        u8 nranges;
-        u8 bankid;
-        const struct ab5500_reg_range *range;
-};
-
-/**
- * struct ab5500_i2c_banks
- * @count: the number of ranges in the list
- * @range: the list of register ranges
- */
-struct ab5500_i2c_banks {
-        u8 nbanks;
-        const struct ab5500_i2c_ranges *bank;
-};
-
-/**
- * struct ab5500_bank
- * @slave_addr: I2C slave_addr found in AB5500 specification
- * @name: Documentation name of the bank. For reference
- */
-struct ab5500_bank {
-        u8 slave_addr;
-        const char *name;
-};
-
-static const struct ab5500_bank bankinfo[AB5500_NUM_BANKS] = {
-        [AB5500_BANK_VIT_IO_I2C_CLK_TST_OTP] = {
-                AB5500_ADDR_VIT_IO_I2C_CLK_TST_OTP, "VIT_IO_I2C_CLK_TST_OTP"},
-        [AB5500_BANK_VDDDIG_IO_I2C_CLK_TST] = {
-                AB5500_ADDR_VDDDIG_IO_I2C_CLK_TST, "VDDDIG_IO_I2C_CLK_TST"},
-        [AB5500_BANK_VDENC] = {AB5500_ADDR_VDENC, "VDENC"},
-        [AB5500_BANK_SIM_USBSIM] = {AB5500_ADDR_SIM_USBSIM, "SIM_USBSIM"},
-        [AB5500_BANK_LED] = {AB5500_ADDR_LED, "LED"},
-        [AB5500_BANK_ADC] = {AB5500_ADDR_ADC, "ADC"},
-        [AB5500_BANK_RTC] = {AB5500_ADDR_RTC, "RTC"},
-        [AB5500_BANK_STARTUP] = {AB5500_ADDR_STARTUP, "STARTUP"},
-        [AB5500_BANK_DBI_ECI] = {AB5500_ADDR_DBI_ECI, "DBI-ECI"},
-        [AB5500_BANK_CHG] = {AB5500_ADDR_CHG, "CHG"},
-        [AB5500_BANK_FG_BATTCOM_ACC] = {
-                AB5500_ADDR_FG_BATTCOM_ACC, "FG_BATCOM_ACC"},
-        [AB5500_BANK_USB] = {AB5500_ADDR_USB, "USB"},
-        [AB5500_BANK_IT] = {AB5500_ADDR_IT, "IT"},
-        [AB5500_BANK_VIBRA] = {AB5500_ADDR_VIBRA, "VIBRA"},
-        [AB5500_BANK_AUDIO_HEADSETUSB] = {
-                AB5500_ADDR_AUDIO_HEADSETUSB, "AUDIO_HEADSETUSB"},
-};
-
-int ab5500_get_register_interruptible_raw(struct ab5500 *ab, u8 bank, u8 reg,
-        u8 *value);
-int ab5500_mask_and_set_register_interruptible_raw(struct ab5500 *ab, u8 bank,
-        u8 reg, u8 bitmask, u8 bitvalues);
diff --git a/drivers/mfd/mc13xxx-spi.c b/drivers/mfd/mc13xxx-spi.c
index 3fcdab3eb8eb..03df422feb76 100644
--- a/drivers/mfd/mc13xxx-spi.c
+++ b/drivers/mfd/mc13xxx-spi.c
@@ -49,10 +49,72 @@ static struct regmap_config mc13xxx_regmap_spi_config = {
         .reg_bits = 7,
         .pad_bits = 1,
         .val_bits = 24,
+        .write_flag_mask = 0x80,
 
         .max_register = MC13XXX_NUMREGS,
 
         .cache_type = REGCACHE_NONE,
+        .use_single_rw = 1,
+};
+
+static int mc13xxx_spi_read(void *context, const void *reg, size_t reg_size,
+                                void *val, size_t val_size)
+{
+        unsigned char w[4] = { *((unsigned char *) reg), 0, 0, 0};
+        unsigned char r[4];
+        unsigned char *p = val;
+        struct device *dev = context;
+        struct spi_device *spi = to_spi_device(dev);
+        struct spi_transfer t = {
+                .tx_buf = w,
+                .rx_buf = r,
+                .len = 4,
+        };
+
+        struct spi_message m;
+        int ret;
+
+        if (val_size != 3 || reg_size != 1)
+                return -ENOTSUPP;
+
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+        ret = spi_sync(spi, &m);
+
+        memcpy(p, &r[1], 3);
+
+        return ret;
+}
+
+static int mc13xxx_spi_write(void *context, const void *data, size_t count)
+{
+        struct device *dev = context;
+        struct spi_device *spi = to_spi_device(dev);
+
+        if (count != 4)
+                return -ENOTSUPP;
+
+        return spi_write(spi, data, count);
+}
+
+/*
+ * We cannot use regmap-spi generic bus implementation here.
+ * The MC13783 chip will get corrupted if CS signal is deasserted
+ * and on i.Mx31 SoC (the target SoC for MC13783 PMIC) the SPI controller
+ * has the following errata (DSPhl22960):
+ * "The CSPI negates SS when the FIFO becomes empty with
+ * SSCTL= 0. Software cannot guarantee that the FIFO will not
+ * drain because of higher priority interrupts and the
+ * non-realtime characteristics of the operating system. As a
+ * result, the SS will negate before all of the data has been
+ * transferred to/from the peripheral."
+ * We workaround this by accessing the SPI controller with a
+ * single transfert.
+ */
+
+static struct regmap_bus regmap_mc13xxx_bus = {
+        .write = mc13xxx_spi_write,
+        .read = mc13xxx_spi_read,
 };
 
 static int mc13xxx_spi_probe(struct spi_device *spi)
@@ -73,12 +135,13 @@ static int mc13xxx_spi_probe(struct spi_device *spi)
 
         dev_set_drvdata(&spi->dev, mc13xxx);
         spi->mode = SPI_MODE_0 | SPI_CS_HIGH;
-        spi->bits_per_word = 32;
 
         mc13xxx->dev = &spi->dev;
         mutex_init(&mc13xxx->lock);
 
-        mc13xxx->regmap = regmap_init_spi(spi, &mc13xxx_regmap_spi_config);
+        mc13xxx->regmap = regmap_init(&spi->dev, &regmap_mc13xxx_bus, &spi->dev,
+                                        &mc13xxx_regmap_spi_config);
+
         if (IS_ERR(mc13xxx->regmap)) {
                 ret = PTR_ERR(mc13xxx->regmap);
                 dev_err(mc13xxx->dev, "Failed to initialize register map: %d\n",
diff --git a/drivers/mfd/omap-usb-host.c b/drivers/mfd/omap-usb-host.c
index 7e96bb229724..41088ecbb2a9 100644
--- a/drivers/mfd/omap-usb-host.c
+++ b/drivers/mfd/omap-usb-host.c
@@ -25,6 +25,7 @@
 #include <linux/clk.h>
 #include <linux/dma-mapping.h>
 #include <linux/spinlock.h>
+#include <linux/gpio.h>
 #include <plat/cpu.h>
 #include <plat/usb.h>
 #include <linux/pm_runtime.h>
@@ -500,8 +501,21 @@ static void omap_usbhs_init(struct device *dev)
         dev_dbg(dev, "starting TI HSUSB Controller\n");
 
         pm_runtime_get_sync(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_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_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);
+        }
+
+        spin_lock_irqsave(&omap->lock, flags);
         omap->usbhs_rev = usbhs_read(omap->uhh_base, OMAP_UHH_REVISION);
         dev_dbg(dev, "OMAP UHH_REVISION 0x%x\n", omap->usbhs_rev);
 
@@ -581,9 +595,39 @@ static void omap_usbhs_init(struct device *dev)
         }
 
         spin_unlock_irqrestore(&omap->lock, flags);
+
+        if (pdata->ehci_data->phy_reset) {
+                /* Hold the PHY in RESET for enough time till
+                 * PHY is settled and ready
+                 */
+                udelay(10);
+
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[0]))
+                        gpio_set_value_cansleep
+                                (pdata->ehci_data->reset_gpio_port[0], 1);
+
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[1]))
+                        gpio_set_value_cansleep
+                                (pdata->ehci_data->reset_gpio_port[1], 1);
+        }
+
         pm_runtime_put_sync(dev);
 }
 
+static void omap_usbhs_deinit(struct device *dev)
+{
+        struct usbhs_hcd_omap           *omap = dev_get_drvdata(dev);
+        struct usbhs_omap_platform_data *pdata = &omap->platdata;
+
+        if (pdata->ehci_data->phy_reset) {
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[0]))
+                        gpio_free(pdata->ehci_data->reset_gpio_port[0]);
+
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[1]))
+                        gpio_free(pdata->ehci_data->reset_gpio_port[1]);
+        }
+}
+
 
 /**
  * usbhs_omap_probe - initialize TI-based HCDs
@@ -767,6 +811,7 @@ static int __devinit usbhs_omap_probe(struct platform_device *pdev)
         goto end_probe;
 
 err_alloc:
+        omap_usbhs_deinit(&pdev->dev);
         iounmap(omap->tll_base);
 
 err_tll:
@@ -818,6 +863,7 @@ static int __devexit usbhs_omap_remove(struct platform_device *pdev)
 {
         struct usbhs_hcd_omap *omap = platform_get_drvdata(pdev);
 
+        omap_usbhs_deinit(&pdev->dev);
         iounmap(omap->tll_base);
         iounmap(omap->uhh_base);
         clk_put(omap->init_60m_fclk);
diff --git a/drivers/mfd/palmas.c b/drivers/mfd/palmas.c
index 00c0aba7eba0..c4a69f193a1d 100644
--- a/drivers/mfd/palmas.c
+++ b/drivers/mfd/palmas.c
@@ -356,7 +356,14 @@ static int __devinit palmas_i2c_probe(struct i2c_client *i2c,
                 }
         }
 
-        ret = regmap_add_irq_chip(palmas->regmap[1], palmas->irq,
+        /* Change IRQ into clear on read mode for efficiency */
+        slave = PALMAS_BASE_TO_SLAVE(PALMAS_INTERRUPT_BASE);
+        addr = PALMAS_BASE_TO_REG(PALMAS_INTERRUPT_BASE, PALMAS_INT_CTRL);
+        reg = PALMAS_INT_CTRL_INT_CLEAR;
+
+        regmap_write(palmas->regmap[slave], addr, reg);
+
+        ret = regmap_add_irq_chip(palmas->regmap[slave], palmas->irq,
                         IRQF_ONESHOT | IRQF_TRIGGER_LOW, -1, &palmas_irq_chip,
                         &palmas->irq_data);
         if (ret < 0)
@@ -441,6 +448,9 @@ static int __devinit palmas_i2c_probe(struct i2c_client *i2c,
                 goto err;
         }
 
+        children[PALMAS_PMIC_ID].platform_data = pdata->pmic_pdata;
+        children[PALMAS_PMIC_ID].pdata_size = sizeof(*pdata->pmic_pdata);
+
         ret = mfd_add_devices(palmas->dev, -1,
                               children, ARRAY_SIZE(palmas_children),
                               NULL, regmap_irq_chip_get_base(palmas->irq_data));
@@ -472,6 +482,7 @@ static const struct i2c_device_id palmas_i2c_id[] = {
         { "twl6035", },
         { "twl6037", },
         { "tps65913", },
+        { /* end */ }
 };
 MODULE_DEVICE_TABLE(i2c, palmas_i2c_id);
 
diff --git a/drivers/mfd/tps65217.c b/drivers/mfd/tps65217.c
index db194e433c08..61c097a98f5d 100644
--- a/drivers/mfd/tps65217.c
+++ b/drivers/mfd/tps65217.c
@@ -24,6 +24,7 @@
 #include <linux/slab.h>
 #include <linux/regmap.h>
 #include <linux/err.h>
+#include <linux/regulator/of_regulator.h>
 
 #include <linux/mfd/core.h>
 #include <linux/mfd/tps65217.h>
@@ -132,6 +133,61 @@ int tps65217_clear_bits(struct tps65217 *tps, unsigned int reg,
 }
 EXPORT_SYMBOL_GPL(tps65217_clear_bits);
 
+#ifdef CONFIG_OF
+static struct of_regulator_match reg_matches[] = {
+        { .name = "dcdc1", .driver_data = (void *)TPS65217_DCDC_1 },
+        { .name = "dcdc2", .driver_data = (void *)TPS65217_DCDC_2 },
+        { .name = "dcdc3", .driver_data = (void *)TPS65217_DCDC_3 },
+        { .name = "ldo1", .driver_data = (void *)TPS65217_LDO_1 },
+        { .name = "ldo2", .driver_data = (void *)TPS65217_LDO_2 },
+        { .name = "ldo3", .driver_data = (void *)TPS65217_LDO_3 },
+        { .name = "ldo4", .driver_data = (void *)TPS65217_LDO_4 },
+};
+
+static struct tps65217_board *tps65217_parse_dt(struct i2c_client *client)
+{
+        struct device_node *node = client->dev.of_node;
+        struct tps65217_board *pdata;
+        struct device_node *regs;
+        int count = ARRAY_SIZE(reg_matches);
+        int ret, i;
+
+        regs = of_find_node_by_name(node, "regulators");
+        if (!regs)
+                return NULL;
+
+        ret = of_regulator_match(&client->dev, regs, reg_matches, count);
+        of_node_put(regs);
+        if ((ret < 0) || (ret > count))
+                return NULL;
+
+        count = ret;
+        pdata = devm_kzalloc(&client->dev, count * sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL;
+
+        for (i = 0; i < count; i++) {
+                if (!reg_matches[i].init_data || !reg_matches[i].of_node)
+                        continue;
+
+                pdata->tps65217_init_data[i] = reg_matches[i].init_data;
+                pdata->of_node[i] = reg_matches[i].of_node;
+        }
+
+        return pdata;
+}
+
+static struct of_device_id tps65217_of_match[] = {
+        { .compatible = "ti,tps65217", },
+        { },
+};
+#else
+static struct tps65217_board *tps65217_parse_dt(struct i2c_client *client)
+{
+        return NULL;
+}
+#endif
+
 static struct regmap_config tps65217_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
@@ -141,10 +197,14 @@ static int __devinit tps65217_probe(struct i2c_client *client,
                                 const struct i2c_device_id *ids)
 {
         struct tps65217 *tps;
+        struct regulator_init_data *reg_data;
         struct tps65217_board *pdata = client->dev.platform_data;
         int i, ret;
         unsigned int version;
 
+        if (!pdata && client->dev.of_node)
+                pdata = tps65217_parse_dt(client);
+
         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
         if (!tps)
                 return -ENOMEM;
@@ -182,8 +242,9 @@ static int __devinit tps65217_probe(struct i2c_client *client,
                 }
 
                 pdev->dev.parent = tps->dev;
-                platform_device_add_data(pdev, &pdata->tps65217_init_data[i],
-                                        sizeof(pdata->tps65217_init_data[i]));
+                pdev->dev.of_node = pdata->of_node[i];
+                reg_data = pdata->tps65217_init_data[i];
+                platform_device_add_data(pdev, reg_data, sizeof(*reg_data));
                 tps->regulator_pdev[i] = pdev;
 
                 platform_device_add(pdev);
@@ -212,6 +273,8 @@ MODULE_DEVICE_TABLE(i2c, tps65217_id_table);
 static struct i2c_driver tps65217_driver = {
         .driver         = {
                 .name   = "tps65217",
+                .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(tps65217_of_match),
         },
         .id_table       = tps65217_id_table,
         .probe          = tps65217_probe,
diff --git a/drivers/misc/mei/main.c b/drivers/misc/mei/main.c
index 7de13891e49e..783fcd7365bc 100644
--- a/drivers/misc/mei/main.c
+++ b/drivers/misc/mei/main.c
@@ -1147,7 +1147,7 @@ static int mei_pci_resume(struct device *device)
                 err = request_threaded_irq(pdev->irq,
                         NULL,
                         mei_interrupt_thread_handler,
-                        0, mei_driver_name, dev);
+                        IRQF_ONESHOT, mei_driver_name, dev);
         else
                 err = request_threaded_irq(pdev->irq,
                         mei_interrupt_quick_handler,
diff --git a/drivers/misc/sgi-xp/xpc_uv.c b/drivers/misc/sgi-xp/xpc_uv.c
index 17bbacb1b4b1..87b251ab6ec5 100644
--- a/drivers/misc/sgi-xp/xpc_uv.c
+++ b/drivers/misc/sgi-xp/xpc_uv.c
@@ -452,9 +452,9 @@ xpc_handle_activate_mq_msg_uv(struct xpc_partition *part,
 
                 if (msg->activate_gru_mq_desc_gpa !=
                     part_uv->activate_gru_mq_desc_gpa) {
-                        spin_lock_irqsave(&part_uv->flags_lock, irq_flags);
+                        spin_lock(&part_uv->flags_lock);
                         part_uv->flags &= ~XPC_P_CACHED_ACTIVATE_GRU_MQ_DESC_UV;
-                        spin_unlock_irqrestore(&part_uv->flags_lock, irq_flags);
+                        spin_unlock(&part_uv->flags_lock);
                         part_uv->activate_gru_mq_desc_gpa =
                             msg->activate_gru_mq_desc_gpa;
                 }
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 276d21ce6bc1..f1c84decb192 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -850,9 +850,7 @@ out:
                 goto retry;
         if (!err)
                 mmc_blk_reset_success(md, type);
-        spin_lock_irq(&md->lock);
-        __blk_end_request(req, err, blk_rq_bytes(req));
-        spin_unlock_irq(&md->lock);
+        blk_end_request(req, err, blk_rq_bytes(req));
 
         return err ? 0 : 1;
 }
@@ -934,9 +932,7 @@ out_retry:
         if (!err)
                 mmc_blk_reset_success(md, type);
 out:
-        spin_lock_irq(&md->lock);
-        __blk_end_request(req, err, blk_rq_bytes(req));
-        spin_unlock_irq(&md->lock);
+        blk_end_request(req, err, blk_rq_bytes(req));
 
         return err ? 0 : 1;
 }
@@ -951,9 +947,7 @@ static int mmc_blk_issue_flush(struct mmc_queue *mq, struct request *req)
         if (ret)
                 ret = -EIO;
 
-        spin_lock_irq(&md->lock);
-        __blk_end_request_all(req, ret);
-        spin_unlock_irq(&md->lock);
+        blk_end_request_all(req, ret);
 
         return ret ? 0 : 1;
 }
@@ -1252,14 +1246,10 @@ static int mmc_blk_cmd_err(struct mmc_blk_data *md, struct mmc_card *card,
 
                 blocks = mmc_sd_num_wr_blocks(card);
                 if (blocks != (u32)-1) {
-                        spin_lock_irq(&md->lock);
-                        ret = __blk_end_request(req, 0, blocks << 9);
-                        spin_unlock_irq(&md->lock);
+                        ret = blk_end_request(req, 0, blocks << 9);
                 }
         } else {
-                spin_lock_irq(&md->lock);
-                ret = __blk_end_request(req, 0, brq->data.bytes_xfered);
-                spin_unlock_irq(&md->lock);
+                ret = blk_end_request(req, 0, brq->data.bytes_xfered);
         }
         return ret;
 }
@@ -1311,10 +1301,8 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
                          * A block was successfully transferred.
                          */
                         mmc_blk_reset_success(md, type);
-                        spin_lock_irq(&md->lock);
-                        ret = __blk_end_request(req, 0,
+                        ret = blk_end_request(req, 0,
                                                 brq->data.bytes_xfered);
-                        spin_unlock_irq(&md->lock);
                         /*
                          * If the blk_end_request function returns non-zero even
                          * though all data has been transferred and no errors
@@ -1364,10 +1352,8 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
                          * time, so we only reach here after trying to
                          * read a single sector.
                          */
-                        spin_lock_irq(&md->lock);
-                        ret = __blk_end_request(req, -EIO,
+                        ret = blk_end_request(req, -EIO,
                                                 brq->data.blksz);
-                        spin_unlock_irq(&md->lock);
                         if (!ret)
                                 goto start_new_req;
                         break;
@@ -1388,12 +1374,10 @@ static int mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *rqc)
         return 1;
 
  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);
+                ret = blk_end_request(req, -EIO, blk_rq_cur_bytes(req));
 
  start_new_req:
         if (rqc) {
@@ -1417,9 +1401,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
         ret = mmc_blk_part_switch(card, md);
         if (ret) {
                 if (req) {
-                        spin_lock_irq(&md->lock);
-                        __blk_end_request_all(req, -EIO);
-                        spin_unlock_irq(&md->lock);
+                        blk_end_request_all(req, -EIO);
                 }
                 ret = 0;
                 goto out;
diff --git a/drivers/mmc/core/Makefile b/drivers/mmc/core/Makefile
index dca4428380f1..38ed210ce2f3 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 cd-gpio.o
+                                   quirks.o slot-gpio.o
 
 mmc_core-$(CONFIG_DEBUG_FS)     += debugfs.o
diff --git a/drivers/mmc/core/cd-gpio.c b/drivers/mmc/core/cd-gpio.c
deleted file mode 100644
index f13e38deceac..000000000000
--- a/drivers/mmc/core/cd-gpio.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * 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/cd-gpio.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)
-{
-        size_t len = strlen(dev_name(host->parent)) + 4;
-        struct mmc_cd_gpio *cd;
-        int irq = gpio_to_irq(gpio);
-        int ret;
-
-        if (irq < 0)
-                return irq;
-
-        cd = kmalloc(sizeof(*cd) + len, GFP_KERNEL);
-        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,
-                                   IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                                   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;
-
-        if (!cd)
-                return;
-
-        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 0b6141d29dbd..8ac5246e2ab2 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -404,6 +404,7 @@ int mmc_interrupt_hpi(struct mmc_card *card)
 {
         int err;
         u32 status;
+        unsigned long prg_wait;
 
         BUG_ON(!card);
 
@@ -419,30 +420,38 @@ int mmc_interrupt_hpi(struct mmc_card *card)
                 goto out;
         }
 
-        /*
-         * If the card status is in PRG-state, we can send the HPI command.
-         */
-        if (R1_CURRENT_STATE(status) == R1_STATE_PRG) {
-                do {
-                        /*
-                         * We don't know when the HPI command will finish
-                         * processing, so we need to resend HPI until out
-                         * of prg-state, and keep checking the card status
-                         * with SEND_STATUS.  If a timeout error occurs when
-                         * sending the HPI command, we are already out of
-                         * prg-state.
-                         */
-                        err = mmc_send_hpi_cmd(card, &status);
-                        if (err)
-                                pr_debug("%s: abort HPI (%d error)\n",
-                                         mmc_hostname(card->host), err);
+        switch (R1_CURRENT_STATE(status)) {
+        case R1_STATE_IDLE:
+        case R1_STATE_READY:
+        case R1_STATE_STBY:
+                /*
+                 * In idle states, HPI is not needed and the caller
+                 * can issue the next intended command immediately
+                 */
+                goto out;
+        case R1_STATE_PRG:
+                break;
+        default:
+                /* In all other states, it's illegal to issue HPI */
+                pr_debug("%s: HPI cannot be sent. Card state=%d\n",
+                        mmc_hostname(card->host), R1_CURRENT_STATE(status));
+                err = -EINVAL;
+                goto out;
+        }
 
-                        err = mmc_send_status(card, &status);
-                        if (err)
-                                break;
-                } while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
-        } else
-                pr_debug("%s: Left prg-state\n", mmc_hostname(card->host));
+        err = mmc_send_hpi_cmd(card, &status);
+        if (err)
+                goto out;
+
+        prg_wait = jiffies + msecs_to_jiffies(card->ext_csd.out_of_int_time);
+        do {
+                err = mmc_send_status(card, &status);
+
+                if (!err && R1_CURRENT_STATE(status) == R1_STATE_TRAN)
+                        break;
+                if (time_after(jiffies, prg_wait))
+                        err = -ETIMEDOUT;
+        } while (!err);
 
 out:
         mmc_release_host(card->host);
@@ -941,7 +950,7 @@ int mmc_regulator_get_ocrmask(struct regulator *supply)
 
         return result;
 }
-EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
+EXPORT_SYMBOL_GPL(mmc_regulator_get_ocrmask);
 
 /**
  * mmc_regulator_set_ocr - set regulator to match host->ios voltage
@@ -1011,7 +1020,30 @@ int mmc_regulator_set_ocr(struct mmc_host *mmc,
                         "could not set regulator OCR (%d)\n", result);
         return result;
 }
-EXPORT_SYMBOL(mmc_regulator_set_ocr);
+EXPORT_SYMBOL_GPL(mmc_regulator_set_ocr);
+
+int mmc_regulator_get_supply(struct mmc_host *mmc)
+{
+        struct device *dev = mmc_dev(mmc);
+        struct regulator *supply;
+        int ret;
+
+        supply = devm_regulator_get(dev, "vmmc");
+        mmc->supply.vmmc = supply;
+        mmc->supply.vqmmc = devm_regulator_get(dev, "vqmmc");
+
+        if (IS_ERR(supply))
+                return PTR_ERR(supply);
+
+        ret = mmc_regulator_get_ocrmask(supply);
+        if (ret > 0)
+                mmc->ocr_avail = ret;
+        else
+                dev_warn(mmc_dev(mmc), "Failed getting OCR mask: %d\n", ret);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mmc_regulator_get_supply);
 
 #endif /* CONFIG_REGULATOR */
 
@@ -1180,6 +1212,9 @@ static void mmc_power_up(struct mmc_host *host)
         host->ios.timing = MMC_TIMING_LEGACY;
         mmc_set_ios(host);
 
+        /* Set signal voltage to 3.3V */
+        mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, false);
+
         /*
          * This delay should be sufficient to allow the power supply
          * to reach the minimum voltage.
@@ -1931,9 +1966,6 @@ static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
          */
         mmc_hw_reset_for_init(host);
 
-        /* Initialization should be done at 3.3 V I/O voltage. */
-        mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
-
         /*
          * sdio_reset sends CMD52 to reset card.  Since we do not know
          * if the card is being re-initialized, just send it.  CMD52
@@ -2075,6 +2107,7 @@ void mmc_rescan(struct work_struct *work)
 void mmc_start_host(struct mmc_host *host)
 {
         host->f_init = max(freqs[0], host->f_min);
+        host->rescan_disable = 0;
         mmc_power_up(host);
         mmc_detect_change(host, 0);
 }
@@ -2088,6 +2121,7 @@ void mmc_stop_host(struct mmc_host *host)
         spin_unlock_irqrestore(&host->lock, flags);
 #endif
 
+        host->rescan_disable = 1;
         cancel_delayed_work_sync(&host->detect);
         mmc_flush_scheduled_work();
 
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index 91c84c7a1829..597f189b4427 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -32,6 +32,7 @@
 static void mmc_host_classdev_release(struct device *dev)
 {
         struct mmc_host *host = cls_dev_to_mmc_host(dev);
+        mutex_destroy(&host->slot.lock);
         kfree(host);
 }
 
@@ -312,6 +313,8 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
         if (!host)
                 return NULL;
 
+        /* scanning will be enabled when we're ready */
+        host->rescan_disable = 1;
         spin_lock(&mmc_host_lock);
         err = idr_get_new(&mmc_host_idr, host, &host->index);
         spin_unlock(&mmc_host_lock);
@@ -327,6 +330,9 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
 
         mmc_host_clk_init(host);
 
+        mutex_init(&host->slot.lock);
+        host->slot.cd_irq = -EINVAL;
+
         spin_lock_init(&host->lock);
         init_waitqueue_head(&host->wq);
         INIT_DELAYED_WORK(&host->detect, mmc_rescan);
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 258b203397aa..396b25891bb9 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -717,10 +717,6 @@ static int mmc_select_powerclass(struct mmc_card *card,
                                  card->ext_csd.generic_cmd6_time);
         }
 
-        if (err)
-                pr_err("%s: power class selection for ext_csd_bus_width %d"
-                       " failed\n", mmc_hostname(card->host), bus_width);
-
         return err;
 }
 
@@ -822,9 +818,6 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
         if (!mmc_host_is_spi(host))
                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
 
-        /* Initialization should be done at 3.3 V I/O voltage. */
-        mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
-
         /*
          * Since we're changing the OCR value, we seem to
          * need to tell some cards to go back to the idle
@@ -1104,7 +1097,9 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                                 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
                 err = mmc_select_powerclass(card, ext_csd_bits, ext_csd);
                 if (err)
-                        goto err;
+                        pr_warning("%s: power class selection to bus width %d"
+                                   " failed\n", mmc_hostname(card->host),
+                                   1 << bus_width);
         }
 
         /*
@@ -1136,7 +1131,10 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                         err = mmc_select_powerclass(card, ext_csd_bits[idx][0],
                                                     ext_csd);
                         if (err)
-                                goto err;
+                                pr_warning("%s: power class selection to "
+                                           "bus width %d failed\n",
+                                           mmc_hostname(card->host),
+                                           1 << bus_width);
 
                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                          EXT_CSD_BUS_WIDTH,
@@ -1164,7 +1162,10 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                         err = mmc_select_powerclass(card, ext_csd_bits[idx][1],
                                                     ext_csd);
                         if (err)
-                                goto err;
+                                pr_warning("%s: power class selection to "
+                                           "bus width %d ddr %d failed\n",
+                                           mmc_hostname(card->host),
+                                           1 << bus_width, ddr);
 
                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                          EXT_CSD_BUS_WIDTH,
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 69370f494e05..0ed2cc5f35b6 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -569,7 +569,6 @@ int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status)
 
         cmd.opcode = opcode;
         cmd.arg = card->rca << 16 | 1;
-        cmd.cmd_timeout_ms = card->ext_csd.out_of_int_time;
 
         err = mmc_wait_for_cmd(card->host, &cmd, 0);
         if (err) {
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index b2b43f624b9e..74972c241dff 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -244,7 +244,7 @@ static int mmc_read_ssr(struct mmc_card *card)
          * bitfield positions accordingly.
          */
         au = UNSTUFF_BITS(ssr, 428 - 384, 4);
-        if (au > 0 || au <= 9) {
+        if (au > 0 && au <= 9) {
                 card->ssr.au = 1 << (au + 4);
                 es = UNSTUFF_BITS(ssr, 408 - 384, 16);
                 et = UNSTUFF_BITS(ssr, 402 - 384, 6);
@@ -290,8 +290,12 @@ static int mmc_read_switch(struct mmc_card *card)
                 return -ENOMEM;
         }
 
-        /* Find out the supported Bus Speed Modes. */
-        err = mmc_sd_switch(card, 0, 0, 1, status);
+        /*
+         * Find out the card's support bits with a mode 0 operation.
+         * The argument does not matter, as the support bits do not
+         * change with the arguments.
+         */
+        err = mmc_sd_switch(card, 0, 0, 0, status);
         if (err) {
                 /*
                  * If the host or the card can't do the switch,
@@ -312,46 +316,8 @@ static int mmc_read_switch(struct mmc_card *card)
 
         if (card->scr.sda_spec3) {
                 card->sw_caps.sd3_bus_mode = status[13];
-
-                /* Find out Driver Strengths supported by the card */
-                err = mmc_sd_switch(card, 0, 2, 1, status);
-                if (err) {
-                        /*
-                         * If the host or the card can't do the switch,
-                         * fail more gracefully.
-                         */
-                        if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
-                                goto out;
-
-                        pr_warning("%s: problem reading "
-                                "Driver Strength.\n",
-                                mmc_hostname(card->host));
-                        err = 0;
-
-                        goto out;
-                }
-
+                /* Driver Strengths supported by the card */
                 card->sw_caps.sd3_drv_type = status[9];
-
-                /* Find out Current Limits supported by the card */
-                err = mmc_sd_switch(card, 0, 3, 1, status);
-                if (err) {
-                        /*
-                         * If the host or the card can't do the switch,
-                         * fail more gracefully.
-                         */
-                        if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
-                                goto out;
-
-                        pr_warning("%s: problem reading "
-                                "Current Limit.\n",
-                                mmc_hostname(card->host));
-                        err = 0;
-
-                        goto out;
-                }
-
-                card->sw_caps.sd3_curr_limit = status[7];
         }
 
 out:
@@ -551,60 +517,80 @@ static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
         return 0;
 }
 
+/* Get host's max current setting at its current voltage */
+static u32 sd_get_host_max_current(struct mmc_host *host)
+{
+        u32 voltage, max_current;
+
+        voltage = 1 << host->ios.vdd;
+        switch (voltage) {
+        case MMC_VDD_165_195:
+                max_current = host->max_current_180;
+                break;
+        case MMC_VDD_29_30:
+        case MMC_VDD_30_31:
+                max_current = host->max_current_300;
+                break;
+        case MMC_VDD_32_33:
+        case MMC_VDD_33_34:
+                max_current = host->max_current_330;
+                break;
+        default:
+                max_current = 0;
+        }
+
+        return max_current;
+}
+
 static int sd_set_current_limit(struct mmc_card *card, u8 *status)
 {
-        int current_limit = 0;
+        int current_limit = SD_SET_CURRENT_NO_CHANGE;
         int err;
+        u32 max_current;
 
         /*
          * Current limit switch is only defined for SDR50, SDR104, and DDR50
-         * bus speed modes. For other bus speed modes, we set the default
-         * current limit of 200mA.
+         * bus speed modes. For other bus speed modes, we do not change the
+         * current limit.
          */
-        if ((card->sd_bus_speed == UHS_SDR50_BUS_SPEED) ||
-            (card->sd_bus_speed == UHS_SDR104_BUS_SPEED) ||
-            (card->sd_bus_speed == UHS_DDR50_BUS_SPEED)) {
-                if (card->host->caps & MMC_CAP_MAX_CURRENT_800) {
-                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
-                                current_limit = SD_SET_CURRENT_LIMIT_800;
-                        else if (card->sw_caps.sd3_curr_limit &
-                                        SD_MAX_CURRENT_600)
-                                current_limit = SD_SET_CURRENT_LIMIT_600;
-                        else if (card->sw_caps.sd3_curr_limit &
-                                        SD_MAX_CURRENT_400)
-                                current_limit = SD_SET_CURRENT_LIMIT_400;
-                        else if (card->sw_caps.sd3_curr_limit &
-                                        SD_MAX_CURRENT_200)
-                                current_limit = SD_SET_CURRENT_LIMIT_200;
-                } else if (card->host->caps & MMC_CAP_MAX_CURRENT_600) {
-                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
-                                current_limit = SD_SET_CURRENT_LIMIT_600;
-                        else if (card->sw_caps.sd3_curr_limit &
-                                        SD_MAX_CURRENT_400)
-                                current_limit = SD_SET_CURRENT_LIMIT_400;
-                        else if (card->sw_caps.sd3_curr_limit &
-                                        SD_MAX_CURRENT_200)
-                                current_limit = SD_SET_CURRENT_LIMIT_200;
-                } else if (card->host->caps & MMC_CAP_MAX_CURRENT_400) {
-                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
-                                current_limit = SD_SET_CURRENT_LIMIT_400;
-                        else if (card->sw_caps.sd3_curr_limit &
-                                        SD_MAX_CURRENT_200)
-                                current_limit = SD_SET_CURRENT_LIMIT_200;
-                } else if (card->host->caps & MMC_CAP_MAX_CURRENT_200) {
-                        if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
-                                current_limit = SD_SET_CURRENT_LIMIT_200;
-                }
-        } else
+        if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
+            (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
+            (card->sd_bus_speed != UHS_DDR50_BUS_SPEED))
+                return 0;
+
+        /*
+         * Host has different current capabilities when operating at
+         * different voltages, so find out its max current first.
+         */
+        max_current = sd_get_host_max_current(card->host);
+
+        /*
+         * We only check host's capability here, if we set a limit that is
+         * higher than the card's maximum current, the card will be using its
+         * maximum current, e.g. if the card's maximum current is 300ma, and
+         * when we set current limit to 200ma, the card will draw 200ma, and
+         * when we set current limit to 400/600/800ma, the card will draw its
+         * maximum 300ma from the host.
+         */
+        if (max_current >= 800)
+                current_limit = SD_SET_CURRENT_LIMIT_800;
+        else if (max_current >= 600)
+                current_limit = SD_SET_CURRENT_LIMIT_600;
+        else if (max_current >= 400)
+                current_limit = SD_SET_CURRENT_LIMIT_400;
+        else if (max_current >= 200)
                 current_limit = SD_SET_CURRENT_LIMIT_200;
 
-        err = mmc_sd_switch(card, 1, 3, current_limit, status);
-        if (err)
-                return err;
+        if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
+                err = mmc_sd_switch(card, 1, 3, current_limit, status);
+                if (err)
+                        return err;
 
-        if (((status[15] >> 4) & 0x0F) != current_limit)
-                pr_warning("%s: Problem setting current limit!\n",
-                        mmc_hostname(card->host));
+                if (((status[15] >> 4) & 0x0F) != current_limit)
+                        pr_warning("%s: Problem setting current limit!\n",
+                                mmc_hostname(card->host));
+
+        }
 
         return 0;
 }
@@ -726,6 +712,7 @@ struct device_type sd_type = {
 int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 {
         int err;
+        u32 max_current;
 
         /*
          * Since we're changing the OCR value, we seem to
@@ -753,9 +740,12 @@ int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
             MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))
                 ocr |= SD_OCR_S18R;
 
-        /* If the host can supply more than 150mA, XPC should be set to 1. */
-        if (host->caps & (MMC_CAP_SET_XPC_330 | MMC_CAP_SET_XPC_300 |
-            MMC_CAP_SET_XPC_180))
+        /*
+         * If the host can supply more than 150mA at current voltage,
+         * XPC should be set to 1.
+         */
+        max_current = sd_get_host_max_current(host);
+        if (max_current > 150)
                 ocr |= SD_OCR_XPC;
 
 try_again:
@@ -911,9 +901,6 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
         BUG_ON(!host);
         WARN_ON(!host->claimed);
 
-        /* The initialization should be done at 3.3 V I/O voltage. */
-        mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
-
         err = mmc_sd_get_cid(host, ocr, cid, &rocr);
         if (err)
                 return err;
diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index 41c5fd8848f4..d4619e2ec030 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -591,9 +591,6 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
          * Inform the card of the voltage
          */
         if (!powered_resume) {
-                /* The initialization should be done at 3.3 V I/O voltage. */
-                mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
-
                 err = mmc_send_io_op_cond(host, host->ocr, &ocr);
                 if (err)
                         goto err;
@@ -1006,10 +1003,6 @@ static int mmc_sdio_power_restore(struct mmc_host *host)
          * restore the correct voltage setting of the card.
          */
 
-        /* The initialization should be done at 3.3 V I/O voltage. */
-        if (!mmc_card_keep_power(host))
-                mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
-
         sdio_reset(host);
         mmc_go_idle(host);
         mmc_send_if_cond(host, host->ocr_avail);
diff --git a/drivers/mmc/core/sdio_cis.c b/drivers/mmc/core/sdio_cis.c
index f1c7ed8f4d85..8e94e555b788 100644
--- a/drivers/mmc/core/sdio_cis.c
+++ b/drivers/mmc/core/sdio_cis.c
@@ -313,7 +313,7 @@ static int sdio_read_cis(struct mmc_card *card, struct sdio_func *func)
 
                         if (ret == -ENOENT) {
                                 /* warn about unknown tuples */
-                                pr_warning("%s: queuing unknown"
+                                pr_warn_ratelimited("%s: queuing unknown"
                                        " CIS tuple 0x%02x (%u bytes)\n",
                                        mmc_hostname(card->host),
                                        tpl_code, tpl_link);
diff --git a/drivers/mmc/core/slot-gpio.c b/drivers/mmc/core/slot-gpio.c
new file mode 100644
index 000000000000..058242916cef
--- /dev/null
+++ b/drivers/mmc/core/slot-gpio.c
@@ -0,0 +1,188 @@
+/*
+ * 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/mmc/slot-gpio.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+struct mmc_gpio {
+        int ro_gpio;
+        int cd_gpio;
+        char *ro_label;
+        char cd_label[0];
+};
+
+static irqreturn_t mmc_gpio_cd_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;
+}
+
+static int mmc_gpio_alloc(struct mmc_host *host)
+{
+        size_t len = strlen(dev_name(host->parent)) + 4;
+        struct mmc_gpio *ctx;
+
+        mutex_lock(&host->slot.lock);
+
+        ctx = host->slot.handler_priv;
+        if (!ctx) {
+                /*
+                 * devm_kzalloc() can be called after device_initialize(), even
+                 * before device_add(), i.e., between mmc_alloc_host() and
+                 * mmc_add_host()
+                 */
+                ctx = devm_kzalloc(&host->class_dev, sizeof(*ctx) + 2 * len,
+                                   GFP_KERNEL);
+                if (ctx) {
+                        ctx->ro_label = ctx->cd_label + len;
+                        snprintf(ctx->cd_label, len, "%s cd", dev_name(host->parent));
+                        snprintf(ctx->ro_label, len, "%s ro", dev_name(host->parent));
+                        ctx->cd_gpio = -EINVAL;
+                        ctx->ro_gpio = -EINVAL;
+                        host->slot.handler_priv = ctx;
+                }
+        }
+
+        mutex_unlock(&host->slot.lock);
+
+        return ctx ? 0 : -ENOMEM;
+}
+
+int mmc_gpio_get_ro(struct mmc_host *host)
+{
+        struct mmc_gpio *ctx = host->slot.handler_priv;
+
+        if (!ctx || !gpio_is_valid(ctx->ro_gpio))
+                return -ENOSYS;
+
+        return !gpio_get_value_cansleep(ctx->ro_gpio) ^
+                !!(host->caps2 & MMC_CAP2_RO_ACTIVE_HIGH);
+}
+EXPORT_SYMBOL(mmc_gpio_get_ro);
+
+int mmc_gpio_get_cd(struct mmc_host *host)
+{
+        struct mmc_gpio *ctx = host->slot.handler_priv;
+
+        if (!ctx || !gpio_is_valid(ctx->cd_gpio))
+                return -ENOSYS;
+
+        return !gpio_get_value_cansleep(ctx->cd_gpio) ^
+                !!(host->caps2 & MMC_CAP2_CD_ACTIVE_HIGH);
+}
+EXPORT_SYMBOL(mmc_gpio_get_cd);
+
+int mmc_gpio_request_ro(struct mmc_host *host, unsigned int gpio)
+{
+        struct mmc_gpio *ctx;
+        int ret;
+
+        if (!gpio_is_valid(gpio))
+                return -EINVAL;
+
+        ret = mmc_gpio_alloc(host);
+        if (ret < 0)
+                return ret;
+
+        ctx = host->slot.handler_priv;
+
+        return gpio_request_one(gpio, GPIOF_DIR_IN, ctx->ro_label);
+}
+EXPORT_SYMBOL(mmc_gpio_request_ro);
+
+int mmc_gpio_request_cd(struct mmc_host *host, unsigned int gpio)
+{
+        struct mmc_gpio *ctx;
+        int irq = gpio_to_irq(gpio);
+        int ret;
+
+        ret = mmc_gpio_alloc(host);
+        if (ret < 0)
+                return ret;
+
+        ctx = host->slot.handler_priv;
+
+        ret = gpio_request_one(gpio, GPIOF_DIR_IN, ctx->cd_label);
+        if (ret < 0)
+                /*
+                 * don't bother freeing memory. It might still get used by other
+                 * slot functions, in any case it will be freed, when the device
+                 * is destroyed.
+                 */
+                return ret;
+
+        /*
+         * Even if gpio_to_irq() returns a valid IRQ number, the platform might
+         * still prefer to poll, e.g., because that IRQ number is already used
+         * by another unit and cannot be shared.
+         */
+        if (irq >= 0 && host->caps & MMC_CAP_NEEDS_POLL)
+                irq = -EINVAL;
+
+        if (irq >= 0) {
+                ret = request_threaded_irq(irq, NULL, mmc_gpio_cd_irqt,
+                        IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                        ctx->cd_label, host);
+                if (ret < 0)
+                        irq = ret;
+        }
+
+        host->slot.cd_irq = irq;
+
+        if (irq < 0)
+                host->caps |= MMC_CAP_NEEDS_POLL;
+
+        ctx->cd_gpio = gpio;
+
+        return 0;
+}
+EXPORT_SYMBOL(mmc_gpio_request_cd);
+
+void mmc_gpio_free_ro(struct mmc_host *host)
+{
+        struct mmc_gpio *ctx = host->slot.handler_priv;
+        int gpio;
+
+        if (!ctx || !gpio_is_valid(ctx->ro_gpio))
+                return;
+
+        gpio = ctx->ro_gpio;
+        ctx->ro_gpio = -EINVAL;
+
+        gpio_free(gpio);
+}
+EXPORT_SYMBOL(mmc_gpio_free_ro);
+
+void mmc_gpio_free_cd(struct mmc_host *host)
+{
+        struct mmc_gpio *ctx = host->slot.handler_priv;
+        int gpio;
+
+        if (!ctx || !gpio_is_valid(ctx->cd_gpio))
+                return;
+
+        if (host->slot.cd_irq >= 0) {
+                free_irq(host->slot.cd_irq, host);
+                host->slot.cd_irq = -EINVAL;
+        }
+
+        gpio = ctx->cd_gpio;
+        ctx->cd_gpio = -EINVAL;
+
+        gpio_free(gpio);
+}
+EXPORT_SYMBOL(mmc_gpio_free_cd);
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index f2c115e06438..322412cec4ee 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -391,11 +391,17 @@ static int atmci_regs_show(struct seq_file *s, void *v)
         clk_disable(host->mck);
         spin_unlock_bh(&host->lock);
 
-        seq_printf(s, "MR:\t0x%08x%s%s CLKDIV=%u\n",
+        seq_printf(s, "MR:\t0x%08x%s%s ",
                         buf[ATMCI_MR / 4],
                         buf[ATMCI_MR / 4] & ATMCI_MR_RDPROOF ? " RDPROOF" : "",
-                        buf[ATMCI_MR / 4] & ATMCI_MR_WRPROOF ? " WRPROOF" : "",
-                        buf[ATMCI_MR / 4] & 0xff);
+                        buf[ATMCI_MR / 4] & ATMCI_MR_WRPROOF ? " WRPROOF" : "");
+        if (host->caps.has_odd_clk_div)
+                seq_printf(s, "{CLKDIV,CLKODD}=%u\n",
+                                ((buf[ATMCI_MR / 4] & 0xff) << 1)
+                                | ((buf[ATMCI_MR / 4] >> 16) & 1));
+        else
+                seq_printf(s, "CLKDIV=%u\n",
+                                (buf[ATMCI_MR / 4] & 0xff));
         seq_printf(s, "DTOR:\t0x%08x\n", buf[ATMCI_DTOR / 4]);
         seq_printf(s, "SDCR:\t0x%08x\n", buf[ATMCI_SDCR / 4]);
         seq_printf(s, "ARGR:\t0x%08x\n", buf[ATMCI_ARGR / 4]);
@@ -1685,7 +1691,6 @@ static void atmci_tasklet_func(unsigned long priv)
 
                         dev_dbg(&host->pdev->dev, "FSM: cmd ready\n");
                         host->cmd = NULL;
-                        host->data = NULL;
                         data->bytes_xfered = data->blocks * data->blksz;
                         data->error = 0;
                         atmci_command_complete(host, mrq->stop);
@@ -1699,6 +1704,7 @@ static void atmci_tasklet_func(unsigned long priv)
                                 atmci_writel(host, ATMCI_IER, ATMCI_NOTBUSY);
                                 state = STATE_WAITING_NOTBUSY;
                         }
+                        host->data = NULL;
                         break;
 
                 case STATE_END_REQUEST:
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 1ca5e72ceb65..72dc3cde646d 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -405,11 +405,23 @@ static void dw_mci_idmac_start_dma(struct dw_mci *host, unsigned int sg_len)
 static int dw_mci_idmac_init(struct dw_mci *host)
 {
         struct idmac_desc *p;
-        int i;
+        int i, dma_support;
 
         /* Number of descriptors in the ring buffer */
         host->ring_size = PAGE_SIZE / sizeof(struct idmac_desc);
 
+        /* Check if Hardware Configuration Register has support for DMA */
+        dma_support = (mci_readl(host, HCON) >> 16) & 0x3;
+
+        if (!dma_support || dma_support > 2) {
+                dev_err(&host->dev,
+                        "Host Controller does not support IDMA Tx.\n");
+                host->dma_ops = NULL;
+                return -ENODEV;
+        }
+
+        dev_info(&host->dev, "Using internal DMA controller.\n");
+
         /* Forward link the descriptor list */
         for (i = 0, p = host->sg_cpu; i < host->ring_size - 1; i++, p++)
                 p->des3 = host->sg_dma + (sizeof(struct idmac_desc) * (i + 1));
@@ -1876,7 +1888,6 @@ static void dw_mci_init_dma(struct dw_mci *host)
         /* Determine which DMA interface to use */
 #ifdef CONFIG_MMC_DW_IDMAC
         host->dma_ops = &dw_mci_idmac_ops;
-        dev_info(&host->dev, "Using internal DMA controller.\n");
 #endif
 
         if (!host->dma_ops)
@@ -2175,7 +2186,7 @@ int dw_mci_resume(struct dw_mci *host)
                 return ret;
         }
 
-        if (host->dma_ops->init)
+        if (host->use_dma && host->dma_ops->init)
                 host->dma_ops->init(host);
 
         /* Restore the old value at FIFOTH register */
diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
index 277161d279b8..a51f9309ffbb 100644
--- a/drivers/mmc/host/mxs-mmc.c
+++ b/drivers/mmc/host/mxs-mmc.c
@@ -164,16 +164,23 @@ struct mxs_mmc_host {
         spinlock_t                      lock;
         int                             sdio_irq_en;
         int                             wp_gpio;
+        bool                            wp_inverted;
 };
 
 static int mxs_mmc_get_ro(struct mmc_host *mmc)
 {
         struct mxs_mmc_host *host = mmc_priv(mmc);
+        int ret;
 
         if (!gpio_is_valid(host->wp_gpio))
                 return -EINVAL;
 
-        return gpio_get_value(host->wp_gpio);
+        ret = gpio_get_value(host->wp_gpio);
+
+        if (host->wp_inverted)
+                ret = !ret;
+
+        return ret;
 }
 
 static int mxs_mmc_get_cd(struct mmc_host *mmc)
@@ -707,6 +714,8 @@ static int mxs_mmc_probe(struct platform_device *pdev)
         struct pinctrl *pinctrl;
         int ret = 0, irq_err, irq_dma;
         dma_cap_mask_t mask;
+        struct regulator *reg_vmmc;
+        enum of_gpio_flags flags;
 
         iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0);
@@ -747,6 +756,16 @@ static int mxs_mmc_probe(struct platform_device *pdev)
         host->mmc = mmc;
         host->sdio_irq_en = 0;
 
+        reg_vmmc = devm_regulator_get(&pdev->dev, "vmmc");
+        if (!IS_ERR(reg_vmmc)) {
+                ret = regulator_enable(reg_vmmc);
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "Failed to enable vmmc regulator: %d\n", ret);
+                        goto out_mmc_free;
+                }
+        }
+
         pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
         if (IS_ERR(pinctrl)) {
                 ret = PTR_ERR(pinctrl);
@@ -785,7 +804,10 @@ static int mxs_mmc_probe(struct platform_device *pdev)
                         mmc->caps |= MMC_CAP_4_BIT_DATA;
                 else if (bus_width == 8)
                         mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA;
-                host->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
+                host->wp_gpio = of_get_named_gpio_flags(np, "wp-gpios", 0,
+                                                        &flags);
+                if (flags & OF_GPIO_ACTIVE_LOW)
+                        host->wp_inverted = 1;
         } else {
                 if (pdata->flags & SLOTF_8_BIT_CAPABLE)
                         mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA;
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index 389a3eedfc24..bc28627af66b 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -1089,7 +1089,7 @@ static int omap_hsmmc_switch_opcond(struct omap_hsmmc_host *host, int vdd)
         /* Disable the clocks */
         pm_runtime_put_sync(host->dev);
         if (host->dbclk)
-                clk_disable(host->dbclk);
+                clk_disable_unprepare(host->dbclk);
 
         /* Turn the power off */
         ret = mmc_slot(host).set_power(host->dev, host->slot_id, 0, 0);
@@ -1100,7 +1100,7 @@ static int omap_hsmmc_switch_opcond(struct omap_hsmmc_host *host, int vdd)
                                                vdd);
         pm_runtime_get_sync(host->dev);
         if (host->dbclk)
-                clk_enable(host->dbclk);
+                clk_prepare_enable(host->dbclk);
 
         if (ret != 0)
                 goto err;
@@ -1899,7 +1899,7 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
         if (IS_ERR(host->dbclk)) {
                 dev_warn(mmc_dev(host->mmc), "Failed to get debounce clk\n");
                 host->dbclk = NULL;
-        } else if (clk_enable(host->dbclk) != 0) {
+        } else if (clk_prepare_enable(host->dbclk) != 0) {
                 dev_warn(mmc_dev(host->mmc), "Failed to enable debounce clk\n");
                 clk_put(host->dbclk);
                 host->dbclk = NULL;
@@ -1931,6 +1931,7 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
         res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx");
         if (!res) {
                 dev_err(mmc_dev(host->mmc), "cannot get DMA TX channel\n");
+                ret = -ENXIO;
                 goto err_irq;
         }
         host->dma_line_tx = res->start;
@@ -1938,6 +1939,7 @@ static int __devinit omap_hsmmc_probe(struct platform_device *pdev)
         res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx");
         if (!res) {
                 dev_err(mmc_dev(host->mmc), "cannot get DMA RX channel\n");
+                ret = -ENXIO;
                 goto err_irq;
         }
         host->dma_line_rx = res->start;
@@ -2023,7 +2025,7 @@ err_irq:
         pm_runtime_disable(host->dev);
         clk_put(host->fclk);
         if (host->dbclk) {
-                clk_disable(host->dbclk);
+                clk_disable_unprepare(host->dbclk);
                 clk_put(host->dbclk);
         }
 err1:
@@ -2058,7 +2060,7 @@ static int __devexit omap_hsmmc_remove(struct platform_device *pdev)
         pm_runtime_disable(host->dev);
         clk_put(host->fclk);
         if (host->dbclk) {
-                clk_disable(host->dbclk);
+                clk_disable_unprepare(host->dbclk);
                 clk_put(host->dbclk);
         }
 
@@ -2116,7 +2118,7 @@ static int omap_hsmmc_suspend(struct device *dev)
         }
 
         if (host->dbclk)
-                clk_disable(host->dbclk);
+                clk_disable_unprepare(host->dbclk);
 err:
         pm_runtime_put_sync(host->dev);
         return ret;
@@ -2137,7 +2139,7 @@ static int omap_hsmmc_resume(struct device *dev)
         pm_runtime_get_sync(host->dev);
 
         if (host->dbclk)
-                clk_enable(host->dbclk);
+                clk_prepare_enable(host->dbclk);
 
         if (!(host->mmc->pm_flags & MMC_PM_KEEP_POWER))
                 omap_hsmmc_conf_bus_power(host);
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index c3622a69f432..bd5a5cce122c 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -26,7 +26,6 @@
 #include <mach/dma.h>
 
 #include <mach/regs-sdi.h>
-#include <mach/regs-gpio.h>
 
 #include <plat/mci.h>
 
@@ -1237,12 +1236,9 @@ static void s3cmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         switch (ios->power_mode) {
         case MMC_POWER_ON:
         case MMC_POWER_UP:
-                s3c2410_gpio_cfgpin(S3C2410_GPE(5), S3C2410_GPE5_SDCLK);
-                s3c2410_gpio_cfgpin(S3C2410_GPE(6), S3C2410_GPE6_SDCMD);
-                s3c2410_gpio_cfgpin(S3C2410_GPE(7), S3C2410_GPE7_SDDAT0);
-                s3c2410_gpio_cfgpin(S3C2410_GPE(8), S3C2410_GPE8_SDDAT1);
-                s3c2410_gpio_cfgpin(S3C2410_GPE(9), S3C2410_GPE9_SDDAT2);
-                s3c2410_gpio_cfgpin(S3C2410_GPE(10), S3C2410_GPE10_SDDAT3);
+                /* Configure GPE5...GPE10 pins in SD mode */
+                s3c_gpio_cfgall_range(S3C2410_GPE(5), 6, S3C_GPIO_SFN(2),
+                                      S3C_GPIO_PULL_NONE);
 
                 if (host->pdata->set_power)
                         host->pdata->set_power(ios->power_mode, ios->vdd);
diff --git a/drivers/mmc/host/sdhci-dove.c b/drivers/mmc/host/sdhci-dove.c
index 177f697b5835..a6e53a1ebb08 100644
--- a/drivers/mmc/host/sdhci-dove.c
+++ b/drivers/mmc/host/sdhci-dove.c
@@ -20,11 +20,17 @@
  */
 
 #include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/err.h>
 #include <linux/module.h>
 #include <linux/mmc/host.h>
 
 #include "sdhci-pltfm.h"
 
+struct sdhci_dove_priv {
+        struct clk *clk;
+};
+
 static u16 sdhci_dove_readw(struct sdhci_host *host, int reg)
 {
         u16 ret;
@@ -66,16 +72,57 @@ static struct sdhci_pltfm_data sdhci_dove_pdata = {
         .quirks = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
                   SDHCI_QUIRK_NO_BUSY_IRQ |
                   SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
-                  SDHCI_QUIRK_FORCE_DMA,
+                  SDHCI_QUIRK_FORCE_DMA |
+                  SDHCI_QUIRK_NO_HISPD_BIT,
 };
 
 static int __devinit sdhci_dove_probe(struct platform_device *pdev)
 {
-        return sdhci_pltfm_register(pdev, &sdhci_dove_pdata);
+        struct sdhci_host *host;
+        struct sdhci_pltfm_host *pltfm_host;
+        struct sdhci_dove_priv *priv;
+        int ret;
+
+        ret = sdhci_pltfm_register(pdev, &sdhci_dove_pdata);
+        if (ret)
+                goto sdhci_dove_register_fail;
+
+        priv = devm_kzalloc(&pdev->dev, sizeof(struct sdhci_dove_priv),
+                            GFP_KERNEL);
+        if (!priv) {
+                dev_err(&pdev->dev, "unable to allocate private data");
+                ret = -ENOMEM;
+                goto sdhci_dove_allocate_fail;
+        }
+
+        host = platform_get_drvdata(pdev);
+        pltfm_host = sdhci_priv(host);
+        pltfm_host->priv = priv;
+
+        priv->clk = clk_get(&pdev->dev, NULL);
+        if (!IS_ERR(priv->clk))
+                clk_prepare_enable(priv->clk);
+        return 0;
+
+sdhci_dove_allocate_fail:
+        sdhci_pltfm_unregister(pdev);
+sdhci_dove_register_fail:
+        return ret;
 }
 
 static int __devexit sdhci_dove_remove(struct platform_device *pdev)
 {
+        struct sdhci_host *host = platform_get_drvdata(pdev);
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct sdhci_dove_priv *priv = pltfm_host->priv;
+
+        if (priv->clk) {
+                if (!IS_ERR(priv->clk)) {
+                        clk_disable_unprepare(priv->clk);
+                        clk_put(priv->clk);
+                }
+                devm_kfree(&pdev->dev, priv->clk);
+        }
         return sdhci_pltfm_unregister(pdev);
 }
 
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index ebbe984e5d00..e23f8134591c 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -299,6 +299,8 @@ static void esdhc_writew_le(struct sdhci_host *host, u16 val, int reg)
 
 static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
 {
+        struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+        struct pltfm_imx_data *imx_data = pltfm_host->priv;
         u32 new_val;
 
         switch (reg) {
@@ -315,8 +317,11 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
                                 SDHCI_CTRL_D3CD);
                 /* ensure the endianess */
                 new_val |= ESDHC_HOST_CONTROL_LE;
-                /* DMA mode bits are shifted */
-                new_val |= (val & SDHCI_CTRL_DMA_MASK) << 5;
+                /* bits 8&9 are reserved on mx25 */
+                if (!is_imx25_esdhc(imx_data)) {
+                        /* DMA mode bits are shifted */
+                        new_val |= (val & SDHCI_CTRL_DMA_MASK) << 5;
+                }
 
                 esdhc_clrset_le(host, 0xffff, new_val, reg);
                 return;
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 69ef0beae104..504da715a41a 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -157,6 +157,7 @@ static const struct sdhci_pci_fixes sdhci_ene_714 = {
 static const struct sdhci_pci_fixes sdhci_cafe = {
         .quirks         = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
                           SDHCI_QUIRK_NO_BUSY_IRQ |
+                          SDHCI_QUIRK_BROKEN_CARD_DETECTION |
                           SDHCI_QUIRK_BROKEN_TIMEOUT_VAL,
 };
 
diff --git a/drivers/mmc/host/sdhci-pxav2.c b/drivers/mmc/host/sdhci-pxav2.c
index dbb75bfbcffb..b6ee8857e226 100644
--- a/drivers/mmc/host/sdhci-pxav2.c
+++ b/drivers/mmc/host/sdhci-pxav2.c
@@ -28,6 +28,9 @@
 #include <linux/mmc/host.h>
 #include <linux/platform_data/pxa_sdhci.h>
 #include <linux/slab.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
 
@@ -121,6 +124,48 @@ static struct sdhci_ops pxav2_sdhci_ops = {
         .platform_8bit_width = pxav2_mmc_set_width,
 };
 
+#ifdef CONFIG_OF
+static const struct of_device_id sdhci_pxav2_of_match[] = {
+        {
+                .compatible = "mrvl,pxav2-mmc",
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, sdhci_pxav2_of_match);
+
+static struct sdhci_pxa_platdata *pxav2_get_mmc_pdata(struct device *dev)
+{
+        struct sdhci_pxa_platdata *pdata;
+        struct device_node *np = dev->of_node;
+        u32 bus_width;
+        u32 clk_delay_cycles;
+
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL;
+
+        if (of_find_property(np, "non-removable", NULL))
+                pdata->flags |= PXA_FLAG_CARD_PERMANENT;
+
+        of_property_read_u32(np, "bus-width", &bus_width);
+        if (bus_width == 8)
+                pdata->flags |= PXA_FLAG_SD_8_BIT_CAPABLE_SLOT;
+
+        of_property_read_u32(np, "mrvl,clk-delay-cycles", &clk_delay_cycles);
+        if (clk_delay_cycles > 0) {
+                pdata->clk_delay_sel = 1;
+                pdata->clk_delay_cycles = clk_delay_cycles;
+        }
+
+        return pdata;
+}
+#else
+static inline struct sdhci_pxa_platdata *pxav2_get_mmc_pdata(struct device *dev)
+{
+        return NULL;
+}
+#endif
+
 static int __devinit sdhci_pxav2_probe(struct platform_device *pdev)
 {
         struct sdhci_pltfm_host *pltfm_host;
@@ -128,6 +173,8 @@ static int __devinit sdhci_pxav2_probe(struct platform_device *pdev)
         struct device *dev = &pdev->dev;
         struct sdhci_host *host = NULL;
         struct sdhci_pxa *pxa = NULL;
+        const struct of_device_id *match;
+
         int ret;
         struct clk *clk;
 
@@ -156,6 +203,10 @@ static int __devinit sdhci_pxav2_probe(struct platform_device *pdev)
                 | SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
                 | SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN;
 
+        match = of_match_device(of_match_ptr(sdhci_pxav2_of_match), &pdev->dev);
+        if (match) {
+                pdata = pxav2_get_mmc_pdata(dev);
+        }
         if (pdata) {
                 if (pdata->flags & PXA_FLAG_CARD_PERMANENT) {
                         /* on-chip device */
@@ -218,6 +269,9 @@ static struct platform_driver sdhci_pxav2_driver = {
         .driver         = {
                 .name   = "sdhci-pxav2",
                 .owner  = THIS_MODULE,
+#ifdef CONFIG_OF
+                .of_match_table = sdhci_pxav2_of_match,
+#endif
                 .pm     = SDHCI_PLTFM_PMOPS,
         },
         .probe          = sdhci_pxav2_probe,
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
index f29695683556..07fe3834fe0b 100644
--- a/drivers/mmc/host/sdhci-pxav3.c
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -28,6 +28,9 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+
 #include "sdhci.h"
 #include "sdhci-pltfm.h"
 
@@ -164,6 +167,46 @@ static struct sdhci_ops pxav3_sdhci_ops = {
         .platform_send_init_74_clocks = pxav3_gen_init_74_clocks,
 };
 
+#ifdef CONFIG_OF
+static const struct of_device_id sdhci_pxav3_of_match[] = {
+        {
+                .compatible = "mrvl,pxav3-mmc",
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, sdhci_pxav3_of_match);
+
+static struct sdhci_pxa_platdata *pxav3_get_mmc_pdata(struct device *dev)
+{
+        struct sdhci_pxa_platdata *pdata;
+        struct device_node *np = dev->of_node;
+        u32 bus_width;
+        u32 clk_delay_cycles;
+
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL;
+
+        if (of_find_property(np, "non-removable", NULL))
+                pdata->flags |= PXA_FLAG_CARD_PERMANENT;
+
+        of_property_read_u32(np, "bus-width", &bus_width);
+        if (bus_width == 8)
+                pdata->flags |= PXA_FLAG_SD_8_BIT_CAPABLE_SLOT;
+
+        of_property_read_u32(np, "mrvl,clk-delay-cycles", &clk_delay_cycles);
+        if (clk_delay_cycles > 0)
+                pdata->clk_delay_cycles = clk_delay_cycles;
+
+        return pdata;
+}
+#else
+static inline struct sdhci_pxa_platdata *pxav3_get_mmc_pdata(struct device *dev)
+{
+        return NULL;
+}
+#endif
+
 static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
 {
         struct sdhci_pltfm_host *pltfm_host;
@@ -171,6 +214,8 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
         struct device *dev = &pdev->dev;
         struct sdhci_host *host = NULL;
         struct sdhci_pxa *pxa = NULL;
+        const struct of_device_id *match;
+
         int ret;
         struct clk *clk;
 
@@ -202,6 +247,10 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
         /* enable 1/8V DDR capable */
         host->mmc->caps |= MMC_CAP_1_8V_DDR;
 
+        match = of_match_device(of_match_ptr(sdhci_pxav3_of_match), &pdev->dev);
+        if (match)
+                pdata = pxav3_get_mmc_pdata(dev);
+
         if (pdata) {
                 if (pdata->flags & PXA_FLAG_CARD_PERMANENT) {
                         /* on-chip device */
@@ -263,6 +312,9 @@ static int __devexit sdhci_pxav3_remove(struct platform_device *pdev)
 static struct platform_driver sdhci_pxav3_driver = {
         .driver         = {
                 .name   = "sdhci-pxav3",
+#ifdef CONFIG_OF
+                .of_match_table = sdhci_pxav3_of_match,
+#endif
                 .owner  = THIS_MODULE,
                 .pm     = SDHCI_PLTFM_PMOPS,
         },
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index f4b8b4db3a9a..9a11dc39921c 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -27,6 +27,7 @@
 
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
 
 #include "sdhci.h"
 
@@ -244,6 +245,19 @@ static void sdhci_init(struct sdhci_host *host, int soft)
 static void sdhci_reinit(struct sdhci_host *host)
 {
         sdhci_init(host, 0);
+        /*
+         * Retuning stuffs are affected by different cards inserted and only
+         * applicable to UHS-I cards. So reset these fields to their initial
+         * value when card is removed.
+         */
+        if (host->flags & SDHCI_USING_RETUNING_TIMER) {
+                host->flags &= ~SDHCI_USING_RETUNING_TIMER;
+
+                del_timer_sync(&host->tuning_timer);
+                host->flags &= ~SDHCI_NEEDS_RETUNING;
+                host->mmc->max_blk_count =
+                        (host->quirks & SDHCI_QUIRK_NO_MULTIBLOCK) ? 1 : 65535;
+        }
         sdhci_enable_card_detection(host);
 }
 
@@ -1245,6 +1259,7 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
         struct sdhci_host *host;
         bool present;
         unsigned long flags;
+        u32 tuning_opcode;
 
         host = mmc_priv(mmc);
 
@@ -1292,8 +1307,12 @@ 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))) {
+                        /* eMMC uses cmd21 while sd and sdio use cmd19 */
+                        tuning_opcode = mmc->card->type == MMC_TYPE_MMC ?
+                                MMC_SEND_TUNING_BLOCK_HS200 :
+                                MMC_SEND_TUNING_BLOCK;
                         spin_unlock_irqrestore(&host->lock, flags);
-                        sdhci_execute_tuning(mmc, mrq->cmd->opcode);
+                        sdhci_execute_tuning(mmc, tuning_opcode);
                         spin_lock_irqsave(&host->lock, flags);
 
                         /* Restore original mmc_request structure */
@@ -1663,11 +1682,15 @@ static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
                 pwr = sdhci_readb(host, SDHCI_POWER_CONTROL);
                 pwr &= ~SDHCI_POWER_ON;
                 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
+                if (host->vmmc)
+                        regulator_disable(host->vmmc);
 
                 /* Wait for 1ms as per the spec */
                 usleep_range(1000, 1500);
                 pwr |= SDHCI_POWER_ON;
                 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
+                if (host->vmmc)
+                        regulator_enable(host->vmmc);
 
                 pr_info(DRIVER_NAME ": Switching to 1.8V signalling "
                         "voltage failed, retrying with S18R set to 0\n");
@@ -1855,6 +1878,7 @@ out:
          */
         if (!(host->flags & SDHCI_NEEDS_RETUNING) && host->tuning_count &&
             (host->tuning_mode == SDHCI_TUNING_MODE_1)) {
+                host->flags |= SDHCI_USING_RETUNING_TIMER;
                 mod_timer(&host->tuning_timer, jiffies +
                         host->tuning_count * HZ);
                 /* Tuning mode 1 limits the maximum data length to 4MB */
@@ -1872,10 +1896,10 @@ out:
          * try tuning again at a later time, when the re-tuning timer expires.
          * So for these controllers, we return 0. Since there might be other
          * controllers who do not have this capability, we return error for
-         * them.
+         * them. SDHCI_USING_RETUNING_TIMER means the host is currently using
+         * a retuning timer to do the retuning for the card.
          */
-        if (err && host->tuning_count &&
-            host->tuning_mode == SDHCI_TUNING_MODE_1)
+        if (err && (host->flags & SDHCI_USING_RETUNING_TIMER))
                 err = 0;
 
         sdhci_clear_set_irqs(host, SDHCI_INT_DATA_AVAIL, ier);
@@ -2382,7 +2406,6 @@ out:
 int sdhci_suspend_host(struct sdhci_host *host)
 {
         int ret;
-        bool has_tuning_timer;
 
         if (host->ops->platform_suspend)
                 host->ops->platform_suspend(host);
@@ -2390,16 +2413,14 @@ int sdhci_suspend_host(struct sdhci_host *host)
         sdhci_disable_card_detection(host);
 
         /* Disable tuning since we are suspending */
-        has_tuning_timer = host->version >= SDHCI_SPEC_300 &&
-                host->tuning_count && host->tuning_mode == SDHCI_TUNING_MODE_1;
-        if (has_tuning_timer) {
+        if (host->flags & SDHCI_USING_RETUNING_TIMER) {
                 del_timer_sync(&host->tuning_timer);
                 host->flags &= ~SDHCI_NEEDS_RETUNING;
         }
 
         ret = mmc_suspend_host(host->mmc);
         if (ret) {
-                if (has_tuning_timer) {
+                if (host->flags & SDHCI_USING_RETUNING_TIMER) {
                         host->flags |= SDHCI_NEEDS_RETUNING;
                         mod_timer(&host->tuning_timer, jiffies +
                                         host->tuning_count * HZ);
@@ -2450,8 +2471,7 @@ int sdhci_resume_host(struct sdhci_host *host)
                 host->ops->platform_resume(host);
 
         /* Set the re-tuning expiration flag */
-        if ((host->version >= SDHCI_SPEC_300) && host->tuning_count &&
-            (host->tuning_mode == SDHCI_TUNING_MODE_1))
+        if (host->flags & SDHCI_USING_RETUNING_TIMER)
                 host->flags |= SDHCI_NEEDS_RETUNING;
 
         return ret;
@@ -2490,8 +2510,7 @@ int sdhci_runtime_suspend_host(struct sdhci_host *host)
         int ret = 0;
 
         /* Disable tuning since we are suspending */
-        if (host->version >= SDHCI_SPEC_300 &&
-            host->tuning_mode == SDHCI_TUNING_MODE_1) {
+        if (host->flags & SDHCI_USING_RETUNING_TIMER) {
                 del_timer_sync(&host->tuning_timer);
                 host->flags &= ~SDHCI_NEEDS_RETUNING;
         }
@@ -2532,8 +2551,7 @@ int sdhci_runtime_resume_host(struct sdhci_host *host)
                 sdhci_do_enable_preset_value(host, true);
 
         /* Set the re-tuning expiration flag */
-        if ((host->version >= SDHCI_SPEC_300) && host->tuning_count &&
-            (host->tuning_mode == SDHCI_TUNING_MODE_1))
+        if (host->flags & SDHCI_USING_RETUNING_TIMER)
                 host->flags |= SDHCI_NEEDS_RETUNING;
 
         spin_lock_irqsave(&host->lock, flags);
@@ -2584,7 +2602,7 @@ EXPORT_SYMBOL_GPL(sdhci_alloc_host);
 int sdhci_add_host(struct sdhci_host *host)
 {
         struct mmc_host *mmc;
-        u32 caps[2];
+        u32 caps[2] = {0, 0};
         u32 max_current_caps;
         unsigned int ocr_avail;
         int ret;
@@ -2614,8 +2632,10 @@ int sdhci_add_host(struct sdhci_host *host)
         caps[0] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ? host->caps :
                 sdhci_readl(host, SDHCI_CAPABILITIES);
 
-        caps[1] = (host->version >= SDHCI_SPEC_300) ?
-                sdhci_readl(host, SDHCI_CAPABILITIES_1) : 0;
+        if (host->version >= SDHCI_SPEC_300)
+                caps[1] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ?
+                        host->caps1 :
+                        sdhci_readl(host, SDHCI_CAPABILITIES_1);
 
         if (host->quirks & SDHCI_QUIRK_FORCE_DMA)
                 host->flags |= SDHCI_USE_SDMA;
@@ -2779,7 +2799,7 @@ int sdhci_add_host(struct sdhci_host *host)
                 mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
 
         if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
-            mmc_card_is_removable(mmc))
+            !(host->mmc->caps & MMC_CAP_NONREMOVABLE))
                 mmc->caps |= MMC_CAP_NEEDS_POLL;
 
         /* Any UHS-I mode in caps implies SDR12 and SDR25 support. */
@@ -2837,6 +2857,30 @@ int sdhci_add_host(struct sdhci_host *host)
                              SDHCI_RETUNING_MODE_SHIFT;
 
         ocr_avail = 0;
+
+        host->vmmc = regulator_get(mmc_dev(mmc), "vmmc");
+        if (IS_ERR(host->vmmc)) {
+                pr_info("%s: no vmmc regulator found\n", mmc_hostname(mmc));
+                host->vmmc = NULL;
+        }
+
+#ifdef CONFIG_REGULATOR
+        if (host->vmmc) {
+                ret = regulator_is_supported_voltage(host->vmmc, 3300000,
+                        3300000);
+                if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_330)))
+                        caps[0] &= ~SDHCI_CAN_VDD_330;
+                ret = regulator_is_supported_voltage(host->vmmc, 3000000,
+                        3000000);
+                if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_300)))
+                        caps[0] &= ~SDHCI_CAN_VDD_300;
+                ret = regulator_is_supported_voltage(host->vmmc, 1800000,
+                        1800000);
+                if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_180)))
+                        caps[0] &= ~SDHCI_CAN_VDD_180;
+        }
+#endif /* CONFIG_REGULATOR */
+
         /*
          * According to SD Host Controller spec v3.00, if the Host System
          * can afford more than 150mA, Host Driver should set XPC to 1. Also
@@ -2845,55 +2889,45 @@ int sdhci_add_host(struct sdhci_host *host)
          * value.
          */
         max_current_caps = sdhci_readl(host, SDHCI_MAX_CURRENT);
+        if (!max_current_caps && host->vmmc) {
+                u32 curr = regulator_get_current_limit(host->vmmc);
+                if (curr > 0) {
+
+                        /* convert to SDHCI_MAX_CURRENT format */
+                        curr = curr/1000;  /* convert to mA */
+                        curr = curr/SDHCI_MAX_CURRENT_MULTIPLIER;
+
+                        curr = min_t(u32, curr, SDHCI_MAX_CURRENT_LIMIT);
+                        max_current_caps =
+                                (curr << SDHCI_MAX_CURRENT_330_SHIFT) |
+                                (curr << SDHCI_MAX_CURRENT_300_SHIFT) |
+                                (curr << SDHCI_MAX_CURRENT_180_SHIFT);
+                }
+        }
 
         if (caps[0] & SDHCI_CAN_VDD_330) {
-                int max_current_330;
-
                 ocr_avail |= MMC_VDD_32_33 | MMC_VDD_33_34;
 
-                max_current_330 = ((max_current_caps &
+                mmc->max_current_330 = ((max_current_caps &
                                    SDHCI_MAX_CURRENT_330_MASK) >>
                                    SDHCI_MAX_CURRENT_330_SHIFT) *
                                    SDHCI_MAX_CURRENT_MULTIPLIER;
-
-                if (max_current_330 > 150)
-                        mmc->caps |= MMC_CAP_SET_XPC_330;
         }
         if (caps[0] & SDHCI_CAN_VDD_300) {
-                int max_current_300;
-
                 ocr_avail |= MMC_VDD_29_30 | MMC_VDD_30_31;
 
-                max_current_300 = ((max_current_caps &
+                mmc->max_current_300 = ((max_current_caps &
                                    SDHCI_MAX_CURRENT_300_MASK) >>
                                    SDHCI_MAX_CURRENT_300_SHIFT) *
                                    SDHCI_MAX_CURRENT_MULTIPLIER;
-
-                if (max_current_300 > 150)
-                        mmc->caps |= MMC_CAP_SET_XPC_300;
         }
         if (caps[0] & SDHCI_CAN_VDD_180) {
-                int max_current_180;
-
                 ocr_avail |= MMC_VDD_165_195;
 
-                max_current_180 = ((max_current_caps &
+                mmc->max_current_180 = ((max_current_caps &
                                    SDHCI_MAX_CURRENT_180_MASK) >>
                                    SDHCI_MAX_CURRENT_180_SHIFT) *
                                    SDHCI_MAX_CURRENT_MULTIPLIER;
-
-                if (max_current_180 > 150)
-                        mmc->caps |= MMC_CAP_SET_XPC_180;
-
-                /* Maximum current capabilities of the host at 1.8V */
-                if (max_current_180 >= 800)
-                        mmc->caps |= MMC_CAP_MAX_CURRENT_800;
-                else if (max_current_180 >= 600)
-                        mmc->caps |= MMC_CAP_MAX_CURRENT_600;
-                else if (max_current_180 >= 400)
-                        mmc->caps |= MMC_CAP_MAX_CURRENT_400;
-                else
-                        mmc->caps |= MMC_CAP_MAX_CURRENT_200;
         }
 
         mmc->ocr_avail = ocr_avail;
@@ -2992,13 +3026,10 @@ int sdhci_add_host(struct sdhci_host *host)
 
         ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,
                 mmc_hostname(mmc), host);
-        if (ret)
+        if (ret) {
+                pr_err("%s: Failed to request IRQ %d: %d\n",
+                       mmc_hostname(mmc), host->irq, ret);
                 goto untasklet;
-
-        host->vmmc = regulator_get(mmc_dev(mmc), "vmmc");
-        if (IS_ERR(host->vmmc)) {
-                pr_info("%s: no vmmc regulator found\n", mmc_hostname(mmc));
-                host->vmmc = NULL;
         }
 
         sdhci_init(host, 0);
@@ -3016,8 +3047,11 @@ int sdhci_add_host(struct sdhci_host *host)
         host->led.brightness_set = sdhci_led_control;
 
         ret = led_classdev_register(mmc_dev(mmc), &host->led);
-        if (ret)
+        if (ret) {
+                pr_err("%s: Failed to register LED device: %d\n",
+                       mmc_hostname(mmc), ret);
                 goto reset;
+        }
 #endif
 
         mmiowb();
@@ -3081,8 +3115,6 @@ void sdhci_remove_host(struct sdhci_host *host, int dead)
         free_irq(host->irq, host);
 
         del_timer_sync(&host->timer);
-        if (host->version >= SDHCI_SPEC_300)
-                del_timer_sync(&host->tuning_timer);
 
         tasklet_kill(&host->card_tasklet);
         tasklet_kill(&host->finish_tasklet);
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index f761f23d2a28..97653ea8942b 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -205,6 +205,7 @@
 #define SDHCI_CAPABILITIES_1    0x44
 
 #define SDHCI_MAX_CURRENT               0x48
+#define  SDHCI_MAX_CURRENT_LIMIT        0xFF
 #define  SDHCI_MAX_CURRENT_330_MASK     0x0000FF
 #define  SDHCI_MAX_CURRENT_330_SHIFT    0
 #define  SDHCI_MAX_CURRENT_300_MASK     0x00FF00
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index 724b35e85a26..b2af7136cd27 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -54,6 +54,8 @@
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/sdio.h>
 #include <linux/mmc/sh_mmcif.h>
+#include <linux/mmc/slot-gpio.h>
+#include <linux/mod_devicetable.h>
 #include <linux/pagemap.h>
 #include <linux/platform_device.h>
 #include <linux/pm_qos.h>
@@ -384,6 +386,9 @@ static void sh_mmcif_request_dma(struct sh_mmcif_host *host,
         struct sh_dmae_slave *tx, *rx;
         host->dma_active = false;
 
+        if (!pdata)
+                return;
+
         /* We can only either use DMA for both Tx and Rx or not use it at all */
         if (pdata->dma) {
                 dev_warn(&host->pd->dev,
@@ -444,13 +449,14 @@ static void sh_mmcif_release_dma(struct sh_mmcif_host *host)
 static void sh_mmcif_clock_control(struct sh_mmcif_host *host, unsigned int clk)
 {
         struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
+        bool sup_pclk = p ? p->sup_pclk : false;
 
         sh_mmcif_bitclr(host, MMCIF_CE_CLK_CTRL, CLK_ENABLE);
         sh_mmcif_bitclr(host, MMCIF_CE_CLK_CTRL, CLK_CLEAR);
 
         if (!clk)
                 return;
-        if (p->sup_pclk && clk == host->clk)
+        if (sup_pclk && clk == host->clk)
                 sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_SUP_PCLK);
         else
                 sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_CLEAR &
@@ -892,21 +898,15 @@ static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
         switch (mrq->cmd->opcode) {
         /* MMCIF does not support SD/SDIO command */
-        case SD_IO_SEND_OP_COND:
+        case MMC_SLEEP_AWAKE: /* = SD_IO_SEND_OP_COND (5) */
+        case MMC_SEND_EXT_CSD: /* = SD_SEND_IF_COND (8) */
+                if ((mrq->cmd->flags & MMC_CMD_MASK) != MMC_CMD_BCR)
+                        break;
         case MMC_APP_CMD:
                 host->state = STATE_IDLE;
                 mrq->cmd->error = -ETIMEDOUT;
                 mmc_request_done(mmc, mrq);
                 return;
-        case MMC_SEND_EXT_CSD: /* = SD_SEND_IF_COND (8) */
-                if (!mrq->data) {
-                        /* send_if_cond cmd (not support) */
-                        host->state = STATE_IDLE;
-                        mrq->cmd->error = -ETIMEDOUT;
-                        mmc_request_done(mmc, mrq);
-                        return;
-                }
-                break;
         default:
                 break;
         }
@@ -916,10 +916,35 @@ static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
         sh_mmcif_start_cmd(host, mrq);
 }
 
+static int sh_mmcif_clk_update(struct sh_mmcif_host *host)
+{
+        int ret = clk_enable(host->hclk);
+
+        if (!ret) {
+                host->clk = clk_get_rate(host->hclk);
+                host->mmc->f_max = host->clk / 2;
+                host->mmc->f_min = host->clk / 512;
+        }
+
+        return ret;
+}
+
+static void sh_mmcif_set_power(struct sh_mmcif_host *host, struct mmc_ios *ios)
+{
+        struct sh_mmcif_plat_data *pd = host->pd->dev.platform_data;
+        struct mmc_host *mmc = host->mmc;
+
+        if (pd && pd->set_pwr)
+                pd->set_pwr(host->pd, ios->power_mode != MMC_POWER_OFF);
+        if (!IS_ERR(mmc->supply.vmmc))
+                /* Errors ignored... */
+                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc,
+                                      ios->power_mode ? ios->vdd : 0);
+}
+
 static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct sh_mmcif_host *host = mmc_priv(mmc);
-        struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
         unsigned long flags;
 
         spin_lock_irqsave(&host->lock, flags);
@@ -937,6 +962,7 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                         sh_mmcif_request_dma(host, host->pd->dev.platform_data);
                         host->card_present = true;
                 }
+                sh_mmcif_set_power(host, ios);
         } else if (ios->power_mode == MMC_POWER_OFF || !ios->clock) {
                 /* clock stop */
                 sh_mmcif_clock_control(host, 0);
@@ -948,9 +974,10 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 }
                 if (host->power) {
                         pm_runtime_put(&host->pd->dev);
+                        clk_disable(host->hclk);
                         host->power = false;
-                        if (p->down_pwr && ios->power_mode == MMC_POWER_OFF)
-                                p->down_pwr(host->pd);
+                        if (ios->power_mode == MMC_POWER_OFF)
+                                sh_mmcif_set_power(host, ios);
                 }
                 host->state = STATE_IDLE;
                 return;
@@ -958,8 +985,7 @@ static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
         if (ios->clock) {
                 if (!host->power) {
-                        if (p->set_pwr)
-                                p->set_pwr(host->pd, ios->power_mode);
+                        sh_mmcif_clk_update(host);
                         pm_runtime_get_sync(&host->pd->dev);
                         host->power = true;
                         sh_mmcif_sync_reset(host);
@@ -975,8 +1001,12 @@ static int sh_mmcif_get_cd(struct mmc_host *mmc)
 {
         struct sh_mmcif_host *host = mmc_priv(mmc);
         struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
+        int ret = mmc_gpio_get_cd(mmc);
+
+        if (ret >= 0)
+                return ret;
 
-        if (!p->get_cd)
+        if (!p || !p->get_cd)
                 return -ENOSYS;
         else
                 return p->get_cd(host->pd);
@@ -1242,12 +1272,28 @@ static void mmcif_timeout_work(struct work_struct *work)
         mmc_request_done(host->mmc, mrq);
 }
 
+static void sh_mmcif_init_ocr(struct sh_mmcif_host *host)
+{
+        struct sh_mmcif_plat_data *pd = host->pd->dev.platform_data;
+        struct mmc_host *mmc = host->mmc;
+
+        mmc_regulator_get_supply(mmc);
+
+        if (!pd)
+                return;
+
+        if (!mmc->ocr_avail)
+                mmc->ocr_avail = pd->ocr;
+        else if (pd->ocr)
+                dev_warn(mmc_dev(mmc), "Platform OCR mask is ignored\n");
+}
+
 static int __devinit sh_mmcif_probe(struct platform_device *pdev)
 {
         int ret = 0, irq[2];
         struct mmc_host *mmc;
         struct sh_mmcif_host *host;
-        struct sh_mmcif_plat_data *pd;
+        struct sh_mmcif_plat_data *pd = pdev->dev.platform_data;
         struct resource *res;
         void __iomem *reg;
         char clk_name[8];
@@ -1268,42 +1314,26 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "ioremap error.\n");
                 return -ENOMEM;
         }
-        pd = pdev->dev.platform_data;
-        if (!pd) {
-                dev_err(&pdev->dev, "sh_mmcif plat data error.\n");
-                ret = -ENXIO;
-                goto clean_up;
-        }
+
         mmc = mmc_alloc_host(sizeof(struct sh_mmcif_host), &pdev->dev);
         if (!mmc) {
                 ret = -ENOMEM;
-                goto clean_up;
+                goto ealloch;
         }
         host            = mmc_priv(mmc);
         host->mmc       = mmc;
         host->addr      = reg;
         host->timeout   = 1000;
 
-        snprintf(clk_name, sizeof(clk_name), "mmc%d", pdev->id);
-        host->hclk = clk_get(&pdev->dev, clk_name);
-        if (IS_ERR(host->hclk)) {
-                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
-                ret = PTR_ERR(host->hclk);
-                goto clean_up1;
-        }
-        clk_enable(host->hclk);
-        host->clk = clk_get_rate(host->hclk);
         host->pd = pdev;
 
         spin_lock_init(&host->lock);
 
         mmc->ops = &sh_mmcif_ops;
-        mmc->f_max = host->clk / 2;
-        mmc->f_min = host->clk / 512;
-        if (pd->ocr)
-                mmc->ocr_avail = pd->ocr;
+        sh_mmcif_init_ocr(host);
+
         mmc->caps = MMC_CAP_MMC_HIGHSPEED;
-        if (pd->caps)
+        if (pd && pd->caps)
                 mmc->caps |= pd->caps;
         mmc->max_segs = 32;
         mmc->max_blk_size = 512;
@@ -1311,34 +1341,52 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         mmc->max_blk_count = mmc->max_req_size / mmc->max_blk_size;
         mmc->max_seg_size = mmc->max_req_size;
 
-        sh_mmcif_sync_reset(host);
         platform_set_drvdata(pdev, host);
 
         pm_runtime_enable(&pdev->dev);
         host->power = false;
 
+        snprintf(clk_name, sizeof(clk_name), "mmc%d", pdev->id);
+        host->hclk = clk_get(&pdev->dev, clk_name);
+        if (IS_ERR(host->hclk)) {
+                ret = PTR_ERR(host->hclk);
+                dev_err(&pdev->dev, "cannot get clock \"%s\": %d\n", clk_name, ret);
+                goto eclkget;
+        }
+        ret = sh_mmcif_clk_update(host);
+        if (ret < 0)
+                goto eclkupdate;
+
         ret = pm_runtime_resume(&pdev->dev);
         if (ret < 0)
-                goto clean_up2;
+                goto eresume;
 
         INIT_DELAYED_WORK(&host->timeout_work, mmcif_timeout_work);
 
+        sh_mmcif_sync_reset(host);
         sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
 
         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;
+                goto ereqirq0;
         }
         ret = request_threaded_irq(irq[1], sh_mmcif_intr, sh_mmcif_irqt, 0, "sh_mmc:int", host);
         if (ret) {
                 dev_err(&pdev->dev, "request_irq error (sh_mmc:int)\n");
-                goto clean_up4;
+                goto ereqirq1;
+        }
+
+        if (pd && pd->use_cd_gpio) {
+                ret = mmc_gpio_request_cd(mmc, pd->cd_gpio);
+                if (ret < 0)
+                        goto erqcd;
         }
 
+        clk_disable(host->hclk);
         ret = mmc_add_host(mmc);
         if (ret < 0)
-                goto clean_up5;
+                goto emmcaddh;
 
         dev_pm_qos_expose_latency_limit(&pdev->dev, 100);
 
@@ -1347,33 +1395,42 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
                 sh_mmcif_readl(host->addr, MMCIF_CE_VERSION) & 0x0000ffff);
         return ret;
 
-clean_up5:
+emmcaddh:
+        if (pd && pd->use_cd_gpio)
+                mmc_gpio_free_cd(mmc);
+erqcd:
         free_irq(irq[1], host);
-clean_up4:
+ereqirq1:
         free_irq(irq[0], host);
-clean_up3:
+ereqirq0:
         pm_runtime_suspend(&pdev->dev);
-clean_up2:
-        pm_runtime_disable(&pdev->dev);
+eresume:
         clk_disable(host->hclk);
-clean_up1:
+eclkupdate:
+        clk_put(host->hclk);
+eclkget:
+        pm_runtime_disable(&pdev->dev);
         mmc_free_host(mmc);
-clean_up:
-        if (reg)
-                iounmap(reg);
+ealloch:
+        iounmap(reg);
         return ret;
 }
 
 static int __devexit sh_mmcif_remove(struct platform_device *pdev)
 {
         struct sh_mmcif_host *host = platform_get_drvdata(pdev);
+        struct sh_mmcif_plat_data *pd = pdev->dev.platform_data;
         int irq[2];
 
         host->dying = true;
+        clk_enable(host->hclk);
         pm_runtime_get_sync(&pdev->dev);
 
         dev_pm_qos_hide_latency_limit(&pdev->dev);
 
+        if (pd && pd->use_cd_gpio)
+                mmc_gpio_free_cd(host->mmc);
+
         mmc_remove_host(host->mmc);
         sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
 
@@ -1395,9 +1452,9 @@ static int __devexit sh_mmcif_remove(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, NULL);
 
-        clk_disable(host->hclk);
         mmc_free_host(host->mmc);
         pm_runtime_put_sync(&pdev->dev);
+        clk_disable(host->hclk);
         pm_runtime_disable(&pdev->dev);
 
         return 0;
@@ -1406,24 +1463,18 @@ static int __devexit sh_mmcif_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int sh_mmcif_suspend(struct device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct sh_mmcif_host *host = platform_get_drvdata(pdev);
+        struct sh_mmcif_host *host = dev_get_drvdata(dev);
         int ret = mmc_suspend_host(host->mmc);
 
-        if (!ret) {
+        if (!ret)
                 sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
-                clk_disable(host->hclk);
-        }
 
         return ret;
 }
 
 static int sh_mmcif_resume(struct device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct sh_mmcif_host *host = platform_get_drvdata(pdev);
-
-        clk_enable(host->hclk);
+        struct sh_mmcif_host *host = dev_get_drvdata(dev);
 
         return mmc_resume_host(host->mmc);
 }
@@ -1432,6 +1483,12 @@ static int sh_mmcif_resume(struct device *dev)
 #define sh_mmcif_resume         NULL
 #endif  /* CONFIG_PM */
 
+static const struct of_device_id mmcif_of_match[] = {
+        { .compatible = "renesas,sh-mmcif" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, mmcif_of_match);
+
 static const struct dev_pm_ops sh_mmcif_dev_pm_ops = {
         .suspend = sh_mmcif_suspend,
         .resume = sh_mmcif_resume,
@@ -1443,6 +1500,8 @@ static struct platform_driver sh_mmcif_driver = {
         .driver         = {
                 .name   = DRIVER_NAME,
                 .pm     = &sh_mmcif_dev_pm_ops,
+                .owner  = THIS_MODULE,
+                .of_match_table = mmcif_of_match,
         },
 };
 
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index 934b68e9efc3..a842939e4655 100644
--- a/drivers/mmc/host/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -21,6 +21,7 @@
 #include <linux/kernel.h>
 #include <linux/clk.h>
 #include <linux/slab.h>
+#include <linux/mod_devicetable.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/mmc/host.h>
@@ -39,22 +40,39 @@ struct sh_mobile_sdhi {
         struct tmio_mmc_dma dma_priv;
 };
 
+static int sh_mobile_sdhi_clk_enable(struct platform_device *pdev, unsigned int *f)
+{
+        struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
+        int ret = clk_enable(priv->clk);
+        if (ret < 0)
+                return ret;
+
+        *f = clk_get_rate(priv->clk);
+        return 0;
+}
+
+static void sh_mobile_sdhi_clk_disable(struct platform_device *pdev)
+{
+        struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct sh_mobile_sdhi *priv = container_of(host->pdata, struct sh_mobile_sdhi, mmc_data);
+        clk_disable(priv->clk);
+}
+
 static void sh_mobile_sdhi_set_pwr(struct platform_device *pdev, int state)
 {
         struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
 
-        if (p && p->set_pwr)
-                p->set_pwr(pdev, state);
+        p->set_pwr(pdev, state);
 }
 
 static int sh_mobile_sdhi_get_cd(struct platform_device *pdev)
 {
         struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
 
-        if (p && p->get_cd)
-                return p->get_cd(pdev);
-        else
-                return -ENOSYS;
+        return p->get_cd(pdev);
 }
 
 static int sh_mobile_sdhi_wait_idle(struct tmio_mmc_host *host)
@@ -116,12 +134,14 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
         }
 
         mmc_data = &priv->mmc_data;
-        p->pdata = mmc_data;
 
-        if (p->init) {
-                ret = p->init(pdev, &sdhi_ops);
-                if (ret)
-                        goto einit;
+        if (p) {
+                p->pdata = mmc_data;
+                if (p->init) {
+                        ret = p->init(pdev, &sdhi_ops);
+                        if (ret)
+                                goto einit;
+                }
         }
 
         snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id);
@@ -132,9 +152,8 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
                 goto eclkget;
         }
 
-        mmc_data->hclk = clk_get_rate(priv->clk);
-        mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
-        mmc_data->get_cd = sh_mobile_sdhi_get_cd;
+        mmc_data->clk_enable = sh_mobile_sdhi_clk_enable;
+        mmc_data->clk_disable = sh_mobile_sdhi_clk_disable;
         mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
         if (p) {
                 mmc_data->flags = p->tmio_flags;
@@ -142,7 +161,12 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
                         mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
                 mmc_data->ocr_mask = p->tmio_ocr_mask;
                 mmc_data->capabilities |= p->tmio_caps;
+                mmc_data->capabilities2 |= p->tmio_caps2;
                 mmc_data->cd_gpio = p->cd_gpio;
+                if (p->set_pwr)
+                        mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
+                if (p->get_cd)
+                        mmc_data->get_cd = sh_mobile_sdhi_get_cd;
 
                 if (p->dma_slave_tx > 0 && p->dma_slave_rx > 0) {
                         priv->param_tx.slave_id = p->dma_slave_tx;
@@ -248,7 +272,7 @@ eirq_card_detect:
 eprobe:
         clk_put(priv->clk);
 eclkget:
-        if (p->cleanup)
+        if (p && p->cleanup)
                 p->cleanup(pdev);
 einit:
         kfree(priv);
@@ -263,7 +287,8 @@ static int sh_mobile_sdhi_remove(struct platform_device *pdev)
         struct sh_mobile_sdhi_info *p = pdev->dev.platform_data;
         int i = 0, irq;
 
-        p->pdata = NULL;
+        if (p)
+                p->pdata = NULL;
 
         tmio_mmc_host_remove(host);
 
@@ -276,7 +301,7 @@ static int sh_mobile_sdhi_remove(struct platform_device *pdev)
 
         clk_put(priv->clk);
 
-        if (p->cleanup)
+        if (p && p->cleanup)
                 p->cleanup(pdev);
 
         kfree(priv);
@@ -291,11 +316,18 @@ static const struct dev_pm_ops tmio_mmc_dev_pm_ops = {
         .runtime_resume = tmio_mmc_host_runtime_resume,
 };
 
+static const struct of_device_id sh_mobile_sdhi_of_match[] = {
+        { .compatible = "renesas,shmobile-sdhi" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, sh_mobile_sdhi_of_match);
+
 static struct platform_driver sh_mobile_sdhi_driver = {
         .driver         = {
                 .name   = "sh_mobile_sdhi",
                 .owner  = THIS_MODULE,
                 .pm     = &tmio_mmc_dev_pm_ops,
+                .of_match_table = sh_mobile_sdhi_of_match,
         },
         .probe          = sh_mobile_sdhi_probe,
         .remove         = __devexit_p(sh_mobile_sdhi_remove),
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index 9a7996ade58e..0d8a9bbe30be 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -34,8 +34,9 @@
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/mfd/tmio.h>
-#include <linux/mmc/cd-gpio.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/slot-gpio.h>
 #include <linux/mmc/tmio.h>
 #include <linux/module.h>
 #include <linux/pagemap.h>
@@ -305,8 +306,8 @@ static int tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command
         int c = cmd->opcode;
         u32 irq_mask = TMIO_MASK_CMD;
 
-        /* Command 12 is handled by hardware */
-        if (cmd->opcode == 12 && !cmd->arg) {
+        /* CMD12 is handled by hardware */
+        if (cmd->opcode == MMC_STOP_TRANSMISSION && !cmd->arg) {
                 sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x001);
                 return 0;
         }
@@ -449,7 +450,7 @@ void tmio_mmc_do_data_irq(struct tmio_mmc_host *host)
         }
 
         if (stop) {
-                if (stop->opcode == 12 && !stop->arg)
+                if (stop->opcode == MMC_STOP_TRANSMISSION && !stop->arg)
                         sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x000);
                 else
                         BUG();
@@ -751,6 +752,34 @@ fail:
         mmc_request_done(mmc, mrq);
 }
 
+static int tmio_mmc_clk_update(struct mmc_host *mmc)
+{
+        struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct tmio_mmc_data *pdata = host->pdata;
+        int ret;
+
+        if (!pdata->clk_enable)
+                return -ENOTSUPP;
+
+        ret = pdata->clk_enable(host->pdev, &mmc->f_max);
+        if (!ret)
+                mmc->f_min = mmc->f_max / 512;
+
+        return ret;
+}
+
+static void tmio_mmc_set_power(struct tmio_mmc_host *host, struct mmc_ios *ios)
+{
+        struct mmc_host *mmc = host->mmc;
+
+        if (host->set_pwr)
+                host->set_pwr(host->pdev, ios->power_mode != MMC_POWER_OFF);
+        if (!IS_ERR(mmc->supply.vmmc))
+                /* Errors ignored... */
+                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc,
+                                      ios->power_mode ? ios->vdd : 0);
+}
+
 /* Set MMC clock / power.
  * Note: This controller uses a simple divider scheme therefore it cannot
  * run a MMC card at full speed (20MHz). The max clock is 24MHz on SD, but as
@@ -797,32 +826,37 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
          */
         if (ios->power_mode == MMC_POWER_ON && ios->clock) {
                 if (!host->power) {
+                        tmio_mmc_clk_update(mmc);
                         pm_runtime_get_sync(dev);
                         host->power = true;
                 }
                 tmio_mmc_set_clock(host, ios->clock);
                 /* power up SD bus */
-                if (host->set_pwr)
-                        host->set_pwr(host->pdev, 1);
+                tmio_mmc_set_power(host, ios);
                 /* start bus clock */
                 tmio_mmc_clk_start(host);
         } 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 (ios->power_mode == MMC_POWER_OFF)
+                        tmio_mmc_set_power(host, ios);
                 if (host->power) {
+                        struct tmio_mmc_data *pdata = host->pdata;
+                        tmio_mmc_clk_stop(host);
                         host->power = false;
                         pm_runtime_put(dev);
+                        if (pdata->clk_disable)
+                                pdata->clk_disable(host->pdev);
                 }
-                tmio_mmc_clk_stop(host);
         }
 
-        switch (ios->bus_width) {
-        case MMC_BUS_WIDTH_1:
-                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
-        break;
-        case MMC_BUS_WIDTH_4:
-                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
-        break;
+        if (host->power) {
+                switch (ios->bus_width) {
+                case MMC_BUS_WIDTH_1:
+                        sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
+                break;
+                case MMC_BUS_WIDTH_4:
+                        sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
+                break;
+                }
         }
 
         /* Let things settle. delay taken from winCE driver */
@@ -841,6 +875,9 @@ static int tmio_mmc_get_ro(struct mmc_host *mmc)
 {
         struct tmio_mmc_host *host = mmc_priv(mmc);
         struct tmio_mmc_data *pdata = host->pdata;
+        int ret = mmc_gpio_get_ro(mmc);
+        if (ret >= 0)
+                return ret;
 
         return !((pdata->flags & TMIO_MMC_WRPROTECT_DISABLE) ||
                  (sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_WRPROTECT));
@@ -850,6 +887,9 @@ static int tmio_mmc_get_cd(struct mmc_host *mmc)
 {
         struct tmio_mmc_host *host = mmc_priv(mmc);
         struct tmio_mmc_data *pdata = host->pdata;
+        int ret = mmc_gpio_get_cd(mmc);
+        if (ret >= 0)
+                return ret;
 
         if (!pdata->get_cd)
                 return -ENOSYS;
@@ -865,6 +905,19 @@ static const struct mmc_host_ops tmio_mmc_ops = {
         .enable_sdio_irq = tmio_mmc_enable_sdio_irq,
 };
 
+static void tmio_mmc_init_ocr(struct tmio_mmc_host *host)
+{
+        struct tmio_mmc_data *pdata = host->pdata;
+        struct mmc_host *mmc = host->mmc;
+
+        mmc_regulator_get_supply(mmc);
+
+        if (!mmc->ocr_avail)
+                mmc->ocr_avail = pdata->ocr_mask ? : MMC_VDD_32_33 | MMC_VDD_33_34;
+        else if (pdata->ocr_mask)
+                dev_warn(mmc_dev(mmc), "Platform OCR mask is ignored\n");
+}
+
 int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
                                   struct platform_device *pdev,
                                   struct tmio_mmc_data *pdata)
@@ -904,18 +957,14 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
 
         mmc->ops = &tmio_mmc_ops;
         mmc->caps = MMC_CAP_4_BIT_DATA | pdata->capabilities;
-        mmc->f_max = pdata->hclk;
-        mmc->f_min = mmc->f_max / 512;
+        mmc->caps2 = pdata->capabilities2;
         mmc->max_segs = 32;
         mmc->max_blk_size = 512;
         mmc->max_blk_count = (PAGE_CACHE_SIZE / mmc->max_blk_size) *
                 mmc->max_segs;
         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
         mmc->max_seg_size = mmc->max_req_size;
-        if (pdata->ocr_mask)
-                mmc->ocr_avail = pdata->ocr_mask;
-        else
-                mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+        tmio_mmc_init_ocr(_host);
 
         _host->native_hotplug = !(pdata->flags & TMIO_MMC_USE_GPIO_CD ||
                                   mmc->caps & MMC_CAP_NEEDS_POLL ||
@@ -927,6 +976,11 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
         if (ret < 0)
                 goto pm_disable;
 
+        if (tmio_mmc_clk_update(mmc) < 0) {
+                mmc->f_max = pdata->hclk;
+                mmc->f_min = mmc->f_max / 512;
+        }
+
         /*
          * There are 4 different scenarios for the card detection:
          *  1) an external gpio irq handles the cd (best for power savings)
@@ -937,7 +991,6 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
          *  While we increment the runtime PM 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
-         *  additionally ensure that in case 2) the tmio mmc hardware stays
          *  powered on during runtime for the card detection to work.
          */
         if (_host->native_hotplug)
@@ -948,6 +1001,17 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
 
         _host->sdcard_irq_mask = sd_ctrl_read32(_host, CTL_IRQ_MASK);
         tmio_mmc_disable_mmc_irqs(_host, TMIO_MASK_ALL);
+
+        /* Unmask the IRQs we want to know about */
+        if (!_host->chan_rx)
+                irq_mask |= TMIO_MASK_READOP;
+        if (!_host->chan_tx)
+                irq_mask |= TMIO_MASK_WRITEOP;
+        if (!_host->native_hotplug)
+                irq_mask &= ~(TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT);
+
+        _host->sdcard_irq_mask &= ~irq_mask;
+
         if (pdata->flags & TMIO_MMC_SDIO_IRQ)
                 tmio_mmc_enable_sdio_irq(mmc, 0);
 
@@ -961,22 +1025,18 @@ int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
         /* See if we also get DMA */
         tmio_mmc_request_dma(_host, pdata);
 
-        mmc_add_host(mmc);
+        ret = mmc_add_host(mmc);
+        if (pdata->clk_disable)
+                pdata->clk_disable(pdev);
+        if (ret < 0) {
+                tmio_mmc_host_remove(_host);
+                return ret;
+        }
 
         dev_pm_qos_expose_latency_limit(&pdev->dev, 100);
 
-        /* Unmask the IRQs we want to know about */
-        if (!_host->chan_rx)
-                irq_mask |= TMIO_MASK_READOP;
-        if (!_host->chan_tx)
-                irq_mask |= TMIO_MASK_WRITEOP;
-        if (!_host->native_hotplug)
-                irq_mask &= ~(TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT);
-
-        tmio_mmc_enable_mmc_irqs(_host, irq_mask);
-
         if (pdata->flags & TMIO_MMC_USE_GPIO_CD) {
-                ret = mmc_cd_gpio_request(mmc, pdata->cd_gpio);
+                ret = mmc_gpio_request_cd(mmc, pdata->cd_gpio);
                 if (ret < 0) {
                         tmio_mmc_host_remove(_host);
                         return ret;
@@ -1008,7 +1068,7 @@ void tmio_mmc_host_remove(struct tmio_mmc_host *host)
                  * This means we can miss a card-eject, but this is anyway
                  * possible, because of delayed processing of hotplug events.
                  */
-                mmc_cd_gpio_free(mmc);
+                mmc_gpio_free_cd(mmc);
 
         if (!host->native_hotplug)
                 pm_runtime_get_sync(&pdev->dev);
diff --git a/drivers/mtd/mtdsuper.c b/drivers/mtd/mtdsuper.c
index a90bfe79916d..334da5f583c0 100644
--- a/drivers/mtd/mtdsuper.c
+++ b/drivers/mtd/mtdsuper.c
@@ -63,7 +63,7 @@ static struct dentry *mount_mtd_aux(struct file_system_type *fs_type, int flags,
         struct super_block *sb;
         int ret;
 
-        sb = sget(fs_type, get_sb_mtd_compare, get_sb_mtd_set, mtd);
+        sb = sget(fs_type, get_sb_mtd_compare, get_sb_mtd_set, flags, mtd);
         if (IS_ERR(sb))
                 goto out_error;
 
@@ -74,8 +74,6 @@ static struct dentry *mount_mtd_aux(struct file_system_type *fs_type, int flags,
         pr_debug("MTDSB: New superblock for device %d (\"%s\")\n",
               mtd->index, mtd->name);
 
-        sb->s_flags = flags;
-
         ret = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
         if (ret < 0) {
                 deactivate_locked_super(sb);
diff --git a/drivers/mtd/nand/cafe_nand.c b/drivers/mtd/nand/cafe_nand.c
index 41371ba1a811..f3f6cfedd69e 100644
--- a/drivers/mtd/nand/cafe_nand.c
+++ b/drivers/mtd/nand/cafe_nand.c
@@ -102,7 +102,7 @@ static const char *part_probes[] = { "cmdlinepart", "RedBoot", NULL };
 static int cafe_device_ready(struct mtd_info *mtd)
 {
         struct cafe_priv *cafe = mtd->priv;
-        int result = !!(cafe_readl(cafe, NAND_STATUS) | 0x40000000);
+        int result = !!(cafe_readl(cafe, NAND_STATUS) & 0x40000000);
         uint32_t irqs = cafe_readl(cafe, NAND_IRQ);
 
         cafe_writel(cafe, irqs, NAND_IRQ);
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
index a05b7b444d4f..a6cad5caba78 100644
--- a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
@@ -920,12 +920,12 @@ static int gpmi_ecc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
                  */
                 memset(chip->oob_poi, ~0, mtd->oobsize);
                 chip->oob_poi[0] = ((uint8_t *) auxiliary_virt)[0];
-
-                read_page_swap_end(this, buf, mtd->writesize,
-                                this->payload_virt, this->payload_phys,
-                                nfc_geo->payload_size,
-                                payload_virt, payload_phys);
         }
+
+        read_page_swap_end(this, buf, mtd->writesize,
+                        this->payload_virt, this->payload_phys,
+                        nfc_geo->payload_size,
+                        payload_virt, payload_phys);
 exit_nfc:
         return ret;
 }
diff --git a/drivers/mtd/nand/mxc_nand.c b/drivers/mtd/nand/mxc_nand.c
index c58e6a93f445..6acc790c2fbb 100644
--- a/drivers/mtd/nand/mxc_nand.c
+++ b/drivers/mtd/nand/mxc_nand.c
@@ -273,6 +273,26 @@ static struct nand_ecclayout nandv2_hw_eccoob_4k = {
 
 static const char *part_probes[] = { "RedBoot", "cmdlinepart", "ofpart", NULL };
 
+static void memcpy32_fromio(void *trg, const void __iomem  *src, size_t size)
+{
+        int i;
+        u32 *t = trg;
+        const __iomem u32 *s = src;
+
+        for (i = 0; i < (size >> 2); i++)
+                *t++ = __raw_readl(s++);
+}
+
+static void memcpy32_toio(void __iomem *trg, const void *src, int size)
+{
+        int i;
+        u32 __iomem *t = trg;
+        const u32 *s = src;
+
+        for (i = 0; i < (size >> 2); i++)
+                __raw_writel(*s++, t++);
+}
+
 static int check_int_v3(struct mxc_nand_host *host)
 {
         uint32_t tmp;
@@ -519,7 +539,7 @@ static void send_read_id_v3(struct mxc_nand_host *host)
 
         wait_op_done(host, true);
 
-        memcpy_fromio(host->data_buf, host->main_area0, 16);
+        memcpy32_fromio(host->data_buf, host->main_area0, 16);
 }
 
 /* Request the NANDFC to perform a read of the NAND device ID. */
@@ -535,7 +555,7 @@ static void send_read_id_v1_v2(struct mxc_nand_host *host)
         /* Wait for operation to complete */
         wait_op_done(host, true);
 
-        memcpy_fromio(host->data_buf, host->main_area0, 16);
+        memcpy32_fromio(host->data_buf, host->main_area0, 16);
 
         if (this->options & NAND_BUSWIDTH_16) {
                 /* compress the ID info */
@@ -797,16 +817,16 @@ static void copy_spare(struct mtd_info *mtd, bool bfrom)
 
         if (bfrom) {
                 for (i = 0; i < n - 1; i++)
-                        memcpy_fromio(d + i * j, s + i * t, j);
+                        memcpy32_fromio(d + i * j, s + i * t, j);
 
                 /* the last section */
-                memcpy_fromio(d + i * j, s + i * t, mtd->oobsize - i * j);
+                memcpy32_fromio(d + i * j, s + i * t, mtd->oobsize - i * j);
         } else {
                 for (i = 0; i < n - 1; i++)
-                        memcpy_toio(&s[i * t], &d[i * j], j);
+                        memcpy32_toio(&s[i * t], &d[i * j], j);
 
                 /* the last section */
-                memcpy_toio(&s[i * t], &d[i * j], mtd->oobsize - i * j);
+                memcpy32_toio(&s[i * t], &d[i * j], mtd->oobsize - i * j);
         }
 }
 
@@ -1070,7 +1090,8 @@ static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
 
                 host->devtype_data->send_page(mtd, NFC_OUTPUT);
 
-                memcpy_fromio(host->data_buf, host->main_area0, mtd->writesize);
+                memcpy32_fromio(host->data_buf, host->main_area0,
+                                mtd->writesize);
                 copy_spare(mtd, true);
                 break;
 
@@ -1086,7 +1107,7 @@ static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
                 break;
 
         case NAND_CMD_PAGEPROG:
-                memcpy_toio(host->main_area0, host->data_buf, mtd->writesize);
+                memcpy32_toio(host->main_area0, host->data_buf, mtd->writesize);
                 copy_spare(mtd, false);
                 host->devtype_data->send_page(mtd, NFC_INPUT);
                 host->devtype_data->send_cmd(host, command, true);
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index d47586cf64ce..a11253a0fcab 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -3501,6 +3501,13 @@ int nand_scan_tail(struct mtd_info *mtd)
         /* propagate ecc info to mtd_info */
         mtd->ecclayout = chip->ecc.layout;
         mtd->ecc_strength = chip->ecc.strength;
+        /*
+         * Initialize bitflip_threshold to its default prior scan_bbt() call.
+         * scan_bbt() might invoke mtd_read(), thus bitflip_threshold must be
+         * properly set.
+         */
+        if (!mtd->bitflip_threshold)
+                mtd->bitflip_threshold = mtd->ecc_strength;
 
         /* Check, if we should skip the bad block table scan */
         if (chip->options & NAND_SKIP_BBTSCAN)
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index 6cc8fbfabb8e..cf0cd3146817 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -28,7 +28,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/vmalloc.h>
-#include <asm/div64.h>
+#include <linux/math64.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/string.h>
@@ -546,12 +546,6 @@ static char *get_partition_name(int i)
         return kstrdup(buf, GFP_KERNEL);
 }
 
-static uint64_t divide(uint64_t n, uint32_t d)
-{
-        do_div(n, d);
-        return n;
-}
-
 /*
  * Initialize the nandsim structure.
  *
@@ -580,7 +574,7 @@ static int init_nandsim(struct mtd_info *mtd)
         ns->geom.oobsz    = mtd->oobsize;
         ns->geom.secsz    = mtd->erasesize;
         ns->geom.pgszoob  = ns->geom.pgsz + ns->geom.oobsz;
-        ns->geom.pgnum    = divide(ns->geom.totsz, ns->geom.pgsz);
+        ns->geom.pgnum    = div_u64(ns->geom.totsz, ns->geom.pgsz);
         ns->geom.totszoob = ns->geom.totsz + (uint64_t)ns->geom.pgnum * ns->geom.oobsz;
         ns->geom.secshift = ffs(ns->geom.secsz) - 1;
         ns->geom.pgshift  = chip->page_shift;
@@ -921,7 +915,7 @@ static int setup_wear_reporting(struct mtd_info *mtd)
 
         if (!rptwear)
                 return 0;
-        wear_eb_count = divide(mtd->size, mtd->erasesize);
+        wear_eb_count = div_u64(mtd->size, mtd->erasesize);
         mem = wear_eb_count * sizeof(unsigned long);
         if (mem / sizeof(unsigned long) != wear_eb_count) {
                 NS_ERR("Too many erase blocks for wear reporting\n");
diff --git a/drivers/mtd/ubi/Kconfig b/drivers/mtd/ubi/Kconfig
index 738ee8dc16cd..ea4b95b5451c 100644
--- a/drivers/mtd/ubi/Kconfig
+++ b/drivers/mtd/ubi/Kconfig
@@ -29,7 +29,7 @@ config MTD_UBI_WL_THRESHOLD
 
 config MTD_UBI_BEB_RESERVE
         int "Percentage of reserved eraseblocks for bad eraseblocks handling"
-        default 1
+        default 2
         range 0 25
         help
           If the MTD device admits of bad eraseblocks (e.g. NAND flash), UBI
diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index acec85deb6af..fb5567878181 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -1026,7 +1026,7 @@ static long ctrl_cdev_ioctl(struct file *file, unsigned int cmd,
         {
                 int ubi_num;
 
-                dbg_gen("dettach MTD device");
+                dbg_gen("detach MTD device");
                 err = get_user(ubi_num, (__user int32_t *)argp);
                 if (err) {
                         err = -EFAULT;
diff --git a/drivers/mtd/ubi/misc.c b/drivers/mtd/ubi/misc.c
index f6a7d7ac4b98..8bbfb444b895 100644
--- a/drivers/mtd/ubi/misc.c
+++ b/drivers/mtd/ubi/misc.c
@@ -92,7 +92,30 @@ int ubi_check_volume(struct ubi_device *ubi, int vol_id)
 }
 
 /**
- * ubi_calculate_rsvd_pool - calculate how many PEBs must be reserved for bad
+ * ubi_update_reserved - update bad eraseblock handling accounting data.
+ * @ubi: UBI device description object
+ *
+ * This function calculates the gap between current number of PEBs reserved for
+ * bad eraseblock handling and the required level of PEBs that must be
+ * reserved, and if necessary, reserves more PEBs to fill that gap, according
+ * to availability. Should be called with ubi->volumes_lock held.
+ */
+void ubi_update_reserved(struct ubi_device *ubi)
+{
+        int need = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
+
+        if (need <= 0 || ubi->avail_pebs == 0)
+                return;
+
+        need = min_t(int, need, ubi->avail_pebs);
+        ubi->avail_pebs -= need;
+        ubi->rsvd_pebs += need;
+        ubi->beb_rsvd_pebs += need;
+        ubi_msg("reserved more %d PEBs for bad PEB handling", need);
+}
+
+/**
+ * ubi_calculate_reserved - calculate how many PEBs must be reserved for bad
  * eraseblock handling.
  * @ubi: UBI device description object
  */
diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h
index a1a81c9ea8ce..84f66e3fa05d 100644
--- a/drivers/mtd/ubi/ubi.h
+++ b/drivers/mtd/ubi/ubi.h
@@ -647,6 +647,7 @@ int ubi_more_leb_change_data(struct ubi_device *ubi, struct ubi_volume *vol,
 int ubi_calc_data_len(const struct ubi_device *ubi, const void *buf,
                       int length);
 int ubi_check_volume(struct ubi_device *ubi, int vol_id);
+void ubi_update_reserved(struct ubi_device *ubi);
 void ubi_calculate_reserved(struct ubi_device *ubi);
 int ubi_check_pattern(const void *buf, uint8_t patt, int size);
 
diff --git a/drivers/mtd/ubi/vmt.c b/drivers/mtd/ubi/vmt.c
index 0669cff8ac3c..9169e58c262e 100644
--- a/drivers/mtd/ubi/vmt.c
+++ b/drivers/mtd/ubi/vmt.c
@@ -443,15 +443,7 @@ int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
         spin_lock(&ubi->volumes_lock);
         ubi->rsvd_pebs -= reserved_pebs;
         ubi->avail_pebs += reserved_pebs;
-        i = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
-        if (i > 0) {
-                i = ubi->avail_pebs >= i ? i : ubi->avail_pebs;
-                ubi->avail_pebs -= i;
-                ubi->rsvd_pebs += i;
-                ubi->beb_rsvd_pebs += i;
-                if (i > 0)
-                        ubi_msg("reserve more %d PEBs", i);
-        }
+        ubi_update_reserved(ubi);
         ubi->vol_count -= 1;
         spin_unlock(&ubi->volumes_lock);
 
@@ -558,15 +550,7 @@ int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs)
                 spin_lock(&ubi->volumes_lock);
                 ubi->rsvd_pebs += pebs;
                 ubi->avail_pebs -= pebs;
-                pebs = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
-                if (pebs > 0) {
-                        pebs = ubi->avail_pebs >= pebs ? pebs : ubi->avail_pebs;
-                        ubi->avail_pebs -= pebs;
-                        ubi->rsvd_pebs += pebs;
-                        ubi->beb_rsvd_pebs += pebs;
-                        if (pebs > 0)
-                                ubi_msg("reserve more %d PEBs", pebs);
-                }
+                ubi_update_reserved(ubi);
                 for (i = 0; i < reserved_pebs; i++)
                         new_mapping[i] = vol->eba_tbl[i];
                 kfree(vol->eba_tbl);
diff --git a/drivers/net/bonding/bond_debugfs.c b/drivers/net/bonding/bond_debugfs.c
index 3680aa251dea..2cf084eb9d52 100644
--- a/drivers/net/bonding/bond_debugfs.c
+++ b/drivers/net/bonding/bond_debugfs.c
@@ -6,7 +6,7 @@
 #include "bonding.h"
 #include "bond_alb.h"
 
-#ifdef CONFIG_DEBUG_FS
+#if defined(CONFIG_DEBUG_FS) && !defined(CONFIG_NET_NS)
 
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index b9c2ae62166d..2ee76993f052 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -3227,6 +3227,12 @@ static int bond_master_netdev_event(unsigned long event,
         switch (event) {
         case NETDEV_CHANGENAME:
                 return bond_event_changename(event_bond);
+        case NETDEV_UNREGISTER:
+                bond_remove_proc_entry(event_bond);
+                break;
+        case NETDEV_REGISTER:
+                bond_create_proc_entry(event_bond);
+                break;
         default:
                 break;
         }
@@ -4411,8 +4417,6 @@ static void bond_uninit(struct net_device *bond_dev)
 
         bond_work_cancel_all(bond);
 
-        bond_remove_proc_entry(bond);
-
         bond_debug_unregister(bond);
 
         __hw_addr_flush(&bond->mc_list);
@@ -4814,7 +4818,6 @@ static int bond_init(struct net_device *bond_dev)
 
         bond_set_lockdep_class(bond_dev);
 
-        bond_create_proc_entry(bond);
         list_add_tail(&bond->bond_list, &bn->dev_list);
 
         bond_prepare_sysfs_group(bond);
diff --git a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
index 9cc15701101b..1f78b63d5efe 100644
--- a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
+++ b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
@@ -261,7 +261,6 @@ static void atl1c_check_link_status(struct atl1c_adapter *adapter)
         if ((phy_data & BMSR_LSTATUS) == 0) {
                 /* link down */
                 netif_carrier_off(netdev);
-                netif_stop_queue(netdev);
                 hw->hibernate = true;
                 if (atl1c_reset_mac(hw) != 0)
                         if (netif_msg_hw(adapter))
diff --git a/drivers/net/ethernet/broadcom/b44.c b/drivers/net/ethernet/broadcom/b44.c
index 46b8b7d81633..d09c6b583d17 100644
--- a/drivers/net/ethernet/broadcom/b44.c
+++ b/drivers/net/ethernet/broadcom/b44.c
@@ -656,7 +656,7 @@ static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
                         dma_unmap_single(bp->sdev->dma_dev, mapping,
                                              RX_PKT_BUF_SZ, DMA_FROM_DEVICE);
                 dev_kfree_skb_any(skb);
-                skb = __netdev_alloc_skb(bp->dev, RX_PKT_BUF_SZ, GFP_ATOMIC|GFP_DMA);
+                skb = alloc_skb(RX_PKT_BUF_SZ, GFP_ATOMIC | GFP_DMA);
                 if (skb == NULL)
                         return -ENOMEM;
                 mapping = dma_map_single(bp->sdev->dma_dev, skb->data,
@@ -967,7 +967,7 @@ static netdev_tx_t b44_start_xmit(struct sk_buff *skb, struct net_device *dev)
                         dma_unmap_single(bp->sdev->dma_dev, mapping, len,
                                              DMA_TO_DEVICE);
 
-                bounce_skb = __netdev_alloc_skb(dev, len, GFP_ATOMIC | GFP_DMA);
+                bounce_skb = alloc_skb(len, GFP_ATOMIC | GFP_DMA);
                 if (!bounce_skb)
                         goto err_out;
 
diff --git a/drivers/net/ethernet/broadcom/bnx2.c b/drivers/net/ethernet/broadcom/bnx2.c
index ac7b74488531..1fa4927a45b1 100644
--- a/drivers/net/ethernet/broadcom/bnx2.c
+++ b/drivers/net/ethernet/broadcom/bnx2.c
@@ -5372,7 +5372,7 @@ bnx2_free_tx_skbs(struct bnx2 *bp)
                         int k, last;
 
                         if (skb == NULL) {
-                                j++;
+                                j = NEXT_TX_BD(j);
                                 continue;
                         }
 
@@ -5384,8 +5384,8 @@ bnx2_free_tx_skbs(struct bnx2 *bp)
                         tx_buf->skb = NULL;
 
                         last = tx_buf->nr_frags;
-                        j++;
-                        for (k = 0; k < last; k++, j++) {
+                        j = NEXT_TX_BD(j);
+                        for (k = 0; k < last; k++, j = NEXT_TX_BD(j)) {
                                 tx_buf = &txr->tx_buf_ring[TX_RING_IDX(j)];
                                 dma_unmap_page(&bp->pdev->dev,
                                         dma_unmap_addr(tx_buf, mapping),
diff --git a/drivers/net/ethernet/broadcom/cnic.c b/drivers/net/ethernet/broadcom/cnic.c
index c95e7b5e2b85..2c89d17cbb29 100644
--- a/drivers/net/ethernet/broadcom/cnic.c
+++ b/drivers/net/ethernet/broadcom/cnic.c
@@ -534,7 +534,8 @@ int cnic_unregister_driver(int ulp_type)
         }
 
         if (atomic_read(&ulp_ops->ref_count) != 0)
-                netdev_warn(dev->netdev, "Failed waiting for ref count to go to zero\n");
+                pr_warn("%s: Failed waiting for ref count to go to zero\n",
+                        __func__);
         return 0;
 
 out_unlock:
@@ -1053,12 +1054,13 @@ static int cnic_init_uio(struct cnic_dev *dev)
 
         uinfo = &udev->cnic_uinfo;
 
-        uinfo->mem[0].addr = dev->netdev->base_addr;
+        uinfo->mem[0].addr = pci_resource_start(dev->pcidev, 0);
         uinfo->mem[0].internal_addr = dev->regview;
-        uinfo->mem[0].size = dev->netdev->mem_end - dev->netdev->mem_start;
         uinfo->mem[0].memtype = UIO_MEM_PHYS;
 
         if (test_bit(CNIC_F_BNX2_CLASS, &dev->flags)) {
+                uinfo->mem[0].size = MB_GET_CID_ADDR(TX_TSS_CID +
+                                                     TX_MAX_TSS_RINGS + 1);
                 uinfo->mem[1].addr = (unsigned long) cp->status_blk.gen &
                                         PAGE_MASK;
                 if (cp->ethdev->drv_state & CNIC_DRV_STATE_USING_MSIX)
@@ -1068,6 +1070,8 @@ static int cnic_init_uio(struct cnic_dev *dev)
 
                 uinfo->name = "bnx2_cnic";
         } else if (test_bit(CNIC_F_BNX2X_CLASS, &dev->flags)) {
+                uinfo->mem[0].size = pci_resource_len(dev->pcidev, 0);
+
                 uinfo->mem[1].addr = (unsigned long) cp->bnx2x_def_status_blk &
                         PAGE_MASK;
                 uinfo->mem[1].size = sizeof(*cp->bnx2x_def_status_blk);
diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
index 0741aded9eb0..ab1d80ff0791 100644
--- a/drivers/net/ethernet/freescale/gianfar.c
+++ b/drivers/net/ethernet/freescale/gianfar.c
@@ -1804,18 +1804,16 @@ void gfar_configure_coalescing(struct gfar_private *priv,
         if (priv->mode == MQ_MG_MODE) {
                 baddr = &regs->txic0;
                 for_each_set_bit(i, &tx_mask, priv->num_tx_queues) {
-                        if (likely(priv->tx_queue[i]->txcoalescing)) {
-                                gfar_write(baddr + i, 0);
+                        gfar_write(baddr + i, 0);
+                        if (likely(priv->tx_queue[i]->txcoalescing))
                                 gfar_write(baddr + i, priv->tx_queue[i]->txic);
-                        }
                 }
 
                 baddr = &regs->rxic0;
                 for_each_set_bit(i, &rx_mask, priv->num_rx_queues) {
-                        if (likely(priv->rx_queue[i]->rxcoalescing)) {
-                                gfar_write(baddr + i, 0);
+                        gfar_write(baddr + i, 0);
+                        if (likely(priv->rx_queue[i]->rxcoalescing))
                                 gfar_write(baddr + i, priv->rx_queue[i]->rxic);
-                        }
                 }
         }
 }
@@ -2065,10 +2063,9 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
                         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);
+                if (skb->sk)
+                        skb_set_owner_w(skb_new, skb->sk);
+                consume_skb(skb);
                 skb = skb_new;
         }
 
diff --git a/drivers/net/ethernet/intel/e1000e/82571.c b/drivers/net/ethernet/intel/e1000e/82571.c
index 36db4df09aed..1f063dcd8f85 100644
--- a/drivers/net/ethernet/intel/e1000e/82571.c
+++ b/drivers/net/ethernet/intel/e1000e/82571.c
@@ -1572,6 +1572,9 @@ static s32 e1000_check_for_serdes_link_82571(struct e1000_hw *hw)
         ctrl = er32(CTRL);
         status = er32(STATUS);
         rxcw = er32(RXCW);
+        /* SYNCH bit and IV bit are sticky */
+        udelay(10);
+        rxcw = er32(RXCW);
 
         if ((rxcw & E1000_RXCW_SYNCH) && !(rxcw & E1000_RXCW_IV)) {
 
diff --git a/drivers/net/ethernet/intel/e1000e/defines.h b/drivers/net/ethernet/intel/e1000e/defines.h
index 351a4097b2ba..76edbc1be33b 100644
--- a/drivers/net/ethernet/intel/e1000e/defines.h
+++ b/drivers/net/ethernet/intel/e1000e/defines.h
@@ -103,6 +103,7 @@
 #define E1000_RXD_ERR_SEQ       0x04    /* Sequence Error */
 #define E1000_RXD_ERR_CXE       0x10    /* Carrier Extension Error */
 #define E1000_RXD_ERR_TCPE      0x20    /* TCP/UDP Checksum Error */
+#define E1000_RXD_ERR_IPE       0x40    /* IP Checksum Error */
 #define E1000_RXD_ERR_RXE       0x80    /* Rx Data Error */
 #define E1000_RXD_SPC_VLAN_MASK 0x0FFF  /* VLAN ID is in lower 12 bits */
 
diff --git a/drivers/net/ethernet/intel/e1000e/ich8lan.c b/drivers/net/ethernet/intel/e1000e/ich8lan.c
index 238ab2f8a5e7..e3a7b07df629 100644
--- a/drivers/net/ethernet/intel/e1000e/ich8lan.c
+++ b/drivers/net/ethernet/intel/e1000e/ich8lan.c
@@ -325,24 +325,46 @@ static inline void __ew32flash(struct e1000_hw *hw, unsigned long reg, u32 val)
  **/
 static bool e1000_phy_is_accessible_pchlan(struct e1000_hw *hw)
 {
-        u16 phy_reg;
-        u32 phy_id;
+        u16 phy_reg = 0;
+        u32 phy_id = 0;
+        s32 ret_val;
+        u16 retry_count;
+
+        for (retry_count = 0; retry_count < 2; retry_count++) {
+                ret_val = e1e_rphy_locked(hw, PHY_ID1, &phy_reg);
+                if (ret_val || (phy_reg == 0xFFFF))
+                        continue;
+                phy_id = (u32)(phy_reg << 16);
 
-        e1e_rphy_locked(hw, PHY_ID1, &phy_reg);
-        phy_id = (u32)(phy_reg << 16);
-        e1e_rphy_locked(hw, PHY_ID2, &phy_reg);
-        phy_id |= (u32)(phy_reg & PHY_REVISION_MASK);
+                ret_val = e1e_rphy_locked(hw, PHY_ID2, &phy_reg);
+                if (ret_val || (phy_reg == 0xFFFF)) {
+                        phy_id = 0;
+                        continue;
+                }
+                phy_id |= (u32)(phy_reg & PHY_REVISION_MASK);
+                break;
+        }
 
         if (hw->phy.id) {
                 if (hw->phy.id == phy_id)
                         return true;
-        } else {
-                if ((phy_id != 0) && (phy_id != PHY_REVISION_MASK))
-                        hw->phy.id = phy_id;
+        } else if (phy_id) {
+                hw->phy.id = phy_id;
+                hw->phy.revision = (u32)(phy_reg & ~PHY_REVISION_MASK);
                 return true;
         }
 
-        return false;
+        /*
+         * In case the PHY needs to be in mdio slow mode,
+         * set slow mode and try to get the PHY id again.
+         */
+        hw->phy.ops.release(hw);
+        ret_val = e1000_set_mdio_slow_mode_hv(hw);
+        if (!ret_val)
+                ret_val = e1000e_get_phy_id(hw);
+        hw->phy.ops.acquire(hw);
+
+        return !ret_val;
 }
 
 /**
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 31d37a2b5ba8..623e30b9964d 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -496,7 +496,7 @@ static void e1000_receive_skb(struct e1000_adapter *adapter,
  * @sk_buff: socket buffer with received data
  **/
 static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
-                              __le16 csum, struct sk_buff *skb)
+                              struct sk_buff *skb)
 {
         u16 status = (u16)status_err;
         u8 errors = (u8)(status_err >> 24);
@@ -511,8 +511,8 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
         if (status & E1000_RXD_STAT_IXSM)
                 return;
 
-        /* TCP/UDP checksum error bit is set */
-        if (errors & E1000_RXD_ERR_TCPE) {
+        /* TCP/UDP checksum error bit or IP checksum error bit is set */
+        if (errors & (E1000_RXD_ERR_TCPE | E1000_RXD_ERR_IPE)) {
                 /* let the stack verify checksum errors */
                 adapter->hw_csum_err++;
                 return;
@@ -523,19 +523,7 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
                 return;
 
         /* It must be a TCP or UDP packet with a valid checksum */
-        if (status & E1000_RXD_STAT_TCPCS) {
-                /* TCP checksum is good */
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-        } else {
-                /*
-                 * IP fragment with UDP payload
-                 * Hardware complements the payload checksum, so we undo it
-                 * and then put the value in host order for further stack use.
-                 */
-                __sum16 sum = (__force __sum16)swab16((__force u16)csum);
-                skb->csum = csum_unfold(~sum);
-                skb->ip_summed = CHECKSUM_COMPLETE;
-        }
+        skb->ip_summed = CHECKSUM_UNNECESSARY;
         adapter->hw_csum_good++;
 }
 
@@ -954,8 +942,7 @@ static bool e1000_clean_rx_irq(struct e1000_ring *rx_ring, int *work_done,
                 skb_put(skb, length);
 
                 /* Receive Checksum Offload */
-                e1000_rx_checksum(adapter, staterr,
-                                  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);
+                e1000_rx_checksum(adapter, staterr, skb);
 
                 e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
 
@@ -1341,8 +1328,7 @@ copydone:
                 total_rx_bytes += skb->len;
                 total_rx_packets++;
 
-                e1000_rx_checksum(adapter, staterr,
-                                  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);
+                e1000_rx_checksum(adapter, staterr, skb);
 
                 e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
 
@@ -1512,9 +1498,8 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_ring *rx_ring, int *work_done,
                         }
                 }
 
-                /* Receive Checksum Offload XXX recompute due to CRC strip? */
-                e1000_rx_checksum(adapter, staterr,
-                                  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);
+                /* Receive Checksum Offload */
+                e1000_rx_checksum(adapter, staterr, skb);
 
                 e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
 
@@ -3098,19 +3083,10 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
 
         /* Enable Receive Checksum Offload for TCP and UDP */
         rxcsum = er32(RXCSUM);
-        if (adapter->netdev->features & NETIF_F_RXCSUM) {
+        if (adapter->netdev->features & NETIF_F_RXCSUM)
                 rxcsum |= E1000_RXCSUM_TUOFL;
-
-                /*
-                 * IPv4 payload checksum for UDP fragments must be
-                 * used in conjunction with packet-split.
-                 */
-                if (adapter->rx_ps_pages)
-                        rxcsum |= E1000_RXCSUM_IPPCSE;
-        } else {
+        else
                 rxcsum &= ~E1000_RXCSUM_TUOFL;
-                /* no need to clear IPPCSE as it defaults to 0 */
-        }
         ew32(RXCSUM, rxcsum);
 
         if (adapter->hw.mac.type == e1000_pch2lan) {
@@ -5241,22 +5217,10 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
         int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
 
         /* Jumbo frame support */
-        if (max_frame > ETH_FRAME_LEN + ETH_FCS_LEN) {
-                if (!(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) {
-                        e_err("Jumbo Frames not supported.\n");
-                        return -EINVAL;
-                }
-
-                /*
-                 * IP payload checksum (enabled with jumbos/packet-split when
-                 * Rx checksum is enabled) and generation of RSS hash is
-                 * mutually exclusive in the hardware.
-                 */
-                if ((netdev->features & NETIF_F_RXCSUM) &&
-                    (netdev->features & NETIF_F_RXHASH)) {
-                        e_err("Jumbo frames cannot be enabled when both receive checksum offload and receive hashing are enabled.  Disable one of the receive offload features before enabling jumbos.\n");
-                        return -EINVAL;
-                }
+        if ((max_frame > ETH_FRAME_LEN + ETH_FCS_LEN) &&
+            !(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) {
+                e_err("Jumbo Frames not supported.\n");
+                return -EINVAL;
         }
 
         /* Supported frame sizes */
@@ -6030,17 +5994,6 @@ static int e1000_set_features(struct net_device *netdev,
                          NETIF_F_RXALL)))
                 return 0;
 
-        /*
-         * IP payload checksum (enabled with jumbos/packet-split when Rx
-         * checksum is enabled) and generation of RSS hash is mutually
-         * exclusive in the hardware.
-         */
-        if (adapter->rx_ps_pages &&
-            (features & NETIF_F_RXCSUM) && (features & NETIF_F_RXHASH)) {
-                e_err("Enabling both receive checksum offload and receive hashing is not possible with jumbo frames.  Disable jumbos or enable only one of the receive offload features.\n");
-                return -EINVAL;
-        }
-
         if (changed & NETIF_F_RXFCS) {
                 if (features & NETIF_F_RXFCS) {
                         adapter->flags2 &= ~FLAG2_CRC_STRIPPING;
diff --git a/drivers/net/ethernet/intel/igbvf/ethtool.c b/drivers/net/ethernet/intel/igbvf/ethtool.c
index 8ce67064b9c5..90eef07943f4 100644
--- a/drivers/net/ethernet/intel/igbvf/ethtool.c
+++ b/drivers/net/ethernet/intel/igbvf/ethtool.c
@@ -357,21 +357,28 @@ static int igbvf_set_coalesce(struct net_device *netdev,
         struct igbvf_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
 
-        if ((ec->rx_coalesce_usecs > IGBVF_MAX_ITR_USECS) ||
-            ((ec->rx_coalesce_usecs > 3) &&
-             (ec->rx_coalesce_usecs < IGBVF_MIN_ITR_USECS)) ||
-            (ec->rx_coalesce_usecs == 2))
-                return -EINVAL;
-
-        /* convert to rate of irq's per second */
-        if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) {
+        if ((ec->rx_coalesce_usecs >= IGBVF_MIN_ITR_USECS) &&
+             (ec->rx_coalesce_usecs <= IGBVF_MAX_ITR_USECS)) {
+                adapter->current_itr = ec->rx_coalesce_usecs << 2;
+                adapter->requested_itr = 1000000000 /
+                                        (adapter->current_itr * 256);
+        } else if ((ec->rx_coalesce_usecs == 3) ||
+                   (ec->rx_coalesce_usecs == 2)) {
                 adapter->current_itr = IGBVF_START_ITR;
                 adapter->requested_itr = ec->rx_coalesce_usecs;
-        } else {
-                adapter->current_itr = ec->rx_coalesce_usecs << 2;
+        } else if (ec->rx_coalesce_usecs == 0) {
+                /*
+                 * The user's desire is to turn off interrupt throttling
+                 * altogether, but due to HW limitations, we can't do that.
+                 * Instead we set a very small value in EITR, which would
+                 * allow ~967k interrupts per second, but allow the adapter's
+                 * internal clocking to still function properly.
+                 */
+                adapter->current_itr = 4;
                 adapter->requested_itr = 1000000000 /
                                         (adapter->current_itr * 256);
-        }
+        } else
+                return -EINVAL;
 
         writel(adapter->current_itr,
                hw->hw_addr + adapter->rx_ring->itr_register);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index 18ca3bcadf0c..e242104ab471 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -6647,6 +6647,11 @@ int ixgbe_setup_tc(struct net_device *dev, u8 tc)
                 return -EINVAL;
         }
 
+        if (adapter->flags & IXGBE_FLAG_SRIOV_ENABLED) {
+                e_err(drv, "Enable failed, SR-IOV enabled\n");
+                return -EINVAL;
+        }
+
         /* Hardware supports up to 8 traffic classes */
         if (tc > adapter->dcb_cfg.num_tcs.pg_tcs ||
             (hw->mac.type == ixgbe_mac_82598EB &&
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
index f69ec4288b10..41e32257a4e8 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
@@ -201,6 +201,9 @@ static bool ixgbevf_clean_tx_irq(struct ixgbevf_adapter *adapter,
         unsigned int i, eop, count = 0;
         unsigned int total_bytes = 0, total_packets = 0;
 
+        if (test_bit(__IXGBEVF_DOWN, &adapter->state))
+                return true;
+
         i = tx_ring->next_to_clean;
         eop = tx_ring->tx_buffer_info[i].next_to_watch;
         eop_desc = IXGBE_TX_DESC_ADV(*tx_ring, eop);
@@ -969,8 +972,6 @@ static irqreturn_t ixgbevf_msix_clean_tx(int irq, void *data)
         r_idx = find_first_bit(q_vector->txr_idx, adapter->num_tx_queues);
         for (i = 0; i < q_vector->txr_count; i++) {
                 tx_ring = &(adapter->tx_ring[r_idx]);
-                tx_ring->total_bytes = 0;
-                tx_ring->total_packets = 0;
                 ixgbevf_clean_tx_irq(adapter, tx_ring);
                 r_idx = find_next_bit(q_vector->txr_idx, adapter->num_tx_queues,
                                       r_idx + 1);
@@ -994,16 +995,6 @@ static irqreturn_t ixgbevf_msix_clean_rx(int irq, void *data)
         struct ixgbe_hw *hw = &adapter->hw;
         struct ixgbevf_ring  *rx_ring;
         int r_idx;
-        int i;
-
-        r_idx = find_first_bit(q_vector->rxr_idx, adapter->num_rx_queues);
-        for (i = 0; i < q_vector->rxr_count; i++) {
-                rx_ring = &(adapter->rx_ring[r_idx]);
-                rx_ring->total_bytes = 0;
-                rx_ring->total_packets = 0;
-                r_idx = find_next_bit(q_vector->rxr_idx, adapter->num_rx_queues,
-                                      r_idx + 1);
-        }
 
         if (!q_vector->rxr_count)
                 return IRQ_HANDLED;
diff --git a/drivers/net/ethernet/stmicro/stmmac/ring_mode.c b/drivers/net/ethernet/stmicro/stmmac/ring_mode.c
index fb8377da1687..4b785e10f2ed 100644
--- a/drivers/net/ethernet/stmicro/stmmac/ring_mode.c
+++ b/drivers/net/ethernet/stmicro/stmmac/ring_mode.c
@@ -51,7 +51,7 @@ static unsigned int stmmac_jumbo_frm(void *p, struct sk_buff *skb, int csum)
                 desc->des3 = desc->des2 + BUF_SIZE_4KiB;
                 priv->hw->desc->prepare_tx_desc(desc, 1, bmax,
                                                 csum);
-
+                wmb();
                 entry = (++priv->cur_tx) % txsize;
                 desc = priv->dma_tx + entry;
 
@@ -59,6 +59,7 @@ static unsigned int stmmac_jumbo_frm(void *p, struct sk_buff *skb, int csum)
                                             len, DMA_TO_DEVICE);
                 desc->des3 = desc->des2 + BUF_SIZE_4KiB;
                 priv->hw->desc->prepare_tx_desc(desc, 0, len, csum);
+                wmb();
                 priv->hw->desc->set_tx_owner(desc);
                 priv->tx_skbuff[entry] = NULL;
         } else {
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index 51b3b68528ee..ea3003edde18 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -1212,6 +1212,7 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
                 priv->hw->desc->prepare_tx_desc(desc, 0, len, csum_insertion);
                 wmb();
                 priv->hw->desc->set_tx_owner(desc);
+                wmb();
         }
 
         /* Interrupt on completition only for the latest segment */
@@ -1227,6 +1228,7 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
 
         /* To avoid raise condition */
         priv->hw->desc->set_tx_owner(first);
+        wmb();
 
         priv->cur_tx++;
 
@@ -1290,6 +1292,7 @@ static inline void stmmac_rx_refill(struct stmmac_priv *priv)
                 }
                 wmb();
                 priv->hw->desc->set_rx_owner(p + entry);
+                wmb();
         }
 }
 
diff --git a/drivers/net/ethernet/ti/davinci_cpdma.c b/drivers/net/ethernet/ti/davinci_cpdma.c
index d614c374ed9d..3b5c4571b55e 100644
--- a/drivers/net/ethernet/ti/davinci_cpdma.c
+++ b/drivers/net/ethernet/ti/davinci_cpdma.c
@@ -15,6 +15,7 @@
 #include <linux/kernel.h>
 #include <linux/spinlock.h>
 #include <linux/device.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/dma-mapping.h>
diff --git a/drivers/net/phy/mdio-mux.c b/drivers/net/phy/mdio-mux.c
index 39ea0674dcde..5c120189ec86 100644
--- a/drivers/net/phy/mdio-mux.c
+++ b/drivers/net/phy/mdio-mux.c
@@ -46,7 +46,13 @@ static int mdio_mux_read(struct mii_bus *bus, int phy_id, int regnum)
         struct mdio_mux_parent_bus *pb = cb->parent;
         int r;
 
-        mutex_lock(&pb->mii_bus->mdio_lock);
+        /* In theory multiple mdio_mux could be stacked, thus creating
+         * more than a single level of nesting.  But in practice,
+         * SINGLE_DEPTH_NESTING will cover the vast majority of use
+         * cases.  We use it, instead of trying to handle the general
+         * case.
+         */
+        mutex_lock_nested(&pb->mii_bus->mdio_lock, SINGLE_DEPTH_NESTING);
         r = pb->switch_fn(pb->current_child, cb->bus_number, pb->switch_data);
         if (r)
                 goto out;
@@ -71,7 +77,7 @@ static int mdio_mux_write(struct mii_bus *bus, int phy_id,
 
         int r;
 
-        mutex_lock(&pb->mii_bus->mdio_lock);
+        mutex_lock_nested(&pb->mii_bus->mdio_lock, SINGLE_DEPTH_NESTING);
         r = pb->switch_fn(pb->current_child, cb->bus_number, pb->switch_data);
         if (r)
                 goto out;
diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
index 3767a1225860..a051cedd64bd 100644
--- a/drivers/net/usb/qmi_wwan.c
+++ b/drivers/net/usb/qmi_wwan.c
@@ -197,6 +197,10 @@ err:
 static int qmi_wwan_cdc_wdm_manage_power(struct usb_interface *intf, int on)
 {
         struct usbnet *dev = usb_get_intfdata(intf);
+
+        /* can be called while disconnecting */
+        if (!dev)
+                return 0;
         return qmi_wwan_manage_power(dev, on);
 }
 
@@ -342,6 +346,15 @@ static const struct driver_info	qmi_wwan_force_int1 = {
         .data           = BIT(1), /* interface whitelist bitmap */
 };
 
+static const struct driver_info qmi_wwan_force_int2 = {
+        .description    = "Qualcomm WWAN/QMI device",
+        .flags          = FLAG_WWAN,
+        .bind           = qmi_wwan_bind_shared,
+        .unbind         = qmi_wwan_unbind_shared,
+        .manage_power   = qmi_wwan_manage_power,
+        .data           = BIT(2), /* interface whitelist bitmap */
+};
+
 static const struct driver_info qmi_wwan_force_int3 = {
         .description    = "Qualcomm WWAN/QMI device",
         .flags          = FLAG_WWAN,
@@ -494,6 +507,15 @@ static const struct usb_device_id products[] = {
                 .bInterfaceProtocol = 0xff,
                 .driver_info        = (unsigned long)&qmi_wwan_force_int4,
         },
+        {       /* ZTE MF60 */
+                .match_flags        = USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_INT_INFO,
+                .idVendor           = 0x19d2,
+                .idProduct          = 0x1402,
+                .bInterfaceClass    = 0xff,
+                .bInterfaceSubClass = 0xff,
+                .bInterfaceProtocol = 0xff,
+                .driver_info        = (unsigned long)&qmi_wwan_force_int2,
+        },
         {       /* Sierra Wireless MC77xx in QMI mode */
                 .match_flags        = USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_INT_INFO,
                 .idVendor           = 0x1199,
diff --git a/drivers/net/wireless/ath/ath.h b/drivers/net/wireless/ath/ath.h
index c54b7d37bff1..420d69b2674c 100644
--- a/drivers/net/wireless/ath/ath.h
+++ b/drivers/net/wireless/ath/ath.h
@@ -143,6 +143,7 @@ struct ath_common {
         u32 keymax;
         DECLARE_BITMAP(keymap, ATH_KEYMAX);
         DECLARE_BITMAP(tkip_keymap, ATH_KEYMAX);
+        DECLARE_BITMAP(ccmp_keymap, ATH_KEYMAX);
         enum ath_crypt_caps crypt_caps;
 
         unsigned int clockrate;
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index 1c68e564f503..995ca8e1302e 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -622,7 +622,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
 
         if (NR_CPUS > 1 && ah->config.serialize_regmode == SER_REG_MODE_AUTO) {
                 if (ah->hw_version.macVersion == AR_SREV_VERSION_5416_PCI ||
-                    ((AR_SREV_9160(ah) || AR_SREV_9280(ah)) &&
+                    ((AR_SREV_9160(ah) || AR_SREV_9280(ah) || AR_SREV_9287(ah)) &&
                      !ah->is_pciexpress)) {
                         ah->config.serialize_regmode =
                                 SER_REG_MODE_ON;
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index e1fcc68124dc..0735aeb3b26c 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -695,9 +695,9 @@ static bool ath_edma_get_buffers(struct ath_softc *sc,
                         __skb_unlink(skb, &rx_edma->rx_fifo);
                         list_add_tail(&bf->list, &sc->rx.rxbuf);
                         ath_rx_edma_buf_link(sc, qtype);
-                } else {
-                        bf = NULL;
                 }
+
+                bf = NULL;
         }
 
         *dest = bf;
@@ -822,7 +822,8 @@ static bool ath9k_rx_accept(struct ath_common *common,
          * descriptor does contain a valid key index. This has been observed
          * mostly with CCMP encryption.
          */
-        if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID)
+        if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID ||
+            !test_bit(rx_stats->rs_keyix, common->ccmp_keymap))
                 rx_stats->rs_status &= ~ATH9K_RXERR_KEYMISS;
 
         if (!rx_stats->rs_datalen) {
diff --git a/drivers/net/wireless/ath/key.c b/drivers/net/wireless/ath/key.c
index 0e81904956cf..5c54aa43ca2d 100644
--- a/drivers/net/wireless/ath/key.c
+++ b/drivers/net/wireless/ath/key.c
@@ -556,6 +556,9 @@ int ath_key_config(struct ath_common *common,
                 return -EIO;
 
         set_bit(idx, common->keymap);
+        if (key->cipher == WLAN_CIPHER_SUITE_CCMP)
+                set_bit(idx, common->ccmp_keymap);
+
         if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
                 set_bit(idx + 64, common->keymap);
                 set_bit(idx, common->tkip_keymap);
@@ -582,6 +585,7 @@ void ath_key_delete(struct ath_common *common, struct ieee80211_key_conf *key)
                 return;
 
         clear_bit(key->hw_key_idx, common->keymap);
+        clear_bit(key->hw_key_idx, common->ccmp_keymap);
         if (key->cipher != WLAN_CIPHER_SUITE_TKIP)
                 return;
 
diff --git a/drivers/net/wireless/b43legacy/dma.c b/drivers/net/wireless/b43legacy/dma.c
index f1f8bd09bd87..c8baf020c20f 100644
--- a/drivers/net/wireless/b43legacy/dma.c
+++ b/drivers/net/wireless/b43legacy/dma.c
@@ -1072,7 +1072,7 @@ static int dma_tx_fragment(struct b43legacy_dmaring *ring,
         meta->dmaaddr = map_descbuffer(ring, skb->data, skb->len, 1);
         /* create a bounce buffer in zone_dma on mapping failure. */
         if (b43legacy_dma_mapping_error(ring, meta->dmaaddr, skb->len, 1)) {
-                bounce_skb = __dev_alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
+                bounce_skb = alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA);
                 if (!bounce_skb) {
                         ring->current_slot = old_top_slot;
                         ring->used_slots = old_used_slots;
diff --git a/drivers/net/wireless/iwlegacy/4965-mac.c b/drivers/net/wireless/iwlegacy/4965-mac.c
index 509301a5e7e2..ff5d689e13f3 100644
--- a/drivers/net/wireless/iwlegacy/4965-mac.c
+++ b/drivers/net/wireless/iwlegacy/4965-mac.c
@@ -3405,7 +3405,7 @@ il4965_remove_dynamic_key(struct il_priv *il,
                 return 0;
         }
 
-        if (il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET) {
+        if (il->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_INVALID) {
                 IL_WARN("Removing wrong key %d 0x%x\n", keyconf->keyidx,
                         key_flags);
                 spin_unlock_irqrestore(&il->sta_lock, flags);
@@ -3420,7 +3420,7 @@ il4965_remove_dynamic_key(struct il_priv *il,
         memset(&il->stations[sta_id].sta.key, 0, sizeof(struct il4965_keyinfo));
         il->stations[sta_id].sta.key.key_flags =
             STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
-        il->stations[sta_id].sta.key.key_offset = WEP_INVALID_OFFSET;
+        il->stations[sta_id].sta.key.key_offset = keyconf->hw_key_idx;
         il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
         il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
 
diff --git a/drivers/net/wireless/iwlegacy/common.c b/drivers/net/wireless/iwlegacy/common.c
index cbf2dc18341f..5d4807c2b56d 100644
--- a/drivers/net/wireless/iwlegacy/common.c
+++ b/drivers/net/wireless/iwlegacy/common.c
@@ -4767,14 +4767,12 @@ il_bg_watchdog(unsigned long data)
                 return;
 
         /* monitor and check for other stuck queues */
-        if (il_is_any_associated(il)) {
-                for (cnt = 0; cnt < il->hw_params.max_txq_num; cnt++) {
-                        /* skip as we already checked the command queue */
-                        if (cnt == il->cmd_queue)
-                                continue;
-                        if (il_check_stuck_queue(il, cnt))
-                                return;
-                }
+        for (cnt = 0; cnt < il->hw_params.max_txq_num; cnt++) {
+                /* skip as we already checked the command queue */
+                if (cnt == il->cmd_queue)
+                        continue;
+                if (il_check_stuck_queue(il, cnt))
+                        return;
         }
 
         mod_timer(&il->watchdog,
diff --git a/drivers/net/wireless/iwlwifi/iwl-mac80211.c b/drivers/net/wireless/iwlwifi/iwl-mac80211.c
index 3ee23134c02b..013680332f07 100644
--- a/drivers/net/wireless/iwlwifi/iwl-mac80211.c
+++ b/drivers/net/wireless/iwlwifi/iwl-mac80211.c
@@ -796,6 +796,18 @@ int iwlagn_mac_sta_state(struct ieee80211_hw *hw,
         switch (op) {
         case ADD:
                 ret = iwlagn_mac_sta_add(hw, vif, sta);
+                if (ret)
+                        break;
+                /*
+                 * Clear the in-progress flag, the AP station entry was added
+                 * but we'll initialize LQ only when we've associated (which
+                 * would also clear the in-progress flag). This is necessary
+                 * in case we never initialize LQ because association fails.
+                 */
+                spin_lock_bh(&priv->sta_lock);
+                priv->stations[iwl_sta_id(sta)].used &=
+                        ~IWL_STA_UCODE_INPROGRESS;
+                spin_unlock_bh(&priv->sta_lock);
                 break;
         case REMOVE:
                 ret = iwlagn_mac_sta_remove(hw, vif, sta);
diff --git a/drivers/net/wireless/mwifiex/11n_rxreorder.c b/drivers/net/wireless/mwifiex/11n_rxreorder.c
index 9c44088054dd..900ee129e825 100644
--- a/drivers/net/wireless/mwifiex/11n_rxreorder.c
+++ b/drivers/net/wireless/mwifiex/11n_rxreorder.c
@@ -256,7 +256,8 @@ mwifiex_11n_create_rx_reorder_tbl(struct mwifiex_private *priv, u8 *ta,
         else
                 last_seq = priv->rx_seq[tid];
 
-        if (last_seq >= new_node->start_win)
+        if (last_seq != MWIFIEX_DEF_11N_RX_SEQ_NUM &&
+            last_seq >= new_node->start_win)
                 new_node->start_win = last_seq + 1;
 
         new_node->win_size = win_size;
@@ -596,5 +597,5 @@ void mwifiex_11n_cleanup_reorder_tbl(struct mwifiex_private *priv)
         spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
 
         INIT_LIST_HEAD(&priv->rx_reorder_tbl_ptr);
-        memset(priv->rx_seq, 0, sizeof(priv->rx_seq));
+        mwifiex_reset_11n_rx_seq_num(priv);
 }
diff --git a/drivers/net/wireless/mwifiex/11n_rxreorder.h b/drivers/net/wireless/mwifiex/11n_rxreorder.h
index f1bffebabc60..6c9815a0f5d8 100644
--- a/drivers/net/wireless/mwifiex/11n_rxreorder.h
+++ b/drivers/net/wireless/mwifiex/11n_rxreorder.h
@@ -37,6 +37,13 @@
 
 #define ADDBA_RSP_STATUS_ACCEPT 0
 
+#define MWIFIEX_DEF_11N_RX_SEQ_NUM      0xffff
+
+static inline void mwifiex_reset_11n_rx_seq_num(struct mwifiex_private *priv)
+{
+        memset(priv->rx_seq, 0xff, sizeof(priv->rx_seq));
+}
+
 int mwifiex_11n_rx_reorder_pkt(struct mwifiex_private *,
                                u16 seqNum,
                                u16 tid, u8 *ta,
diff --git a/drivers/net/wireless/mwifiex/cfg80211.c b/drivers/net/wireless/mwifiex/cfg80211.c
index ce61b6fae1c9..5c7fd185373c 100644
--- a/drivers/net/wireless/mwifiex/cfg80211.c
+++ b/drivers/net/wireless/mwifiex/cfg80211.c
@@ -958,6 +958,7 @@ static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
         case NL80211_HIDDEN_SSID_ZERO_CONTENTS:
                 /* firmware doesn't support this type of hidden SSID */
         default:
+                kfree(bss_cfg);
                 return -EINVAL;
         }
 
diff --git a/drivers/net/wireless/mwifiex/ie.c b/drivers/net/wireless/mwifiex/ie.c
index ceb82cd749cc..383820a52beb 100644
--- a/drivers/net/wireless/mwifiex/ie.c
+++ b/drivers/net/wireless/mwifiex/ie.c
@@ -213,6 +213,7 @@ mwifiex_update_uap_custom_ie(struct mwifiex_private *priv,
                 /* save assoc resp ie index after auto-indexing */
                 *assoc_idx = *((u16 *)pos);
 
+        kfree(ap_custom_ie);
         return ret;
 }
 
diff --git a/drivers/net/wireless/mwifiex/sdio.c b/drivers/net/wireless/mwifiex/sdio.c
index e0377473282f..fc8a9bfa1248 100644
--- a/drivers/net/wireless/mwifiex/sdio.c
+++ b/drivers/net/wireless/mwifiex/sdio.c
@@ -978,10 +978,10 @@ static int mwifiex_decode_rx_packet(struct mwifiex_adapter *adapter,
                 dev_dbg(adapter->dev, "info: --- Rx: Event ---\n");
                 adapter->event_cause = *(u32 *) skb->data;
 
-                skb_pull(skb, MWIFIEX_EVENT_HEADER_LEN);
-
                 if ((skb->len > 0) && (skb->len  < MAX_EVENT_SIZE))
-                        memcpy(adapter->event_body, skb->data, skb->len);
+                        memcpy(adapter->event_body,
+                               skb->data + MWIFIEX_EVENT_HEADER_LEN,
+                               skb->len);
 
                 /* event cause has been saved to adapter->event_cause */
                 adapter->event_received = true;
diff --git a/drivers/net/wireless/mwifiex/sta_event.c b/drivers/net/wireless/mwifiex/sta_event.c
index 4ace5a3dcd23..11e731f3581c 100644
--- a/drivers/net/wireless/mwifiex/sta_event.c
+++ b/drivers/net/wireless/mwifiex/sta_event.c
@@ -406,9 +406,9 @@ int mwifiex_process_sta_event(struct mwifiex_private *priv)
                 break;
 
         case EVENT_UAP_STA_ASSOC:
-                skb_pull(adapter->event_skb, MWIFIEX_UAP_EVENT_EXTRA_HEADER);
                 memset(&sinfo, 0, sizeof(sinfo));
-                event = (struct mwifiex_assoc_event *)adapter->event_skb->data;
+                event = (struct mwifiex_assoc_event *)
+                        (adapter->event_body + MWIFIEX_UAP_EVENT_EXTRA_HEADER);
                 if (le16_to_cpu(event->type) == TLV_TYPE_UAP_MGMT_FRAME) {
                         len = -1;
 
@@ -433,9 +433,8 @@ int mwifiex_process_sta_event(struct mwifiex_private *priv)
                                  GFP_KERNEL);
                 break;
         case EVENT_UAP_STA_DEAUTH:
-                skb_pull(adapter->event_skb, MWIFIEX_UAP_EVENT_EXTRA_HEADER);
-                cfg80211_del_sta(priv->netdev, adapter->event_skb->data,
-                                 GFP_KERNEL);
+                cfg80211_del_sta(priv->netdev, adapter->event_body +
+                                 MWIFIEX_UAP_EVENT_EXTRA_HEADER, GFP_KERNEL);
                 break;
         case EVENT_UAP_BSS_IDLE:
                 priv->media_connected = false;
diff --git a/drivers/net/wireless/mwifiex/usb.c b/drivers/net/wireless/mwifiex/usb.c
index 49ebf20c56eb..22a5916564b8 100644
--- a/drivers/net/wireless/mwifiex/usb.c
+++ b/drivers/net/wireless/mwifiex/usb.c
@@ -49,6 +49,7 @@ static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
         struct device *dev = adapter->dev;
         u32 recv_type;
         __le32 tmp;
+        int ret;
 
         if (adapter->hs_activated)
                 mwifiex_process_hs_config(adapter);
@@ -69,16 +70,19 @@ static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
                 case MWIFIEX_USB_TYPE_CMD:
                         if (skb->len > MWIFIEX_SIZE_OF_CMD_BUFFER) {
                                 dev_err(dev, "CMD: skb->len too large\n");
-                                return -1;
+                                ret = -1;
+                                goto exit_restore_skb;
                         } else if (!adapter->curr_cmd) {
                                 dev_dbg(dev, "CMD: no curr_cmd\n");
                                 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
                                         mwifiex_process_sleep_confirm_resp(
                                                         adapter, skb->data,
                                                         skb->len);
-                                        return 0;
+                                        ret = 0;
+                                        goto exit_restore_skb;
                                 }
-                                return -1;
+                                ret = -1;
+                                goto exit_restore_skb;
                         }
 
                         adapter->curr_cmd->resp_skb = skb;
@@ -87,20 +91,22 @@ static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
                 case MWIFIEX_USB_TYPE_EVENT:
                         if (skb->len < sizeof(u32)) {
                                 dev_err(dev, "EVENT: skb->len too small\n");
-                                return -1;
+                                ret = -1;
+                                goto exit_restore_skb;
                         }
                         skb_copy_from_linear_data(skb, &tmp, sizeof(u32));
                         adapter->event_cause = le32_to_cpu(tmp);
-                        skb_pull(skb, sizeof(u32));
                         dev_dbg(dev, "event_cause %#x\n", adapter->event_cause);
 
                         if (skb->len > MAX_EVENT_SIZE) {
                                 dev_err(dev, "EVENT: event body too large\n");
-                                return -1;
+                                ret = -1;
+                                goto exit_restore_skb;
                         }
 
-                        skb_copy_from_linear_data(skb, adapter->event_body,
-                                                  skb->len);
+                        memcpy(adapter->event_body, skb->data +
+                               MWIFIEX_EVENT_HEADER_LEN, skb->len);
+
                         adapter->event_received = true;
                         adapter->event_skb = skb;
                         break;
@@ -124,6 +130,12 @@ static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
         }
 
         return -EINPROGRESS;
+
+exit_restore_skb:
+        /* The buffer will be reused for further cmds/events */
+        skb_push(skb, INTF_HEADER_LEN);
+
+        return ret;
 }
 
 static void mwifiex_usb_rx_complete(struct urb *urb)
diff --git a/drivers/net/wireless/mwifiex/wmm.c b/drivers/net/wireless/mwifiex/wmm.c
index f3fc65515857..3fa4d4176993 100644
--- a/drivers/net/wireless/mwifiex/wmm.c
+++ b/drivers/net/wireless/mwifiex/wmm.c
@@ -404,6 +404,8 @@ mwifiex_wmm_init(struct mwifiex_adapter *adapter)
                 priv->add_ba_param.tx_win_size = MWIFIEX_AMPDU_DEF_TXWINSIZE;
                 priv->add_ba_param.rx_win_size = MWIFIEX_AMPDU_DEF_RXWINSIZE;
 
+                mwifiex_reset_11n_rx_seq_num(priv);
+
                 atomic_set(&priv->wmm.tx_pkts_queued, 0);
                 atomic_set(&priv->wmm.highest_queued_prio, HIGH_PRIO_TID);
         }
@@ -1221,6 +1223,7 @@ mwifiex_dequeue_tx_packet(struct mwifiex_adapter *adapter)
 
         if (!ptr->is_11n_enabled ||
             mwifiex_is_ba_stream_setup(priv, ptr, tid) ||
+            priv->wps.session_enable ||
             ((priv->sec_info.wpa_enabled ||
               priv->sec_info.wpa2_enabled) &&
              !priv->wpa_is_gtk_set)) {
diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index d357d1ed92f6..74ecc33fdd90 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -436,8 +436,8 @@ void rt2x00usb_kick_queue(struct data_queue *queue)
         case QID_RX:
                 if (!rt2x00queue_full(queue))
                         rt2x00queue_for_each_entry(queue,
-                                                   Q_INDEX_DONE,
                                                    Q_INDEX,
+                                                   Q_INDEX_DONE,
                                                    NULL,
                                                    rt2x00usb_kick_rx_entry);
                 break;
diff --git a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
index d228358e6a40..9970c2b1b199 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
@@ -301,9 +301,11 @@ static struct usb_device_id rtl8192c_usb_ids[] = {
         {RTL_USB_DEVICE(0x07b8, 0x8188, rtl92cu_hal_cfg)}, /*Abocom - Abocom*/
         {RTL_USB_DEVICE(0x07b8, 0x8189, rtl92cu_hal_cfg)}, /*Funai - Abocom*/
         {RTL_USB_DEVICE(0x0846, 0x9041, rtl92cu_hal_cfg)}, /*NetGear WNA1000M*/
+        {RTL_USB_DEVICE(0x0bda, 0x5088, rtl92cu_hal_cfg)}, /*Thinkware-CC&C*/
         {RTL_USB_DEVICE(0x0df6, 0x0052, rtl92cu_hal_cfg)}, /*Sitecom - Edimax*/
         {RTL_USB_DEVICE(0x0df6, 0x005c, rtl92cu_hal_cfg)}, /*Sitecom - Edimax*/
         {RTL_USB_DEVICE(0x0eb0, 0x9071, rtl92cu_hal_cfg)}, /*NO Brand - Etop*/
+        {RTL_USB_DEVICE(0x4856, 0x0091, rtl92cu_hal_cfg)}, /*NetweeN - Feixun*/
         /* HP - Lite-On ,8188CUS Slim Combo */
         {RTL_USB_DEVICE(0x103c, 0x1629, rtl92cu_hal_cfg)},
         {RTL_USB_DEVICE(0x13d3, 0x3357, rtl92cu_hal_cfg)}, /* AzureWave */
@@ -346,6 +348,7 @@ static struct usb_device_id rtl8192c_usb_ids[] = {
         {RTL_USB_DEVICE(0x07b8, 0x8178, rtl92cu_hal_cfg)}, /*Funai -Abocom*/
         {RTL_USB_DEVICE(0x0846, 0x9021, rtl92cu_hal_cfg)}, /*Netgear-Sercomm*/
         {RTL_USB_DEVICE(0x0b05, 0x17ab, rtl92cu_hal_cfg)}, /*ASUS-Edimax*/
+        {RTL_USB_DEVICE(0x0bda, 0x8186, rtl92cu_hal_cfg)}, /*Realtek 92CE-VAU*/
         {RTL_USB_DEVICE(0x0df6, 0x0061, rtl92cu_hal_cfg)}, /*Sitecom-Edimax*/
         {RTL_USB_DEVICE(0x0e66, 0x0019, rtl92cu_hal_cfg)}, /*Hawking-Edimax*/
         {RTL_USB_DEVICE(0x2001, 0x3307, rtl92cu_hal_cfg)}, /*D-Link-Cameo*/
diff --git a/drivers/net/wireless/ti/wlcore/Kconfig b/drivers/net/wireless/ti/wlcore/Kconfig
index 54156b0b5c2d..d7b907e67170 100644
--- a/drivers/net/wireless/ti/wlcore/Kconfig
+++ b/drivers/net/wireless/ti/wlcore/Kconfig
@@ -1,7 +1,6 @@
 config WLCORE
         tristate "TI wlcore support"
         depends on WL_TI && GENERIC_HARDIRQS && MAC80211
-        depends on INET
         select FW_LOADER
         ---help---
           This module contains the main code for TI WLAN chips.  It abstracts
diff --git a/drivers/of/platform.c b/drivers/of/platform.c
index 343ad29e211c..e44f8c2d239d 100644
--- a/drivers/of/platform.c
+++ b/drivers/of/platform.c
@@ -317,10 +317,9 @@ static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *l
         for(; lookup->compatible != NULL; lookup++) {
                 if (!of_device_is_compatible(np, lookup->compatible))
                         continue;
-                if (of_address_to_resource(np, 0, &res))
-                        continue;
-                if (res.start != lookup->phys_addr)
-                        continue;
+                if (!of_address_to_resource(np, 0, &res))
+                        if (res.start != lookup->phys_addr)
+                                continue;
                 pr_debug("%s: devname=%s\n", np->full_name, lookup->name);
                 return lookup;
         }
@@ -462,4 +461,5 @@ int of_platform_populate(struct device_node *root,
         of_node_put(root);
         return rc;
 }
+EXPORT_SYMBOL_GPL(of_platform_populate);
 #endif /* CONFIG_OF_ADDRESS */
diff --git a/drivers/oprofile/oprofile_perf.c b/drivers/oprofile/oprofile_perf.c
index efc4b7f308cf..f3cfa0b9adfa 100644
--- a/drivers/oprofile/oprofile_perf.c
+++ b/drivers/oprofile/oprofile_perf.c
@@ -1,5 +1,6 @@
 /*
  * Copyright 2010 ARM Ltd.
+ * Copyright 2012 Advanced Micro Devices, Inc., Robert Richter
  *
  * Perf-events backend for OProfile.
  */
@@ -25,7 +26,7 @@ static int oprofile_perf_enabled;
 static DEFINE_MUTEX(oprofile_perf_mutex);
 
 static struct op_counter_config *counter_config;
-static struct perf_event **perf_events[NR_CPUS];
+static DEFINE_PER_CPU(struct perf_event **, perf_events);
 static int num_counters;
 
 /*
@@ -38,7 +39,7 @@ static void op_overflow_handler(struct perf_event *event,
         u32 cpu = smp_processor_id();
 
         for (id = 0; id < num_counters; ++id)
-                if (perf_events[cpu][id] == event)
+                if (per_cpu(perf_events, cpu)[id] == event)
                         break;
 
         if (id != num_counters)
@@ -74,7 +75,7 @@ static int op_create_counter(int cpu, int event)
 {
         struct perf_event *pevent;
 
-        if (!counter_config[event].enabled || perf_events[cpu][event])
+        if (!counter_config[event].enabled || per_cpu(perf_events, cpu)[event])
                 return 0;
 
         pevent = perf_event_create_kernel_counter(&counter_config[event].attr,
@@ -91,18 +92,18 @@ static int op_create_counter(int cpu, int event)
                 return -EBUSY;
         }
 
-        perf_events[cpu][event] = pevent;
+        per_cpu(perf_events, cpu)[event] = pevent;
 
         return 0;
 }
 
 static void op_destroy_counter(int cpu, int event)
 {
-        struct perf_event *pevent = perf_events[cpu][event];
+        struct perf_event *pevent = per_cpu(perf_events, cpu)[event];
 
         if (pevent) {
                 perf_event_release_kernel(pevent);
-                perf_events[cpu][event] = NULL;
+                per_cpu(perf_events, cpu)[event] = NULL;
         }
 }
 
@@ -257,12 +258,12 @@ void oprofile_perf_exit(void)
 
         for_each_possible_cpu(cpu) {
                 for (id = 0; id < num_counters; ++id) {
-                        event = perf_events[cpu][id];
+                        event = per_cpu(perf_events, cpu)[id];
                         if (event)
                                 perf_event_release_kernel(event);
                 }
 
-                kfree(perf_events[cpu]);
+                kfree(per_cpu(perf_events, cpu));
         }
 
         kfree(counter_config);
@@ -277,8 +278,6 @@ int __init oprofile_perf_init(struct oprofile_operations *ops)
         if (ret)
                 return ret;
 
-        memset(&perf_events, 0, sizeof(perf_events));
-
         num_counters = perf_num_counters();
         if (num_counters <= 0) {
                 pr_info("oprofile: no performance counters\n");
@@ -298,9 +297,9 @@ int __init oprofile_perf_init(struct oprofile_operations *ops)
         }
 
         for_each_possible_cpu(cpu) {
-                perf_events[cpu] = kcalloc(num_counters,
+                per_cpu(perf_events, cpu) = kcalloc(num_counters,
                                 sizeof(struct perf_event *), GFP_KERNEL);
-                if (!perf_events[cpu]) {
+                if (!per_cpu(perf_events, cpu)) {
                         pr_info("oprofile: failed to allocate %d perf events "
                                         "for cpu %d\n", num_counters, cpu);
                         ret = -ENOMEM;
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index bf0cee629b60..099f46cd8e87 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -748,6 +748,18 @@ static int pci_pm_suspend_noirq(struct device *dev)
 
         pci_pm_set_unknown_state(pci_dev);
 
+        /*
+         * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
+         * PCI COMMAND register isn't 0, the BIOS assumes that the controller
+         * hasn't been quiesced and tries to turn it off.  If the controller
+         * is already in D3, this can hang or cause memory corruption.
+         *
+         * Since the value of the COMMAND register doesn't matter once the
+         * device has been suspended, we can safely set it to 0 here.
+         */
+        if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
+                pci_write_config_word(pci_dev, PCI_COMMAND, 0);
+
         return 0;
 }
 
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 77cb54a65cde..447e83472c01 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1744,11 +1744,6 @@ int pci_prepare_to_sleep(struct pci_dev *dev)
         if (target_state == PCI_POWER_ERROR)
                 return -EIO;
 
-        /* Some devices mustn't be in D3 during system sleep */
-        if (target_state == PCI_D3hot &&
-                        (dev->dev_flags & PCI_DEV_FLAGS_NO_D3_DURING_SLEEP))
-                return 0;
-
         pci_enable_wake(dev, target_state, device_may_wakeup(&dev->dev));
 
         error = pci_set_power_state(dev, target_state);
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 194b243a2817..2a7521677541 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -2929,32 +2929,6 @@ static void __devinit disable_igfx_irq(struct pci_dev *dev)
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0102, disable_igfx_irq);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x010a, disable_igfx_irq);
 
-/*
- * The Intel 6 Series/C200 Series chipset's EHCI controllers on many
- * ASUS motherboards will cause memory corruption or a system crash
- * if they are in D3 while the system is put into S3 sleep.
- */
-static void __devinit asus_ehci_no_d3(struct pci_dev *dev)
-{
-        const char *sys_info;
-        static const char good_Asus_board[] = "P8Z68-V";
-
-        if (dev->dev_flags & PCI_DEV_FLAGS_NO_D3_DURING_SLEEP)
-                return;
-        if (dev->subsystem_vendor != PCI_VENDOR_ID_ASUSTEK)
-                return;
-        sys_info = dmi_get_system_info(DMI_BOARD_NAME);
-        if (sys_info && memcmp(sys_info, good_Asus_board,
-                        sizeof(good_Asus_board) - 1) == 0)
-                return;
-
-        dev_info(&dev->dev, "broken D3 during system sleep on ASUS\n");
-        dev->dev_flags |= PCI_DEV_FLAGS_NO_D3_DURING_SLEEP;
-        device_set_wakeup_capable(&dev->dev, false);
-}
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x1c26, asus_ehci_no_d3);
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x1c2d, asus_ehci_no_d3);
-
 static void pci_do_fixups(struct pci_dev *dev, struct pci_fixup *f,
                           struct pci_fixup *end)
 {
diff --git a/drivers/pinctrl/pinctrl-imx.c b/drivers/pinctrl/pinctrl-imx.c
index dd6d93aa5334..90c837f469a6 100644
--- a/drivers/pinctrl/pinctrl-imx.c
+++ b/drivers/pinctrl/pinctrl-imx.c
@@ -474,7 +474,9 @@ static int __devinit imx_pinctrl_parse_groups(struct device_node *np,
                 grp->configs[j] = config & ~IMX_PAD_SION;
         }
 
+#ifdef DEBUG
         IMX_PMX_DUMP(info, grp->pins, grp->mux_mode, grp->configs, grp->npins);
+#endif
 
         return 0;
 }
diff --git a/drivers/pinctrl/pinctrl-imx6q.c b/drivers/pinctrl/pinctrl-imx6q.c
index 7737d4d71a3c..e9bf71fbedca 100644
--- a/drivers/pinctrl/pinctrl-imx6q.c
+++ b/drivers/pinctrl/pinctrl-imx6q.c
@@ -1950,6 +1950,8 @@ static struct imx_pin_reg imx6q_pin_regs[] = {
         IMX_PIN_REG(MX6Q_PAD_SD2_DAT3, 0x0744, 0x035C, 5, 0x0000, 0), /* MX6Q_PAD_SD2_DAT3__GPIO_1_12 */
         IMX_PIN_REG(MX6Q_PAD_SD2_DAT3, 0x0744, 0x035C, 6, 0x0000, 0), /* MX6Q_PAD_SD2_DAT3__SJC_DONE */
         IMX_PIN_REG(MX6Q_PAD_SD2_DAT3, 0x0744, 0x035C, 7, 0x0000, 0), /* MX6Q_PAD_SD2_DAT3__ANATOP_TESTO_3 */
+        IMX_PIN_REG(MX6Q_PAD_ENET_RX_ER, 0x04EC, 0x01D8, 0, 0x0000, 0), /* MX6Q_PAD_ENET_RX_ER__ANATOP_USBOTG_ID */
+        IMX_PIN_REG(MX6Q_PAD_GPIO_1, 0x05F4, 0x0224, 3, 0x0000, 0), /* MX6Q_PAD_GPIO_1__ANATOP_USBOTG_ID */
 };
 
 /* Pad names for the pinmux subsystem */
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index ce875dc365e5..c8f40c9c0428 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -1877,8 +1877,7 @@ static int acer_platform_remove(struct platform_device *device)
         return 0;
 }
 
-static int acer_platform_suspend(struct platform_device *dev,
-pm_message_t state)
+static int acer_suspend(struct device *dev)
 {
         u32 value;
         struct acer_data *data = &interface->data;
@@ -1900,7 +1899,7 @@ pm_message_t state)
         return 0;
 }
 
-static int acer_platform_resume(struct platform_device *device)
+static int acer_resume(struct device *dev)
 {
         struct acer_data *data = &interface->data;
 
@@ -1916,6 +1915,8 @@ static int acer_platform_resume(struct platform_device *device)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(acer_pm, acer_suspend, acer_resume);
+
 static void acer_platform_shutdown(struct platform_device *device)
 {
         struct acer_data *data = &interface->data;
@@ -1931,11 +1932,10 @@ static struct platform_driver acer_platform_driver = {
         .driver = {
                 .name = "acer-wmi",
                 .owner = THIS_MODULE,
+                .pm = &acer_pm,
         },
         .probe = acer_platform_probe,
         .remove = acer_platform_remove,
-        .suspend = acer_platform_suspend,
-        .resume = acer_platform_resume,
         .shutdown = acer_platform_shutdown,
 };
 
diff --git a/drivers/platform/x86/classmate-laptop.c b/drivers/platform/x86/classmate-laptop.c
index 94f93b621d7b..e2230a2b2f8e 100644
--- a/drivers/platform/x86/classmate-laptop.c
+++ b/drivers/platform/x86/classmate-laptop.c
@@ -362,15 +362,18 @@ static int cmpc_tablet_remove(struct acpi_device *acpi, int type)
         return cmpc_remove_acpi_notify_device(acpi);
 }
 
-static int cmpc_tablet_resume(struct acpi_device *acpi)
+static int cmpc_tablet_resume(struct device *dev)
 {
-        struct input_dev *inputdev = dev_get_drvdata(&acpi->dev);
+        struct input_dev *inputdev = dev_get_drvdata(dev);
+
         unsigned long long val = 0;
-        if (ACPI_SUCCESS(cmpc_get_tablet(acpi->handle, &val)))
+        if (ACPI_SUCCESS(cmpc_get_tablet(to_acpi_device(dev)->handle, &val)))
                 input_report_switch(inputdev, SW_TABLET_MODE, !val);
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(cmpc_tablet_pm, NULL, cmpc_tablet_resume);
+
 static const struct acpi_device_id cmpc_tablet_device_ids[] = {
         {CMPC_TABLET_HID, 0},
         {"", 0}
@@ -384,9 +387,9 @@ static struct acpi_driver cmpc_tablet_acpi_driver = {
         .ops = {
                 .add = cmpc_tablet_add,
                 .remove = cmpc_tablet_remove,
-                .resume = cmpc_tablet_resume,
                 .notify = cmpc_tablet_handler,
-        }
+        },
+        .drv.pm = &cmpc_tablet_pm,
 };
 
 
diff --git a/drivers/platform/x86/fujitsu-tablet.c b/drivers/platform/x86/fujitsu-tablet.c
index da267eae8ba8..d2e41735a47b 100644
--- a/drivers/platform/x86/fujitsu-tablet.c
+++ b/drivers/platform/x86/fujitsu-tablet.c
@@ -440,12 +440,14 @@ static int __devexit acpi_fujitsu_remove(struct acpi_device *adev, int type)
         return 0;
 }
 
-static int acpi_fujitsu_resume(struct acpi_device *adev)
+static int acpi_fujitsu_resume(struct device *dev)
 {
         fujitsu_reset();
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(acpi_fujitsu_pm, NULL, acpi_fujitsu_resume);
+
 static struct acpi_driver acpi_fujitsu_driver = {
         .name  = MODULENAME,
         .class = "hotkey",
@@ -453,8 +455,8 @@ static struct acpi_driver acpi_fujitsu_driver = {
         .ops   = {
                 .add    = acpi_fujitsu_add,
                 .remove = acpi_fujitsu_remove,
-                .resume = acpi_fujitsu_resume,
-        }
+        },
+        .drv.pm = &acpi_fujitsu_pm,
 };
 
 static int __init fujitsu_module_init(void)
diff --git a/drivers/platform/x86/hdaps.c b/drivers/platform/x86/hdaps.c
index 24a3ae065f1b..d9ab6f64dcec 100644
--- a/drivers/platform/x86/hdaps.c
+++ b/drivers/platform/x86/hdaps.c
@@ -305,17 +305,19 @@ static int hdaps_probe(struct platform_device *dev)
         return 0;
 }
 
-static int hdaps_resume(struct platform_device *dev)
+static int hdaps_resume(struct device *dev)
 {
         return hdaps_device_init();
 }
 
+static SIMPLE_DEV_PM_OPS(hdaps_pm, NULL, hdaps_resume);
+
 static struct platform_driver hdaps_driver = {
         .probe = hdaps_probe,
-        .resume = hdaps_resume,
         .driver = {
                 .name = "hdaps",
                 .owner = THIS_MODULE,
+                .pm = &hdaps_pm,
         },
 };
 
diff --git a/drivers/platform/x86/hp_accel.c b/drivers/platform/x86/hp_accel.c
index 22b2dfa73148..f4d91154ad67 100644
--- a/drivers/platform/x86/hp_accel.c
+++ b/drivers/platform/x86/hp_accel.c
@@ -353,20 +353,22 @@ static int lis3lv02d_remove(struct acpi_device *device, int type)
 
 
 #ifdef CONFIG_PM
-static int lis3lv02d_suspend(struct acpi_device *device, pm_message_t state)
+static int lis3lv02d_suspend(struct device *dev)
 {
         /* make sure the device is off when we suspend */
         lis3lv02d_poweroff(&lis3_dev);
         return 0;
 }
 
-static int lis3lv02d_resume(struct acpi_device *device)
+static int lis3lv02d_resume(struct device *dev)
 {
         return lis3lv02d_poweron(&lis3_dev);
 }
+
+static SIMPLE_DEV_PM_OPS(hp_accel_pm, lis3lv02d_suspend, lis3lv02d_resume);
+#define HP_ACCEL_PM (&hp_accel_pm)
 #else
-#define lis3lv02d_suspend NULL
-#define lis3lv02d_resume NULL
+#define HP_ACCEL_PM NULL
 #endif
 
 /* For the HP MDPS aka 3D Driveguard */
@@ -377,9 +379,8 @@ static struct acpi_driver lis3lv02d_driver = {
         .ops = {
                 .add     = lis3lv02d_add,
                 .remove  = lis3lv02d_remove,
-                .suspend = lis3lv02d_suspend,
-                .resume  = lis3lv02d_resume,
-        }
+        },
+        .drv.pm = HP_ACCEL_PM,
 };
 
 static int __init lis3lv02d_init_module(void)
diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index 4f20f8dd3d7c..17f6dfd8dbfb 100644
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -694,10 +694,10 @@ MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
 static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
 {
         int ret, i;
-        unsigned long cfg;
+        int cfg;
         struct ideapad_private *priv;
 
-        if (read_method_int(adevice->handle, "_CFG", (int *)&cfg))
+        if (read_method_int(adevice->handle, "_CFG", &cfg))
                 return -ENODEV;
 
         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
@@ -721,7 +721,7 @@ static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
                 goto input_failed;
 
         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) {
-                if (test_bit(ideapad_rfk_data[i].cfgbit, &cfg))
+                if (test_bit(ideapad_rfk_data[i].cfgbit, &priv->cfg))
                         ideapad_register_rfkill(adevice, i);
                 else
                         priv->rfk[i] = NULL;
diff --git a/drivers/platform/x86/intel_ips.c b/drivers/platform/x86/intel_ips.c
index 0ffdb3cde2bb..5051aa970e0a 100644
--- a/drivers/platform/x86/intel_ips.c
+++ b/drivers/platform/x86/intel_ips.c
@@ -72,6 +72,7 @@
 #include <linux/string.h>
 #include <linux/tick.h>
 #include <linux/timer.h>
+#include <linux/dmi.h>
 #include <drm/i915_drm.h>
 #include <asm/msr.h>
 #include <asm/processor.h>
@@ -1485,6 +1486,24 @@ static DEFINE_PCI_DEVICE_TABLE(ips_id_table) = {
 
 MODULE_DEVICE_TABLE(pci, ips_id_table);
 
+static int ips_blacklist_callback(const struct dmi_system_id *id)
+{
+        pr_info("Blacklisted intel_ips for %s\n", id->ident);
+        return 1;
+}
+
+static const struct dmi_system_id ips_blacklist[] = {
+        {
+                .callback = ips_blacklist_callback,
+                .ident = "HP ProBook",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "HP ProBook"),
+                },
+        },
+        { }     /* terminating entry */
+};
+
 static int ips_probe(struct pci_dev *dev, const struct pci_device_id *id)
 {
         u64 platform_info;
@@ -1494,6 +1513,9 @@ static int ips_probe(struct pci_dev *dev, const struct pci_device_id *id)
         u16 htshi, trc, trc_required_mask;
         u8 tse;
 
+        if (dmi_check_system(ips_blacklist))
+                return -ENODEV;
+
         ips = kzalloc(sizeof(struct ips_driver), GFP_KERNEL);
         if (!ips)
                 return -ENOMEM;
@@ -1697,21 +1719,6 @@ static void ips_remove(struct pci_dev *dev)
         dev_dbg(&dev->dev, "IPS driver removed\n");
 }
 
-#ifdef CONFIG_PM
-static int ips_suspend(struct pci_dev *dev, pm_message_t state)
-{
-        return 0;
-}
-
-static int ips_resume(struct pci_dev *dev)
-{
-        return 0;
-}
-#else
-#define ips_suspend NULL
-#define ips_resume NULL
-#endif /* CONFIG_PM */
-
 static void ips_shutdown(struct pci_dev *dev)
 {
 }
@@ -1721,8 +1728,6 @@ static struct pci_driver ips_pci_driver = {
         .id_table = ips_id_table,
         .probe = ips_probe,
         .remove = ips_remove,
-        .suspend = ips_suspend,
-        .resume = ips_resume,
         .shutdown = ips_shutdown,
 };
 
diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c
index 5ae9cd9c7e6e..ea7422f6fa03 100644
--- a/drivers/platform/x86/intel_mid_thermal.c
+++ b/drivers/platform/x86/intel_mid_thermal.c
@@ -418,23 +418,23 @@ static struct thermal_device_info *initialize_sensor(int index)
 
 /**
  * mid_thermal_resume - resume routine
- * @pdev: platform device structure
+ * @dev: device structure
  *
  * mid thermal resume: re-initializes the adc. Can sleep.
  */
-static int mid_thermal_resume(struct platform_device *pdev)
+static int mid_thermal_resume(struct device *dev)
 {
-        return mid_initialize_adc(&pdev->dev);
+        return mid_initialize_adc(dev);
 }
 
 /**
  * mid_thermal_suspend - suspend routine
- * @pdev: platform device structure
+ * @dev: device structure
  *
  * mid thermal suspend implements the suspend functionality
  * by stopping the ADC. Can sleep.
  */
-static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
+static int mid_thermal_suspend(struct device *dev)
 {
         /*
          * This just stops the ADC and does not disable it.
@@ -444,6 +444,9 @@ static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
         return configure_adc(0);
 }
 
+static SIMPLE_DEV_PM_OPS(mid_thermal_pm,
+                         mid_thermal_suspend, mid_thermal_resume);
+
 /**
  * read_curr_temp - reads the current temperature and stores in temp
  * @temp: holds the current temperature value after reading
@@ -557,10 +560,9 @@ static struct platform_driver mid_thermal_driver = {
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
+                .pm = &mid_thermal_pm,
         },
         .probe = mid_thermal_probe,
-        .suspend = mid_thermal_suspend,
-        .resume = mid_thermal_resume,
         .remove = __devexit_p(mid_thermal_remove),
         .id_table = therm_id_table,
 };
diff --git a/drivers/platform/x86/msi-laptop.c b/drivers/platform/x86/msi-laptop.c
index bb5132128b33..f64441844317 100644
--- a/drivers/platform/x86/msi-laptop.c
+++ b/drivers/platform/x86/msi-laptop.c
@@ -85,7 +85,8 @@
 #define MSI_STANDARD_EC_TOUCHPAD_ADDRESS        0xe4
 #define MSI_STANDARD_EC_TOUCHPAD_MASK           (1 << 4)
 
-static int msi_laptop_resume(struct platform_device *device);
+static int msi_laptop_resume(struct device *device);
+static SIMPLE_DEV_PM_OPS(msi_laptop_pm, NULL, msi_laptop_resume);
 
 #define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS  0x2f
 
@@ -437,8 +438,8 @@ static struct platform_driver msipf_driver = {
         .driver = {
                 .name = "msi-laptop-pf",
                 .owner = THIS_MODULE,
+                .pm = &msi_laptop_pm,
         },
-        .resume = msi_laptop_resume,
 };
 
 static struct platform_device *msipf_device;
@@ -752,7 +753,7 @@ err_bluetooth:
         return retval;
 }
 
-static int msi_laptop_resume(struct platform_device *device)
+static int msi_laptop_resume(struct device *device)
 {
         u8 data;
         int result;
diff --git a/drivers/platform/x86/panasonic-laptop.c b/drivers/platform/x86/panasonic-laptop.c
index ffff8b4b4949..24480074bcf0 100644
--- a/drivers/platform/x86/panasonic-laptop.c
+++ b/drivers/platform/x86/panasonic-laptop.c
@@ -177,7 +177,6 @@ enum SINF_BITS { SINF_NUM_BATTERIES = 0,
 
 static int acpi_pcc_hotkey_add(struct acpi_device *device);
 static int acpi_pcc_hotkey_remove(struct acpi_device *device, int type);
-static int acpi_pcc_hotkey_resume(struct acpi_device *device);
 static void acpi_pcc_hotkey_notify(struct acpi_device *device, u32 event);
 
 static const struct acpi_device_id pcc_device_ids[] = {
@@ -189,6 +188,9 @@ static const struct acpi_device_id pcc_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, pcc_device_ids);
 
+static int acpi_pcc_hotkey_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(acpi_pcc_hotkey_pm, NULL, acpi_pcc_hotkey_resume);
+
 static struct acpi_driver acpi_pcc_driver = {
         .name =         ACPI_PCC_DRIVER_NAME,
         .class =        ACPI_PCC_CLASS,
@@ -196,9 +198,9 @@ static struct acpi_driver acpi_pcc_driver = {
         .ops =          {
                                 .add =          acpi_pcc_hotkey_add,
                                 .remove =       acpi_pcc_hotkey_remove,
-                                .resume =       acpi_pcc_hotkey_resume,
                                 .notify =       acpi_pcc_hotkey_notify,
                         },
+        .drv.pm =       &acpi_pcc_hotkey_pm,
 };
 
 static const struct key_entry panasonic_keymap[] = {
@@ -538,11 +540,15 @@ static void acpi_pcc_destroy_input(struct pcc_acpi *pcc)
 
 /* kernel module interface */
 
-static int acpi_pcc_hotkey_resume(struct acpi_device *device)
+static int acpi_pcc_hotkey_resume(struct device *dev)
 {
-        struct pcc_acpi *pcc = acpi_driver_data(device);
+        struct pcc_acpi *pcc;
+
+        if (!dev)
+                return -EINVAL;
 
-        if (device == NULL || pcc == NULL)
+        pcc = acpi_driver_data(to_acpi_device(dev));
+        if (!pcc)
                 return -EINVAL;
 
         ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Sticky mode restore: %d\n",
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 210d4ae547c2..9363969ad07a 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -973,7 +973,7 @@ static ssize_t sony_nc_sysfs_store(struct device *dev,
                                struct device_attribute *attr,
                                const char *buffer, size_t count)
 {
-        unsigned long value = 0;
+        int value;
         int ret = 0;
         struct sony_nc_value *item =
             container_of(attr, struct sony_nc_value, devattr);
@@ -984,7 +984,7 @@ static ssize_t sony_nc_sysfs_store(struct device *dev,
         if (count > 31)
                 return -EINVAL;
 
-        if (kstrtoul(buffer, 10, &value))
+        if (kstrtoint(buffer, 10, &value))
                 return -EINVAL;
 
         if (item->validate)
@@ -994,7 +994,7 @@ static ssize_t sony_nc_sysfs_store(struct device *dev,
                 return value;
 
         ret = sony_nc_int_call(sony_nc_acpi_handle, *item->acpiset,
-                        (int *)&value, NULL);
+                               &value, NULL);
         if (ret < 0)
                 return -EIO;
 
@@ -1010,6 +1010,7 @@ static ssize_t sony_nc_sysfs_store(struct device *dev,
 struct sony_backlight_props {
         struct backlight_device *dev;
         int                     handle;
+        int                     cmd_base;
         u8                      offset;
         u8                      maxlvl;
 };
@@ -1037,7 +1038,7 @@ static int sony_nc_get_brightness_ng(struct backlight_device *bd)
         struct sony_backlight_props *sdev =
                 (struct sony_backlight_props *)bl_get_data(bd);
 
-        sony_call_snc_handle(sdev->handle, 0x0200, &result);
+        sony_call_snc_handle(sdev->handle, sdev->cmd_base + 0x100, &result);
 
         return (result & 0xff) - sdev->offset;
 }
@@ -1049,7 +1050,8 @@ static int sony_nc_update_status_ng(struct backlight_device *bd)
                 (struct sony_backlight_props *)bl_get_data(bd);
 
         value = bd->props.brightness + sdev->offset;
-        if (sony_call_snc_handle(sdev->handle, 0x0100 | (value << 16), &result))
+        if (sony_call_snc_handle(sdev->handle, sdev->cmd_base | (value << 0x10),
+                                &result))
                 return -EIO;
 
         return value;
@@ -1172,6 +1174,11 @@ static int sony_nc_hotkeys_decode(u32 event, unsigned int handle)
 /*
  * ACPI callbacks
  */
+enum event_types {
+        HOTKEY = 1,
+        KILLSWITCH,
+        GFX_SWITCH
+};
 static void sony_nc_notify(struct acpi_device *device, u32 event)
 {
         u32 real_ev = event;
@@ -1196,7 +1203,7 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
                 /* hotkey event */
                 case 0x0100:
                 case 0x0127:
-                        ev_type = 1;
+                        ev_type = HOTKEY;
                         real_ev = sony_nc_hotkeys_decode(event, handle);
 
                         if (real_ev > 0)
@@ -1216,7 +1223,7 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
                          * update the rfkill device status when the
                          * switch is moved.
                          */
-                        ev_type = 2;
+                        ev_type = KILLSWITCH;
                         sony_call_snc_handle(handle, 0x0100, &result);
                         real_ev = result & 0x03;
 
@@ -1226,6 +1233,24 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
 
                         break;
 
+                case 0x0128:
+                case 0x0146:
+                        /* Hybrid GFX switching */
+                        sony_call_snc_handle(handle, 0x0000, &result);
+                        dprintk("GFX switch event received (reason: %s)\n",
+                                        (result & 0x01) ?
+                                        "switch change" : "unknown");
+
+                        /* verify the switch state
+                         * 1: discrete GFX
+                         * 0: integrated GFX
+                         */
+                        sony_call_snc_handle(handle, 0x0100, &result);
+
+                        ev_type = GFX_SWITCH;
+                        real_ev = result & 0xff;
+                        break;
+
                 default:
                         dprintk("Unknown event 0x%x for handle 0x%x\n",
                                         event, handle);
@@ -1238,7 +1263,7 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
 
         } else {
                 /* old style event */
-                ev_type = 1;
+                ev_type = HOTKEY;
                 sony_laptop_report_input_event(real_ev);
         }
 
@@ -1452,7 +1477,7 @@ static void sony_nc_function_resume(void)
                                 &result);
 }
 
-static int sony_nc_resume(struct acpi_device *device)
+static int sony_nc_resume(struct device *dev)
 {
         struct sony_nc_value *item;
         acpi_handle handle;
@@ -1484,6 +1509,8 @@ static int sony_nc_resume(struct acpi_device *device)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(sony_nc_pm, NULL, sony_nc_resume);
+
 static void sony_nc_rfkill_cleanup(void)
 {
         int i;
@@ -1893,32 +1920,33 @@ static ssize_t sony_nc_battery_care_limit_store(struct device *dev,
          *  bits 4,5: store the limit into the EC
          *  bits 6,7: store the limit into the battery
          */
+        cmd = 0;
 
-        /*
-         * handle 0x0115 should allow storing on battery too;
-         * handle 0x0136 same as 0x0115 + health status;
-         * handle 0x013f, same as 0x0136 but no storing on the battery
-         *
-         * Store only inside the EC for now, regardless the handle number
-         */
-        if (value == 0)
-                /* disable limits */
-                cmd = 0x0;
+        if (value > 0) {
+                if (value <= 50)
+                        cmd = 0x20;
 
-        else if (value <= 50)
-                cmd = 0x21;
+                else if (value <= 80)
+                        cmd = 0x10;
 
-        else if (value <= 80)
-                cmd = 0x11;
+                else if (value <= 100)
+                        cmd = 0x30;
 
-        else if (value <= 100)
-                cmd = 0x31;
+                else
+                        return -EINVAL;
 
-        else
-                return -EINVAL;
+                /*
+                 * handle 0x0115 should allow storing on battery too;
+                 * handle 0x0136 same as 0x0115 + health status;
+                 * handle 0x013f, same as 0x0136 but no storing on the battery
+                 */
+                if (bcare_ctl->handle != 0x013f)
+                        cmd = cmd | (cmd << 2);
 
-        if (sony_call_snc_handle(bcare_ctl->handle, (cmd << 0x10) | 0x0100,
-                                &result))
+                cmd = (cmd | 0x1) << 0x10;
+        }
+
+        if (sony_call_snc_handle(bcare_ctl->handle, cmd | 0x0100, &result))
                 return -EIO;
 
         return count;
@@ -2113,7 +2141,7 @@ static ssize_t sony_nc_thermal_mode_show(struct device *dev,
                 struct device_attribute *attr, char *buffer)
 {
         ssize_t count = 0;
-        unsigned int mode = sony_nc_thermal_mode_get();
+        int mode = sony_nc_thermal_mode_get();
 
         if (mode < 0)
                 return mode;
@@ -2472,6 +2500,7 @@ static void sony_nc_backlight_ng_read_limits(int handle,
 {
         u64 offset;
         int i;
+        int lvl_table_len = 0;
         u8 min = 0xff, max = 0x00;
         unsigned char buffer[32] = { 0 };
 
@@ -2480,8 +2509,6 @@ static void sony_nc_backlight_ng_read_limits(int handle,
         props->maxlvl = 0xff;
 
         offset = sony_find_snc_handle(handle);
-        if (offset < 0)
-                return;
 
         /* try to read the boundaries from ACPI tables, if we fail the above
          * defaults should be reasonable
@@ -2491,11 +2518,21 @@ static void sony_nc_backlight_ng_read_limits(int handle,
         if (i < 0)
                 return;
 
+        switch (handle) {
+        case 0x012f:
+        case 0x0137:
+                lvl_table_len = 9;
+                break;
+        case 0x143:
+                lvl_table_len = 16;
+                break;
+        }
+
         /* the buffer lists brightness levels available, brightness levels are
          * from position 0 to 8 in the array, other values are used by ALS
          * control.
          */
-        for (i = 0; i < 9 && i < ARRAY_SIZE(buffer); i++) {
+        for (i = 0; i < lvl_table_len && i < ARRAY_SIZE(buffer); i++) {
 
                 dprintk("Brightness level: %d\n", buffer[i]);
 
@@ -2520,16 +2557,24 @@ static void sony_nc_backlight_setup(void)
         const struct backlight_ops *ops = NULL;
         struct backlight_properties props;
 
-        if (sony_find_snc_handle(0x12f) != -1) {
+        if (sony_find_snc_handle(0x12f) >= 0) {
                 ops = &sony_backlight_ng_ops;
+                sony_bl_props.cmd_base = 0x0100;
                 sony_nc_backlight_ng_read_limits(0x12f, &sony_bl_props);
                 max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
 
-        } else if (sony_find_snc_handle(0x137) != -1) {
+        } else if (sony_find_snc_handle(0x137) >= 0) {
                 ops = &sony_backlight_ng_ops;
+                sony_bl_props.cmd_base = 0x0100;
                 sony_nc_backlight_ng_read_limits(0x137, &sony_bl_props);
                 max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
 
+        } else if (sony_find_snc_handle(0x143) >= 0) {
+                ops = &sony_backlight_ng_ops;
+                sony_bl_props.cmd_base = 0x3000;
+                sony_nc_backlight_ng_read_limits(0x143, &sony_bl_props);
+                max_brightness = sony_bl_props.maxlvl - sony_bl_props.offset;
+
         } else if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "GBRT",
                                                 &unused))) {
                 ops = &sony_backlight_ops;
@@ -2597,6 +2642,12 @@ static int sony_nc_add(struct acpi_device *device)
                 }
         }
 
+        result = sony_laptop_setup_input(device);
+        if (result) {
+                pr_err("Unable to create input devices\n");
+                goto outplatform;
+        }
+
         if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "ECON",
                                          &handle))) {
                 int arg = 1;
@@ -2614,12 +2665,6 @@ static int sony_nc_add(struct acpi_device *device)
         }
 
         /* setup input devices and helper fifo */
-        result = sony_laptop_setup_input(device);
-        if (result) {
-                pr_err("Unable to create input devices\n");
-                goto outsnc;
-        }
-
         if (acpi_video_backlight_support()) {
                 pr_info("brightness ignored, must be controlled by ACPI video driver\n");
         } else {
@@ -2667,22 +2712,21 @@ static int sony_nc_add(struct acpi_device *device)
 
         return 0;
 
-      out_sysfs:
+out_sysfs:
         for (item = sony_nc_values; item->name; ++item) {
                 device_remove_file(&sony_pf_device->dev, &item->devattr);
         }
         sony_nc_backlight_cleanup();
-
-        sony_laptop_remove_input();
-
-      outsnc:
         sony_nc_function_cleanup(sony_pf_device);
         sony_nc_handles_cleanup(sony_pf_device);
 
-      outpresent:
+outplatform:
+        sony_laptop_remove_input();
+
+outpresent:
         sony_pf_remove();
 
-      outwalk:
+outwalk:
         sony_nc_rfkill_cleanup();
         return result;
 }
@@ -2728,9 +2772,9 @@ static struct acpi_driver sony_nc_driver = {
         .ops = {
                 .add = sony_nc_add,
                 .remove = sony_nc_remove,
-                .resume = sony_nc_resume,
                 .notify = sony_nc_notify,
                 },
+        .drv.pm = &sony_nc_pm,
 };
 
 /*********** SPIC (SNY6001) Device ***********/
@@ -4243,19 +4287,22 @@ err_free_resources:
         return result;
 }
 
-static int sony_pic_suspend(struct acpi_device *device, pm_message_t state)
+static int sony_pic_suspend(struct device *dev)
 {
-        if (sony_pic_disable(device))
+        if (sony_pic_disable(to_acpi_device(dev)))
                 return -ENXIO;
         return 0;
 }
 
-static int sony_pic_resume(struct acpi_device *device)
+static int sony_pic_resume(struct device *dev)
 {
-        sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq);
+        sony_pic_enable(to_acpi_device(dev),
+                        spic_dev.cur_ioport, spic_dev.cur_irq);
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(sony_pic_pm, sony_pic_suspend, sony_pic_resume);
+
 static const struct acpi_device_id sony_pic_device_ids[] = {
         {SONY_PIC_HID, 0},
         {"", 0},
@@ -4269,9 +4316,8 @@ static struct acpi_driver sony_pic_driver = {
         .ops = {
                 .add = sony_pic_add,
                 .remove = sony_pic_remove,
-                .suspend = sony_pic_suspend,
-                .resume = sony_pic_resume,
                 },
+        .drv.pm = &sony_pic_pm,
 };
 
 static struct dmi_system_id __initdata sonypi_dmi_table[] = {
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 8b5610d88418..d5fd4a1193f8 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -277,7 +277,7 @@ struct ibm_struct {
         int (*write) (char *);
         void (*exit) (void);
         void (*resume) (void);
-        void (*suspend) (pm_message_t state);
+        void (*suspend) (void);
         void (*shutdown) (void);
 
         struct list_head all_drivers;
@@ -922,8 +922,7 @@ static struct input_dev *tpacpi_inputdev;
 static struct mutex tpacpi_inputdev_send_mutex;
 static LIST_HEAD(tpacpi_all_drivers);
 
-static int tpacpi_suspend_handler(struct platform_device *pdev,
-                                  pm_message_t state)
+static int tpacpi_suspend_handler(struct device *dev)
 {
         struct ibm_struct *ibm, *itmp;
 
@@ -931,13 +930,13 @@ static int tpacpi_suspend_handler(struct platform_device *pdev,
                                  &tpacpi_all_drivers,
                                  all_drivers) {
                 if (ibm->suspend)
-                        (ibm->suspend)(state);
+                        (ibm->suspend)();
         }
 
         return 0;
 }
 
-static int tpacpi_resume_handler(struct platform_device *pdev)
+static int tpacpi_resume_handler(struct device *dev)
 {
         struct ibm_struct *ibm, *itmp;
 
@@ -951,6 +950,9 @@ static int tpacpi_resume_handler(struct platform_device *pdev)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(tpacpi_pm,
+                         tpacpi_suspend_handler, tpacpi_resume_handler);
+
 static void tpacpi_shutdown_handler(struct platform_device *pdev)
 {
         struct ibm_struct *ibm, *itmp;
@@ -967,9 +969,8 @@ static struct platform_driver tpacpi_pdriver = {
         .driver = {
                 .name = TPACPI_DRVR_NAME,
                 .owner = THIS_MODULE,
+                .pm = &tpacpi_pm,
         },
-        .suspend = tpacpi_suspend_handler,
-        .resume = tpacpi_resume_handler,
         .shutdown = tpacpi_shutdown_handler,
 };
 
@@ -3758,7 +3759,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
         }
 }
 
-static void hotkey_suspend(pm_message_t state)
+static void hotkey_suspend(void)
 {
         /* Do these on suspend, we get the events on early resume! */
         hotkey_wakeup_reason = TP_ACPI_WAKEUP_NONE;
@@ -6329,7 +6330,7 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
         return 0;
 }
 
-static void brightness_suspend(pm_message_t state)
+static void brightness_suspend(void)
 {
         tpacpi_brightness_checkpoint_nvram();
 }
@@ -6748,7 +6749,7 @@ static struct snd_kcontrol_new volume_alsa_control_mute __devinitdata = {
         .get = volume_alsa_mute_get,
 };
 
-static void volume_suspend(pm_message_t state)
+static void volume_suspend(void)
 {
         tpacpi_volume_checkpoint_nvram();
 }
@@ -8107,7 +8108,7 @@ static void fan_exit(void)
         flush_workqueue(tpacpi_wq);
 }
 
-static void fan_suspend(pm_message_t state)
+static void fan_suspend(void)
 {
         int rc;
 
diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c
index dab10f6edcd4..c13ba5bac93f 100644
--- a/drivers/platform/x86/toshiba_acpi.c
+++ b/drivers/platform/x86/toshiba_acpi.c
@@ -1296,10 +1296,9 @@ static void toshiba_acpi_notify(struct acpi_device *acpi_dev, u32 event)
         }
 }
 
-static int toshiba_acpi_suspend(struct acpi_device *acpi_dev,
-                                pm_message_t state)
+static int toshiba_acpi_suspend(struct device *device)
 {
-        struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
+        struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
         u32 result;
 
         if (dev->hotkey_dev)
@@ -1308,9 +1307,9 @@ static int toshiba_acpi_suspend(struct acpi_device *acpi_dev,
         return 0;
 }
 
-static int toshiba_acpi_resume(struct acpi_device *acpi_dev)
+static int toshiba_acpi_resume(struct device *device)
 {
-        struct toshiba_acpi_dev *dev = acpi_driver_data(acpi_dev);
+        struct toshiba_acpi_dev *dev = acpi_driver_data(to_acpi_device(device));
         u32 result;
 
         if (dev->hotkey_dev)
@@ -1319,6 +1318,9 @@ static int toshiba_acpi_resume(struct acpi_device *acpi_dev)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(toshiba_acpi_pm,
+                         toshiba_acpi_suspend, toshiba_acpi_resume);
+
 static struct acpi_driver toshiba_acpi_driver = {
         .name   = "Toshiba ACPI driver",
         .owner  = THIS_MODULE,
@@ -1328,9 +1330,8 @@ static struct acpi_driver toshiba_acpi_driver = {
                 .add            = toshiba_acpi_add,
                 .remove         = toshiba_acpi_remove,
                 .notify         = toshiba_acpi_notify,
-                .suspend        = toshiba_acpi_suspend,
-                .resume         = toshiba_acpi_resume,
         },
+        .drv.pm = &toshiba_acpi_pm,
 };
 
 static int __init toshiba_acpi_init(void)
diff --git a/drivers/platform/x86/toshiba_bluetooth.c b/drivers/platform/x86/toshiba_bluetooth.c
index 5fb7186694df..715a43cb5e3c 100644
--- a/drivers/platform/x86/toshiba_bluetooth.c
+++ b/drivers/platform/x86/toshiba_bluetooth.c
@@ -34,7 +34,6 @@ MODULE_LICENSE("GPL");
 static int toshiba_bt_rfkill_add(struct acpi_device *device);
 static int toshiba_bt_rfkill_remove(struct acpi_device *device, int type);
 static void toshiba_bt_rfkill_notify(struct acpi_device *device, u32 event);
-static int toshiba_bt_resume(struct acpi_device *device);
 
 static const struct acpi_device_id bt_device_ids[] = {
         { "TOS6205", 0},
@@ -42,6 +41,9 @@ static const struct acpi_device_id bt_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, bt_device_ids);
 
+static int toshiba_bt_resume(struct device *dev);
+static SIMPLE_DEV_PM_OPS(toshiba_bt_pm, NULL, toshiba_bt_resume);
+
 static struct acpi_driver toshiba_bt_rfkill_driver = {
         .name =         "Toshiba BT",
         .class =        "Toshiba",
@@ -50,9 +52,9 @@ static struct acpi_driver toshiba_bt_rfkill_driver = {
                                 .add =          toshiba_bt_rfkill_add,
                                 .remove =       toshiba_bt_rfkill_remove,
                                 .notify =       toshiba_bt_rfkill_notify,
-                                .resume =       toshiba_bt_resume,
                         },
         .owner =        THIS_MODULE,
+        .drv.pm =       &toshiba_bt_pm,
 };
 
 
@@ -88,9 +90,9 @@ static void toshiba_bt_rfkill_notify(struct acpi_device *device, u32 event)
         toshiba_bluetooth_enable(device->handle);
 }
 
-static int toshiba_bt_resume(struct acpi_device *device)
+static int toshiba_bt_resume(struct device *dev)
 {
-        return toshiba_bluetooth_enable(device->handle);
+        return toshiba_bluetooth_enable(to_acpi_device(dev)->handle);
 }
 
 static int toshiba_bt_rfkill_add(struct acpi_device *device)
diff --git a/drivers/platform/x86/xo15-ebook.c b/drivers/platform/x86/xo15-ebook.c
index fad153dc0355..849c07c13bf6 100644
--- a/drivers/platform/x86/xo15-ebook.c
+++ b/drivers/platform/x86/xo15-ebook.c
@@ -77,11 +77,13 @@ static void ebook_switch_notify(struct acpi_device *device, u32 event)
         }
 }
 
-static int ebook_switch_resume(struct acpi_device *device)
+static int ebook_switch_resume(struct device *dev)
 {
-        return ebook_send_state(device);
+        return ebook_send_state(to_acpi_device(dev));
 }
 
+static SIMPLE_DEV_PM_OPS(ebook_switch_pm, NULL, ebook_switch_resume);
+
 static int ebook_switch_add(struct acpi_device *device)
 {
         struct ebook_switch *button;
@@ -161,10 +163,10 @@ static struct acpi_driver xo15_ebook_driver = {
         .ids = ebook_device_ids,
         .ops = {
                 .add = ebook_switch_add,
-                .resume = ebook_switch_resume,
                 .remove = ebook_switch_remove,
                 .notify = ebook_switch_notify,
         },
+        .drv.pm = &ebook_switch_pm,
 };
 
 static int __init xo15_ebook_init(void)
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index c86b8864e411..f34c3be6c9fe 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -20,6 +20,7 @@ menuconfig REGULATOR
 
           If unsure, say no.
 
+
 if REGULATOR
 
 config REGULATOR_DEBUG
@@ -88,6 +89,13 @@ config REGULATOR_AAT2870
           If you have a AnalogicTech AAT2870 say Y to enable the
           regulator driver.
 
+config REGULATOR_ARIZONA
+        tristate "Wolfson Arizona class devices"
+        depends on MFD_ARIZONA
+        help
+          Support for the regulators found on Wolfson Arizona class
+          devices.
+
 config REGULATOR_DA903X
         tristate "Dialog Semiconductor DA9030/DA9034 regulators"
         depends on PMIC_DA903X
@@ -195,6 +203,14 @@ config REGULATOR_MAX8998
           via I2C bus. The provided regulator is suitable for S3C6410
           and S5PC1XX chips to control VCC_CORE and VCC_USIM voltages.
 
+config REGULATOR_MAX77686
+        tristate "Maxim 77686 regulator"
+        depends on MFD_MAX77686
+        help
+          This driver controls a Maxim 77686 regulator
+          via I2C bus. The provided regulator is suitable for
+          Exynos-4 chips to control VARM and VINT voltages.
+
 config REGULATOR_PCAP
         tristate "Motorola PCAP2 regulator driver"
         depends on EZX_PCAP
@@ -216,6 +232,19 @@ config REGULATOR_LP3972
          Say Y here to support the voltage regulators and convertors
          on National Semiconductors LP3972 PMIC
 
+config REGULATOR_LP872X
+        bool "TI/National Semiconductor LP8720/LP8725 voltage regulators"
+        depends on I2C=y
+        select REGMAP_I2C
+        help
+          This driver supports LP8720/LP8725 PMIC
+
+config REGULATOR_LP8788
+        bool "TI LP8788 Power Regulators"
+        depends on MFD_LP8788
+        help
+          This driver supports LP8788 voltage regulator chip.
+
 config REGULATOR_PCF50633
         tristate "NXP PCF50633 regulator driver"
         depends on MFD_PCF50633
@@ -233,6 +262,14 @@ config REGULATOR_RC5T583
           through regulator interface. The device supports multiple DCDC/LDO
           outputs which can be controlled by i2c communication.
 
+config REGULATOR_S2MPS11
+        tristate "Samsung S2MPS11 voltage regulator"
+        depends on MFD_SEC_CORE
+        help
+         This driver supports a Samsung S2MPS11 voltage output regulator
+         via I2C bus. S2MPS11 is comprised of high efficient Buck converters
+         including Dual-Phase Buck converter, Buck-Boost converter, various LDOs.
+
 config REGULATOR_S5M8767
         tristate "Samsung S5M8767A voltage regulator"
         depends on MFD_S5M_CORE
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 977fd46909ab..3342615cf25e 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -15,6 +15,7 @@ obj-$(CONFIG_REGULATOR_AB3100) += ab3100.o
 obj-$(CONFIG_REGULATOR_AB8500)  += ab8500.o
 obj-$(CONFIG_REGULATOR_AD5398) += ad5398.o
 obj-$(CONFIG_REGULATOR_ANATOP) += anatop-regulator.o
+obj-$(CONFIG_REGULATOR_ARIZONA) += arizona-micsupp.o arizona-ldo1.o
 obj-$(CONFIG_REGULATOR_DA903X)  += da903x.o
 obj-$(CONFIG_REGULATOR_DA9052)  += da9052-regulator.o
 obj-$(CONFIG_REGULATOR_DBX500_PRCMU) += dbx500-prcmu.o
@@ -23,6 +24,9 @@ obj-$(CONFIG_REGULATOR_GPIO) += gpio-regulator.o
 obj-$(CONFIG_REGULATOR_ISL6271A) += isl6271a-regulator.o
 obj-$(CONFIG_REGULATOR_LP3971) += lp3971.o
 obj-$(CONFIG_REGULATOR_LP3972) += lp3972.o
+obj-$(CONFIG_REGULATOR_LP872X) += lp872x.o
+obj-$(CONFIG_REGULATOR_LP8788) += lp8788-buck.o
+obj-$(CONFIG_REGULATOR_LP8788) += lp8788-ldo.o
 obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o
 obj-$(CONFIG_REGULATOR_MAX8649) += max8649.o
 obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o
@@ -30,6 +34,7 @@ obj-$(CONFIG_REGULATOR_MAX8925) += max8925-regulator.o
 obj-$(CONFIG_REGULATOR_MAX8952) += max8952.o
 obj-$(CONFIG_REGULATOR_MAX8997) += max8997.o
 obj-$(CONFIG_REGULATOR_MAX8998) += max8998.o
+obj-$(CONFIG_REGULATOR_MAX77686) += max77686.o
 obj-$(CONFIG_REGULATOR_MC13783) += mc13783-regulator.o
 obj-$(CONFIG_REGULATOR_MC13892) += mc13892-regulator.o
 obj-$(CONFIG_REGULATOR_MC13XXX_CORE) +=  mc13xxx-regulator-core.o
@@ -37,6 +42,7 @@ obj-$(CONFIG_REGULATOR_PALMAS) += palmas-regulator.o
 obj-$(CONFIG_REGULATOR_PCAP) += pcap-regulator.o
 obj-$(CONFIG_REGULATOR_PCF50633) += pcf50633-regulator.o
 obj-$(CONFIG_REGULATOR_RC5T583)  += rc5t583-regulator.o
+obj-$(CONFIG_REGULATOR_S2MPS11) += s2mps11.o
 obj-$(CONFIG_REGULATOR_S5M8767) += s5m8767.o
 obj-$(CONFIG_REGULATOR_TPS6105X) += tps6105x-regulator.o
 obj-$(CONFIG_REGULATOR_TPS62360) += tps62360-regulator.o
diff --git a/drivers/regulator/aat2870-regulator.c b/drivers/regulator/aat2870-regulator.c
index 06776ca945f2..6f45bfd22e83 100644
--- a/drivers/regulator/aat2870-regulator.c
+++ b/drivers/regulator/aat2870-regulator.c
@@ -33,11 +33,6 @@ struct aat2870_regulator {
         struct aat2870_data *aat2870;
         struct regulator_desc desc;
 
-        const int *voltages; /* uV */
-
-        int min_uV;
-        int max_uV;
-
         u8 enable_addr;
         u8 enable_shift;
         u8 enable_mask;
@@ -47,14 +42,6 @@ struct aat2870_regulator {
         u8 voltage_mask;
 };
 
-static int aat2870_ldo_list_voltage(struct regulator_dev *rdev,
-                                    unsigned selector)
-{
-        struct aat2870_regulator *ri = rdev_get_drvdata(rdev);
-
-        return ri->voltages[selector];
-}
-
 static int aat2870_ldo_set_voltage_sel(struct regulator_dev *rdev,
                                        unsigned selector)
 {
@@ -111,7 +98,7 @@ static int aat2870_ldo_is_enabled(struct regulator_dev *rdev)
 }
 
 static struct regulator_ops aat2870_ldo_ops = {
-        .list_voltage = aat2870_ldo_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage_sel = aat2870_ldo_set_voltage_sel,
         .get_voltage_sel = aat2870_ldo_get_voltage_sel,
         .enable = aat2870_ldo_enable,
@@ -119,7 +106,7 @@ static struct regulator_ops aat2870_ldo_ops = {
         .is_enabled = aat2870_ldo_is_enabled,
 };
 
-static const int aat2870_ldo_voltages[] = {
+static const unsigned int aat2870_ldo_voltages[] = {
         1200000, 1300000, 1500000, 1600000,
         1800000, 2000000, 2200000, 2500000,
         2600000, 2700000, 2800000, 2900000,
@@ -132,13 +119,11 @@ static const int aat2870_ldo_voltages[] = {
                         .name = #ids,                   \
                         .id = AAT2870_ID_##ids,         \
                         .n_voltages = ARRAY_SIZE(aat2870_ldo_voltages), \
+                        .volt_table = aat2870_ldo_voltages, \
                         .ops = &aat2870_ldo_ops,        \
                         .type = REGULATOR_VOLTAGE,      \
                         .owner = THIS_MODULE,           \
                 },                                      \
-                .voltages = aat2870_ldo_voltages,       \
-                .min_uV = 1200000,                      \
-                .max_uV = 3300000,                      \
         }
 
 static struct aat2870_regulator aat2870_regulators[] = {
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
index 03f4d9c604ec..182b553059c9 100644
--- a/drivers/regulator/ab3100.c
+++ b/drivers/regulator/ab3100.c
@@ -43,20 +43,12 @@
  * @dev: handle to the device
  * @plfdata: AB3100 platform data passed in at probe time
  * @regreg: regulator register number in the AB3100
- * @fixed_voltage: a fixed voltage for this regulator, if this
- *          0 the voltages array is used instead.
- * @typ_voltages: an array of available typical voltages for
- *          this regulator
- * @voltages_len: length of the array of available voltages
  */
 struct ab3100_regulator {
         struct regulator_dev *rdev;
         struct device *dev;
         struct ab3100_platform_data *plfdata;
         u8 regreg;
-        int fixed_voltage;
-        int const *typ_voltages;
-        u8 voltages_len;
 };
 
 /* The order in which registers are initialized */
@@ -80,7 +72,7 @@ static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
 #define LDO_C_VOLTAGE 2650000
 #define LDO_D_VOLTAGE 2650000
 
-static const int ldo_e_buck_typ_voltages[] = {
+static const unsigned int ldo_e_buck_typ_voltages[] = {
         1800000,
         1400000,
         1300000,
@@ -90,7 +82,7 @@ static const int ldo_e_buck_typ_voltages[] = {
         900000,
 };
 
-static const int ldo_f_typ_voltages[] = {
+static const unsigned int ldo_f_typ_voltages[] = {
         1800000,
         1400000,
         1300000,
@@ -101,21 +93,21 @@ static const int ldo_f_typ_voltages[] = {
         2650000,
 };
 
-static const int ldo_g_typ_voltages[] = {
+static const unsigned int ldo_g_typ_voltages[] = {
         2850000,
         2750000,
         1800000,
         1500000,
 };
 
-static const int ldo_h_typ_voltages[] = {
+static const unsigned int ldo_h_typ_voltages[] = {
         2750000,
         1800000,
         1500000,
         1200000,
 };
 
-static const int ldo_k_typ_voltages[] = {
+static const unsigned int ldo_k_typ_voltages[] = {
         2750000,
         1800000,
 };
@@ -126,40 +118,27 @@ static struct ab3100_regulator
 ab3100_regulators[AB3100_NUM_REGULATORS] = {
         {
                 .regreg = AB3100_LDO_A,
-                .fixed_voltage = LDO_A_VOLTAGE,
         },
         {
                 .regreg = AB3100_LDO_C,
-                .fixed_voltage = LDO_C_VOLTAGE,
         },
         {
                 .regreg = AB3100_LDO_D,
-                .fixed_voltage = LDO_D_VOLTAGE,
         },
         {
                 .regreg = AB3100_LDO_E,
-                .typ_voltages = ldo_e_buck_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_F,
-                .typ_voltages = ldo_f_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_f_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_G,
-                .typ_voltages = ldo_g_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_g_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_H,
-                .typ_voltages = ldo_h_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_h_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_K,
-                .typ_voltages = ldo_k_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_k_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_EXT,
@@ -167,8 +146,6 @@ ab3100_regulators[AB3100_NUM_REGULATORS] = {
         },
         {
                 .regreg = AB3100_BUCK,
-                .typ_voltages = ldo_e_buck_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
         },
 };
 
@@ -178,7 +155,7 @@ ab3100_regulators[AB3100_NUM_REGULATORS] = {
  */
 static int ab3100_enable_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         int err;
         u8 regval;
 
@@ -209,7 +186,7 @@ static int ab3100_enable_regulator(struct regulator_dev *reg)
 
 static int ab3100_disable_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         int err;
         u8 regval;
 
@@ -242,7 +219,7 @@ static int ab3100_disable_regulator(struct regulator_dev *reg)
 
 static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         u8 regval;
         int err;
 
@@ -257,26 +234,12 @@ static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
         return regval & AB3100_REG_ON_MASK;
 }
 
-static int ab3100_list_voltage_regulator(struct regulator_dev *reg,
-                                         unsigned selector)
-{
-        struct ab3100_regulator *abreg = reg->reg_data;
-
-        if (selector >= abreg->voltages_len)
-                return -EINVAL;
-        return abreg->typ_voltages[selector];
-}
-
 static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         u8 regval;
         int err;
 
-        /* Return the voltage for fixed regulators immediately */
-        if (abreg->fixed_voltage)
-                return abreg->fixed_voltage;
-
         /*
          * For variable types, read out setting and index into
          * supplied voltage list.
@@ -294,20 +257,20 @@ static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
         regval &= 0xE0;
         regval >>= 5;
 
-        if (regval >= abreg->voltages_len) {
+        if (regval >= reg->desc->n_voltages) {
                 dev_err(&reg->dev,
                         "regulator register %02x contains an illegal voltage setting\n",
                         abreg->regreg);
                 return -EINVAL;
         }
 
-        return abreg->typ_voltages[regval];
+        return reg->desc->volt_table[regval];
 }
 
 static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
                                             unsigned selector)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         u8 regval;
         int err;
 
@@ -336,7 +299,7 @@ static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
 static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
                                                 int uV)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         u8 regval;
         int err;
         int bestindex;
@@ -379,42 +342,22 @@ static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
  */
 static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 
         return abreg->plfdata->external_voltage;
 }
 
-static int ab3100_enable_time_regulator(struct regulator_dev *reg)
+static int ab3100_get_fixed_voltage_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
-
-        /* Per-regulator power on delay from spec */
-        switch (abreg->regreg) {
-        case AB3100_LDO_A: /* Fallthrough */
-        case AB3100_LDO_C: /* Fallthrough */
-        case AB3100_LDO_D: /* Fallthrough */
-        case AB3100_LDO_E: /* Fallthrough */
-        case AB3100_LDO_H: /* Fallthrough */
-        case AB3100_LDO_K:
-                return 200;
-        case AB3100_LDO_F:
-                return 600;
-        case AB3100_LDO_G:
-                return 400;
-        case AB3100_BUCK:
-                return 1000;
-        default:
-                break;
-        }
-        return 0;
+        return reg->desc->min_uV;
 }
 
 static struct regulator_ops regulator_ops_fixed = {
+        .list_voltage = regulator_list_voltage_linear,
         .enable      = ab3100_enable_regulator,
         .disable     = ab3100_disable_regulator,
         .is_enabled  = ab3100_is_enabled_regulator,
-        .get_voltage = ab3100_get_voltage_regulator,
-        .enable_time = ab3100_enable_time_regulator,
+        .get_voltage = ab3100_get_fixed_voltage_regulator,
 };
 
 static struct regulator_ops regulator_ops_variable = {
@@ -423,8 +366,7 @@ static struct regulator_ops regulator_ops_variable = {
         .is_enabled  = ab3100_is_enabled_regulator,
         .get_voltage = ab3100_get_voltage_regulator,
         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
-        .list_voltage = ab3100_list_voltage_regulator,
-        .enable_time = ab3100_enable_time_regulator,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 static struct regulator_ops regulator_ops_variable_sleepable = {
@@ -434,8 +376,7 @@ static struct regulator_ops regulator_ops_variable_sleepable = {
         .get_voltage = ab3100_get_voltage_regulator,
         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
         .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
-        .list_voltage = ab3100_list_voltage_regulator,
-        .enable_time = ab3100_enable_time_regulator,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 /*
@@ -457,62 +398,81 @@ ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
                 .name = "LDO_A",
                 .id   = AB3100_LDO_A,
                 .ops  = &regulator_ops_fixed,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .min_uV = LDO_A_VOLTAGE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_C",
                 .id   = AB3100_LDO_C,
                 .ops  = &regulator_ops_fixed,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .min_uV = LDO_C_VOLTAGE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_D",
                 .id   = AB3100_LDO_D,
                 .ops  = &regulator_ops_fixed,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .min_uV = LDO_D_VOLTAGE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_E",
                 .id   = AB3100_LDO_E,
                 .ops  = &regulator_ops_variable_sleepable,
                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
+                .volt_table = ldo_e_buck_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_F",
                 .id   = AB3100_LDO_F,
                 .ops  = &regulator_ops_variable,
                 .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
+                .volt_table = ldo_f_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 600,
         },
         {
                 .name = "LDO_G",
                 .id   = AB3100_LDO_G,
                 .ops  = &regulator_ops_variable,
                 .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
+                .volt_table = ldo_g_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 400,
         },
         {
                 .name = "LDO_H",
                 .id   = AB3100_LDO_H,
                 .ops  = &regulator_ops_variable,
                 .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
+                .volt_table = ldo_h_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_K",
                 .id   = AB3100_LDO_K,
                 .ops  = &regulator_ops_variable,
                 .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
+                .volt_table = ldo_k_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_EXT",
@@ -528,6 +488,7 @@ ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 1000,
         },
 };
 
diff --git a/drivers/regulator/ab8500.c b/drivers/regulator/ab8500.c
index a739f5ca936a..13d424fc1c14 100644
--- a/drivers/regulator/ab8500.c
+++ b/drivers/regulator/ab8500.c
@@ -30,9 +30,6 @@
  * @dev: device pointer
  * @desc: regulator description
  * @regulator_dev: regulator device
- * @max_uV: maximum voltage (for variable voltage supplies)
- * @min_uV: minimum voltage (for variable voltage supplies)
- * @fixed_uV: typical voltage (for fixed voltage supplies)
  * @update_bank: bank to control on/off
  * @update_reg: register to control on/off
  * @update_mask: mask to enable/disable regulator
@@ -40,17 +37,12 @@
  * @voltage_bank: bank to control regulator voltage
  * @voltage_reg: register to control regulator voltage
  * @voltage_mask: mask to control regulator voltage
- * @voltages: supported voltage table
- * @voltages_len: number of supported voltages for the regulator
  * @delay: startup/set voltage delay in us
  */
 struct ab8500_regulator_info {
         struct device           *dev;
         struct regulator_desc   desc;
         struct regulator_dev    *regulator;
-        int max_uV;
-        int min_uV;
-        int fixed_uV;
         u8 update_bank;
         u8 update_reg;
         u8 update_mask;
@@ -58,13 +50,11 @@ struct ab8500_regulator_info {
         u8 voltage_bank;
         u8 voltage_reg;
         u8 voltage_mask;
-        int const *voltages;
-        int voltages_len;
         unsigned int delay;
 };
 
 /* voltage tables for the vauxn/vintcore supplies */
-static const int ldo_vauxn_voltages[] = {
+static const unsigned int ldo_vauxn_voltages[] = {
         1100000,
         1200000,
         1300000,
@@ -83,7 +73,7 @@ static const int ldo_vauxn_voltages[] = {
         3300000,
 };
 
-static const int ldo_vaux3_voltages[] = {
+static const unsigned int ldo_vaux3_voltages[] = {
         1200000,
         1500000,
         1800000,
@@ -94,7 +84,7 @@ static const int ldo_vaux3_voltages[] = {
         2910000,
 };
 
-static const int ldo_vintcore_voltages[] = {
+static const unsigned int ldo_vintcore_voltages[] = {
         1200000,
         1225000,
         1250000,
@@ -185,25 +175,6 @@ static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
                 return false;
 }
 
-static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
-{
-        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
-
-        if (info == NULL) {
-                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
-                return -EINVAL;
-        }
-
-        /* return the uV for the fixed regulators */
-        if (info->fixed_uV)
-                return info->fixed_uV;
-
-        if (selector >= info->voltages_len)
-                return -EINVAL;
-
-        return info->voltages[selector];
-}
-
 static int ab8500_regulator_get_voltage_sel(struct regulator_dev *rdev)
 {
         int ret, val;
@@ -279,14 +250,7 @@ static int ab8500_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
                                              unsigned int new_sel)
 {
         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
-        int ret;
 
-        /* If the regulator isn't on, it won't take time here */
-        ret = ab8500_regulator_is_enabled(rdev);
-        if (ret < 0)
-                return ret;
-        if (!ret)
-                return 0;
         return info->delay;
 }
 
@@ -296,21 +260,14 @@ static struct regulator_ops ab8500_regulator_ops = {
         .is_enabled     = ab8500_regulator_is_enabled,
         .get_voltage_sel = ab8500_regulator_get_voltage_sel,
         .set_voltage_sel = ab8500_regulator_set_voltage_sel,
-        .list_voltage   = ab8500_list_voltage,
+        .list_voltage   = regulator_list_voltage_table,
         .enable_time    = ab8500_regulator_enable_time,
         .set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
 };
 
 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
 {
-        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
-
-        if (info == NULL) {
-                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
-                return -EINVAL;
-        }
-
-        return info->fixed_uV;
+        return rdev->desc->min_uV;
 }
 
 static struct regulator_ops ab8500_regulator_fixed_ops = {
@@ -318,9 +275,8 @@ static struct regulator_ops ab8500_regulator_fixed_ops = {
         .disable        = ab8500_regulator_disable,
         .is_enabled     = ab8500_regulator_is_enabled,
         .get_voltage    = ab8500_fixed_get_voltage,
-        .list_voltage   = ab8500_list_voltage,
+        .list_voltage   = regulator_list_voltage_linear,
         .enable_time    = ab8500_regulator_enable_time,
-        .set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
 };
 
 static struct ab8500_regulator_info
@@ -329,7 +285,7 @@ static struct ab8500_regulator_info
          * Variable Voltage Regulators
          *   name, min mV, max mV,
          *   update bank, reg, mask, enable val
-         *   volt bank, reg, mask, table, table length
+         *   volt bank, reg, mask
          */
         [AB8500_LDO_AUX1] = {
                 .desc = {
@@ -339,9 +295,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_AUX1,
                         .owner          = THIS_MODULE,
                         .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
+                        .volt_table     = ldo_vauxn_voltages,
                 },
-                .min_uV                 = 1100000,
-                .max_uV                 = 3300000,
                 .update_bank            = 0x04,
                 .update_reg             = 0x09,
                 .update_mask            = 0x03,
@@ -349,8 +304,6 @@ static struct ab8500_regulator_info
                 .voltage_bank           = 0x04,
                 .voltage_reg            = 0x1f,
                 .voltage_mask           = 0x0f,
-                .voltages               = ldo_vauxn_voltages,
-                .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
         },
         [AB8500_LDO_AUX2] = {
                 .desc = {
@@ -360,9 +313,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_AUX2,
                         .owner          = THIS_MODULE,
                         .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
+                        .volt_table     = ldo_vauxn_voltages,
                 },
-                .min_uV                 = 1100000,
-                .max_uV                 = 3300000,
                 .update_bank            = 0x04,
                 .update_reg             = 0x09,
                 .update_mask            = 0x0c,
@@ -370,8 +322,6 @@ static struct ab8500_regulator_info
                 .voltage_bank           = 0x04,
                 .voltage_reg            = 0x20,
                 .voltage_mask           = 0x0f,
-                .voltages               = ldo_vauxn_voltages,
-                .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
         },
         [AB8500_LDO_AUX3] = {
                 .desc = {
@@ -381,9 +331,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_AUX3,
                         .owner          = THIS_MODULE,
                         .n_voltages     = ARRAY_SIZE(ldo_vaux3_voltages),
+                        .volt_table     = ldo_vaux3_voltages,
                 },
-                .min_uV                 = 1100000,
-                .max_uV                 = 3300000,
                 .update_bank            = 0x04,
                 .update_reg             = 0x0a,
                 .update_mask            = 0x03,
@@ -391,8 +340,6 @@ static struct ab8500_regulator_info
                 .voltage_bank           = 0x04,
                 .voltage_reg            = 0x21,
                 .voltage_mask           = 0x07,
-                .voltages               = ldo_vaux3_voltages,
-                .voltages_len           = ARRAY_SIZE(ldo_vaux3_voltages),
         },
         [AB8500_LDO_INTCORE] = {
                 .desc = {
@@ -402,9 +349,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_INTCORE,
                         .owner          = THIS_MODULE,
                         .n_voltages     = ARRAY_SIZE(ldo_vintcore_voltages),
+                        .volt_table     = ldo_vintcore_voltages,
                 },
-                .min_uV                 = 1100000,
-                .max_uV                 = 3300000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x80,
                 .update_mask            = 0x44,
@@ -412,8 +358,6 @@ static struct ab8500_regulator_info
                 .voltage_bank           = 0x03,
                 .voltage_reg            = 0x80,
                 .voltage_mask           = 0x38,
-                .voltages               = ldo_vintcore_voltages,
-                .voltages_len           = ARRAY_SIZE(ldo_vintcore_voltages),
         },
 
         /*
@@ -429,9 +373,9 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_TVOUT,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 2000000,
                 },
                 .delay                  = 10000,
-                .fixed_uV               = 2000000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x80,
                 .update_mask            = 0x82,
@@ -445,8 +389,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_USB,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 3300000,
                 },
-                .fixed_uV               = 3300000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x82,
                 .update_mask            = 0x03,
@@ -460,8 +404,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_AUDIO,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 2000000,
                 },
-                .fixed_uV               = 2000000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x83,
                 .update_mask            = 0x02,
@@ -475,8 +419,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_ANAMIC1,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 2050000,
                 },
-                .fixed_uV               = 2050000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x83,
                 .update_mask            = 0x08,
@@ -490,8 +434,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_ANAMIC2,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 2050000,
                 },
-                .fixed_uV               = 2050000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x83,
                 .update_mask            = 0x10,
@@ -505,8 +449,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_DMIC,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 1800000,
                 },
-                .fixed_uV               = 1800000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x83,
                 .update_mask            = 0x04,
@@ -520,8 +464,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_ANA,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 1200000,
                 },
-                .fixed_uV               = 1200000,
                 .update_bank            = 0x04,
                 .update_reg             = 0x06,
                 .update_mask            = 0x0c,
@@ -769,9 +713,7 @@ static __devinit int ab8500_regulator_register(struct platform_device *pdev,
                 if (info->desc.id == AB8500_LDO_AUX3) {
                         info->desc.n_voltages =
                                 ARRAY_SIZE(ldo_vauxn_voltages);
-                        info->voltages = ldo_vauxn_voltages;
-                        info->voltages_len =
-                                ARRAY_SIZE(ldo_vauxn_voltages);
+                        info->desc.volt_table = ldo_vauxn_voltages;
                         info->voltage_mask = 0xf;
                 }
         }
diff --git a/drivers/regulator/ad5398.c b/drivers/regulator/ad5398.c
index 46d05f38baf8..f123f7e3b752 100644
--- a/drivers/regulator/ad5398.c
+++ b/drivers/regulator/ad5398.c
@@ -89,9 +89,12 @@ static int ad5398_set_current_limit(struct regulator_dev *rdev, int min_uA, int
         unsigned short data;
         int ret;
 
-        if (min_uA > chip->max_uA || min_uA < chip->min_uA)
-                return -EINVAL;
-        if (max_uA > chip->max_uA || max_uA < chip->min_uA)
+        if (min_uA < chip->min_uA)
+                min_uA = chip->min_uA;
+        if (max_uA > chip->max_uA)
+                max_uA = chip->max_uA;
+
+        if (min_uA > chip->max_uA || max_uA < chip->min_uA)
                 return -EINVAL;
 
         selector = DIV_ROUND_UP((min_uA - chip->min_uA) * chip->current_level,
diff --git a/drivers/regulator/anatop-regulator.c b/drivers/regulator/anatop-regulator.c
index e82e7eaac0f1..e9c2085f9dfb 100644
--- a/drivers/regulator/anatop-regulator.c
+++ b/drivers/regulator/anatop-regulator.c
@@ -43,33 +43,15 @@ struct anatop_regulator {
         struct regulator_init_data *initdata;
 };
 
-static int anatop_set_voltage(struct regulator_dev *reg, int min_uV,
-                                  int max_uV, unsigned *selector)
+static int anatop_set_voltage_sel(struct regulator_dev *reg, unsigned selector)
 {
         struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
-        u32 val, sel, mask;
-        int uv;
-
-        uv = min_uV;
-        dev_dbg(&reg->dev, "%s: uv %d, min %d, max %d\n", __func__,
-                uv, anatop_reg->min_voltage,
-                anatop_reg->max_voltage);
-
-        if (uv < anatop_reg->min_voltage) {
-                if (max_uV > anatop_reg->min_voltage)
-                        uv = anatop_reg->min_voltage;
-                else
-                        return -EINVAL;
-        }
+        u32 val, mask;
 
         if (!anatop_reg->control_reg)
                 return -ENOTSUPP;
 
-        sel = DIV_ROUND_UP(uv - anatop_reg->min_voltage, 25000);
-        if (sel * 25000 + anatop_reg->min_voltage > anatop_reg->max_voltage)
-                return -EINVAL;
-        val = anatop_reg->min_bit_val + sel;
-        *selector = sel;
+        val = anatop_reg->min_bit_val + selector;
         dev_dbg(&reg->dev, "%s: calculated val %d\n", __func__, val);
         mask = ((1 << anatop_reg->vol_bit_width) - 1) <<
                 anatop_reg->vol_bit_shift;
@@ -94,21 +76,11 @@ static int anatop_get_voltage_sel(struct regulator_dev *reg)
         return val - anatop_reg->min_bit_val;
 }
 
-static int anatop_list_voltage(struct regulator_dev *reg, unsigned selector)
-{
-        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
-        int uv;
-
-        uv = anatop_reg->min_voltage + selector * 25000;
-        dev_dbg(&reg->dev, "vddio = %d, selector = %u\n", uv, selector);
-
-        return uv;
-}
-
 static struct regulator_ops anatop_rops = {
-        .set_voltage     = anatop_set_voltage,
+        .set_voltage_sel = anatop_set_voltage_sel,
         .get_voltage_sel = anatop_get_voltage_sel,
-        .list_voltage    = anatop_list_voltage,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
 };
 
 static int __devinit anatop_regulator_probe(struct platform_device *pdev)
@@ -176,6 +148,8 @@ static int __devinit anatop_regulator_probe(struct platform_device *pdev)
 
         rdesc->n_voltages = (sreg->max_voltage - sreg->min_voltage)
                 / 25000 + 1;
+        rdesc->min_uV = sreg->min_voltage;
+        rdesc->uV_step = 25000;
 
         config.dev = &pdev->dev;
         config.init_data = initdata;
diff --git a/drivers/regulator/arizona-ldo1.c b/drivers/regulator/arizona-ldo1.c
new file mode 100644
index 000000000000..c8f95c07adb6
--- /dev/null
+++ b/drivers/regulator/arizona-ldo1.c
@@ -0,0 +1,138 @@
+/*
+ * arizona-ldo1.c  --  LDO1 supply for Arizona devices
+ *
+ * Copyright 2012 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.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/bitops.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+
+#include <linux/mfd/arizona/core.h>
+#include <linux/mfd/arizona/pdata.h>
+#include <linux/mfd/arizona/registers.h>
+
+struct arizona_ldo1 {
+        struct regulator_dev *regulator;
+        struct arizona *arizona;
+
+        struct regulator_consumer_supply supply;
+        struct regulator_init_data init_data;
+};
+
+static struct regulator_ops arizona_ldo1_ops = {
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+};
+
+static const struct regulator_desc arizona_ldo1 = {
+        .name = "LDO1",
+        .supply_name = "LDOVDD",
+        .type = REGULATOR_VOLTAGE,
+        .ops = &arizona_ldo1_ops,
+
+        .vsel_reg = ARIZONA_LDO1_CONTROL_1,
+        .vsel_mask = ARIZONA_LDO1_VSEL_MASK,
+        .min_uV = 900000,
+        .uV_step = 50000,
+        .n_voltages = 7,
+
+        .owner = THIS_MODULE,
+};
+
+static const struct regulator_init_data arizona_ldo1_default = {
+        .constraints = {
+                .valid_ops_mask = REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies = 1,
+};
+
+static __devinit int arizona_ldo1_probe(struct platform_device *pdev)
+{
+        struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
+        struct regulator_config config = { };
+        struct arizona_ldo1 *ldo1;
+        int ret;
+
+        ldo1 = devm_kzalloc(&pdev->dev, sizeof(*ldo1), GFP_KERNEL);
+        if (ldo1 == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        ldo1->arizona = arizona;
+
+        /*
+         * Since the chip usually supplies itself we provide some
+         * default init_data for it.  This will be overridden with
+         * platform data if provided.
+         */
+        ldo1->init_data = arizona_ldo1_default;
+        ldo1->init_data.consumer_supplies = &ldo1->supply;
+        ldo1->supply.supply = "DCVDD";
+        ldo1->supply.dev_name = dev_name(arizona->dev);
+
+        config.dev = arizona->dev;
+        config.driver_data = ldo1;
+        config.regmap = arizona->regmap;
+        config.ena_gpio = arizona->pdata.ldoena;
+
+        if (arizona->pdata.ldo1)
+                config.init_data = arizona->pdata.ldo1;
+        else
+                config.init_data = &ldo1->init_data;
+
+        ldo1->regulator = regulator_register(&arizona_ldo1, &config);
+        if (IS_ERR(ldo1->regulator)) {
+                ret = PTR_ERR(ldo1->regulator);
+                dev_err(arizona->dev, "Failed to register LDO1 supply: %d\n",
+                        ret);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, ldo1);
+
+        return 0;
+}
+
+static __devexit int arizona_ldo1_remove(struct platform_device *pdev)
+{
+        struct arizona_ldo1 *ldo1 = platform_get_drvdata(pdev);
+
+        regulator_unregister(ldo1->regulator);
+
+        return 0;
+}
+
+static struct platform_driver arizona_ldo1_driver = {
+        .probe = arizona_ldo1_probe,
+        .remove = __devexit_p(arizona_ldo1_remove),
+        .driver         = {
+                .name   = "arizona-ldo1",
+                .owner  = THIS_MODULE,
+        },
+};
+
+module_platform_driver(arizona_ldo1_driver);
+
+/* Module information */
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("Arizona LDO1 driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:arizona-ldo1");
diff --git a/drivers/regulator/arizona-micsupp.c b/drivers/regulator/arizona-micsupp.c
new file mode 100644
index 000000000000..450a069aa9b6
--- /dev/null
+++ b/drivers/regulator/arizona-micsupp.c
@@ -0,0 +1,188 @@
+/*
+ * arizona-micsupp.c  --  Microphone supply for Arizona devices
+ *
+ * Copyright 2012 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.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/bitops.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+
+#include <linux/mfd/arizona/core.h>
+#include <linux/mfd/arizona/pdata.h>
+#include <linux/mfd/arizona/registers.h>
+
+#define ARIZONA_MICSUPP_MAX_SELECTOR 0x1f
+
+struct arizona_micsupp {
+        struct regulator_dev *regulator;
+        struct arizona *arizona;
+
+        struct regulator_consumer_supply supply;
+        struct regulator_init_data init_data;
+};
+
+static int arizona_micsupp_list_voltage(struct regulator_dev *rdev,
+                                        unsigned int selector)
+{
+        if (selector > ARIZONA_MICSUPP_MAX_SELECTOR)
+                return -EINVAL;
+
+        if (selector == ARIZONA_MICSUPP_MAX_SELECTOR)
+                return 3300000;
+        else
+                return (selector * 50000) + 1700000;
+}
+
+static int arizona_micsupp_map_voltage(struct regulator_dev *rdev,
+                                       int min_uV, int max_uV)
+{
+        unsigned int voltage;
+        int selector;
+
+        if (min_uV < 1700000)
+                min_uV = 1700000;
+
+        if (min_uV > 3200000)
+                selector = ARIZONA_MICSUPP_MAX_SELECTOR;
+        else
+                selector = DIV_ROUND_UP(min_uV - 1700000, 50000);
+
+        if (selector < 0)
+                return -EINVAL;
+
+        voltage = arizona_micsupp_list_voltage(rdev, selector);
+        if (voltage < min_uV || voltage > max_uV)
+                return -EINVAL;
+
+        return selector;
+}
+
+static struct regulator_ops arizona_micsupp_ops = {
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+
+        .list_voltage = arizona_micsupp_list_voltage,
+        .map_voltage = arizona_micsupp_map_voltage,
+
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+};
+
+static const struct regulator_desc arizona_micsupp = {
+        .name = "MICVDD",
+        .supply_name = "CPVDD",
+        .type = REGULATOR_VOLTAGE,
+        .n_voltages = ARIZONA_MICSUPP_MAX_SELECTOR + 1,
+        .ops = &arizona_micsupp_ops,
+
+        .vsel_reg = ARIZONA_LDO2_CONTROL_1,
+        .vsel_mask = ARIZONA_LDO2_VSEL_MASK,
+        .enable_reg = ARIZONA_MIC_CHARGE_PUMP_1,
+        .enable_mask = ARIZONA_CPMIC_ENA,
+
+        .owner = THIS_MODULE,
+};
+
+static const struct regulator_init_data arizona_micsupp_default = {
+        .constraints = {
+                .valid_ops_mask = REGULATOR_CHANGE_STATUS |
+                                REGULATOR_CHANGE_VOLTAGE,
+                .min_uV = 1700000,
+                .max_uV = 3300000,
+        },
+
+        .num_consumer_supplies = 1,
+};
+
+static __devinit int arizona_micsupp_probe(struct platform_device *pdev)
+{
+        struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
+        struct regulator_config config = { };
+        struct arizona_micsupp *micsupp;
+        int ret;
+
+        micsupp = devm_kzalloc(&pdev->dev, sizeof(*micsupp), GFP_KERNEL);
+        if (micsupp == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        micsupp->arizona = arizona;
+
+        /*
+         * Since the chip usually supplies itself we provide some
+         * default init_data for it.  This will be overridden with
+         * platform data if provided.
+         */
+        micsupp->init_data = arizona_micsupp_default;
+        micsupp->init_data.consumer_supplies = &micsupp->supply;
+        micsupp->supply.supply = "MICVDD";
+        micsupp->supply.dev_name = dev_name(arizona->dev);
+
+        config.dev = arizona->dev;
+        config.driver_data = micsupp;
+        config.regmap = arizona->regmap;
+
+        if (arizona->pdata.micvdd)
+                config.init_data = arizona->pdata.micvdd;
+        else
+                config.init_data = &micsupp->init_data;
+
+        /* Default to regulated mode until the API supports bypass */
+        regmap_update_bits(arizona->regmap, ARIZONA_MIC_CHARGE_PUMP_1,
+                           ARIZONA_CPMIC_BYPASS, 0);
+
+        micsupp->regulator = regulator_register(&arizona_micsupp, &config);
+        if (IS_ERR(micsupp->regulator)) {
+                ret = PTR_ERR(micsupp->regulator);
+                dev_err(arizona->dev, "Failed to register mic supply: %d\n",
+                        ret);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, micsupp);
+
+        return 0;
+}
+
+static __devexit int arizona_micsupp_remove(struct platform_device *pdev)
+{
+        struct arizona_micsupp *micsupp = platform_get_drvdata(pdev);
+
+        regulator_unregister(micsupp->regulator);
+
+        return 0;
+}
+
+static struct platform_driver arizona_micsupp_driver = {
+        .probe = arizona_micsupp_probe,
+        .remove = __devexit_p(arizona_micsupp_remove),
+        .driver         = {
+                .name   = "arizona-micsupp",
+                .owner  = THIS_MODULE,
+        },
+};
+
+module_platform_driver(arizona_micsupp_driver);
+
+/* Module information */
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("Arizona microphone supply driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:arizona-micsupp");
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index 09a737c868b5..2e31dffbefe7 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -23,6 +23,7 @@
 #include <linux/mutex.h>
 #include <linux/suspend.h>
 #include <linux/delay.h>
+#include <linux/gpio.h>
 #include <linux/of.h>
 #include <linux/regmap.h>
 #include <linux/regulator/of_regulator.h>
@@ -108,28 +109,6 @@ static const char *rdev_get_name(struct regulator_dev *rdev)
                 return "";
 }
 
-/* gets the regulator for a given consumer device */
-static struct regulator *get_device_regulator(struct device *dev)
-{
-        struct regulator *regulator = NULL;
-        struct regulator_dev *rdev;
-
-        mutex_lock(&regulator_list_mutex);
-        list_for_each_entry(rdev, &regulator_list, list) {
-                mutex_lock(&rdev->mutex);
-                list_for_each_entry(regulator, &rdev->consumer_list, list) {
-                        if (regulator->dev == dev) {
-                                mutex_unlock(&rdev->mutex);
-                                mutex_unlock(&regulator_list_mutex);
-                                return regulator;
-                        }
-                }
-                mutex_unlock(&rdev->mutex);
-        }
-        mutex_unlock(&regulator_list_mutex);
-        return NULL;
-}
-
 /**
  * of_get_regulator - get a regulator device node based on supply name
  * @dev: Device pointer for the consumer (of regulator) device
@@ -303,18 +282,6 @@ static int regulator_check_drms(struct regulator_dev *rdev)
         return 0;
 }
 
-static ssize_t device_requested_uA_show(struct device *dev,
-                             struct device_attribute *attr, char *buf)
-{
-        struct regulator *regulator;
-
-        regulator = get_device_regulator(dev);
-        if (regulator == NULL)
-                return 0;
-
-        return sprintf(buf, "%d\n", regulator->uA_load);
-}
-
 static ssize_t regulator_uV_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
@@ -427,6 +394,9 @@ static ssize_t regulator_status_show(struct device *dev,
         case REGULATOR_STATUS_STANDBY:
                 label = "standby";
                 break;
+        case REGULATOR_STATUS_UNDEFINED:
+                label = "undefined";
+                break;
         default:
                 return -ERANGE;
         }
@@ -967,6 +937,14 @@ static int set_machine_constraints(struct regulator_dev *rdev,
                 }
         }
 
+        if (rdev->constraints->ramp_delay && ops->set_ramp_delay) {
+                ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
+                if (ret < 0) {
+                        rdev_err(rdev, "failed to set ramp_delay\n");
+                        goto out;
+                }
+        }
+
         print_constraints(rdev);
         return 0;
 out:
@@ -1097,48 +1075,29 @@ static struct regulator *create_regulator(struct regulator_dev *rdev,
         list_add(&regulator->list, &rdev->consumer_list);
 
         if (dev) {
-                /* create a 'requested_microamps_name' sysfs entry */
-                size = scnprintf(buf, REG_STR_SIZE,
-                                 "microamps_requested_%s-%s",
-                                 dev_name(dev), supply_name);
-                if (size >= REG_STR_SIZE)
-                        goto overflow_err;
-
                 regulator->dev = dev;
-                sysfs_attr_init(&regulator->dev_attr.attr);
-                regulator->dev_attr.attr.name = kstrdup(buf, GFP_KERNEL);
-                if (regulator->dev_attr.attr.name == NULL)
-                        goto attr_name_err;
-
-                regulator->dev_attr.attr.mode = 0444;
-                regulator->dev_attr.show = device_requested_uA_show;
-                err = device_create_file(dev, &regulator->dev_attr);
-                if (err < 0) {
-                        rdev_warn(rdev, "could not add regulator_dev requested microamps sysfs entry\n");
-                        goto attr_name_err;
-                }
 
-                /* also add a link to the device sysfs entry */
+                /* Add a link to the device sysfs entry */
                 size = scnprintf(buf, REG_STR_SIZE, "%s-%s",
                                  dev->kobj.name, supply_name);
                 if (size >= REG_STR_SIZE)
-                        goto attr_err;
+                        goto overflow_err;
 
                 regulator->supply_name = kstrdup(buf, GFP_KERNEL);
                 if (regulator->supply_name == NULL)
-                        goto attr_err;
+                        goto overflow_err;
 
                 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
                                         buf);
                 if (err) {
                         rdev_warn(rdev, "could not add device link %s err %d\n",
                                   dev->kobj.name, err);
-                        goto link_name_err;
+                        /* non-fatal */
                 }
         } else {
                 regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
                 if (regulator->supply_name == NULL)
-                        goto attr_err;
+                        goto overflow_err;
         }
 
         regulator->debugfs = debugfs_create_dir(regulator->supply_name,
@@ -1165,12 +1124,6 @@ static struct regulator *create_regulator(struct regulator_dev *rdev,
 
         mutex_unlock(&rdev->mutex);
         return regulator;
-link_name_err:
-        kfree(regulator->supply_name);
-attr_err:
-        device_remove_file(regulator->dev, &regulator->dev_attr);
-attr_name_err:
-        kfree(regulator->dev_attr.attr.name);
 overflow_err:
         list_del(&regulator->list);
         kfree(regulator);
@@ -1181,7 +1134,7 @@ overflow_err:
 static int _regulator_get_enable_time(struct regulator_dev *rdev)
 {
         if (!rdev->desc->ops->enable_time)
-                return 0;
+                return rdev->desc->enable_time;
         return rdev->desc->ops->enable_time(rdev);
 }
 
@@ -1420,11 +1373,8 @@ void regulator_put(struct regulator *regulator)
         debugfs_remove_recursive(regulator->debugfs);
 
         /* remove any sysfs entries */
-        if (regulator->dev) {
+        if (regulator->dev)
                 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
-                device_remove_file(regulator->dev, &regulator->dev_attr);
-                kfree(regulator->dev_attr.attr.name);
-        }
         kfree(regulator->supply_name);
         list_del(&regulator->list);
         kfree(regulator);
@@ -1459,19 +1409,61 @@ void devm_regulator_put(struct regulator *regulator)
 {
         int rc;
 
-        rc = devres_destroy(regulator->dev, devm_regulator_release,
+        rc = devres_release(regulator->dev, devm_regulator_release,
                             devm_regulator_match, regulator);
-        if (rc == 0)
-                regulator_put(regulator);
-        else
+        if (rc != 0)
                 WARN_ON(rc);
 }
 EXPORT_SYMBOL_GPL(devm_regulator_put);
 
+static int _regulator_do_enable(struct regulator_dev *rdev)
+{
+        int ret, delay;
+
+        /* Query before enabling in case configuration dependent.  */
+        ret = _regulator_get_enable_time(rdev);
+        if (ret >= 0) {
+                delay = ret;
+        } else {
+                rdev_warn(rdev, "enable_time() failed: %d\n", ret);
+                delay = 0;
+        }
+
+        trace_regulator_enable(rdev_get_name(rdev));
+
+        if (rdev->ena_gpio) {
+                gpio_set_value_cansleep(rdev->ena_gpio,
+                                        !rdev->ena_gpio_invert);
+                rdev->ena_gpio_state = 1;
+        } else if (rdev->desc->ops->enable) {
+                ret = rdev->desc->ops->enable(rdev);
+                if (ret < 0)
+                        return ret;
+        } else {
+                return -EINVAL;
+        }
+
+        /* Allow the regulator to ramp; it would be useful to extend
+         * this for bulk operations so that the regulators can ramp
+         * together.  */
+        trace_regulator_enable_delay(rdev_get_name(rdev));
+
+        if (delay >= 1000) {
+                mdelay(delay / 1000);
+                udelay(delay % 1000);
+        } else if (delay) {
+                udelay(delay);
+        }
+
+        trace_regulator_enable_complete(rdev_get_name(rdev));
+
+        return 0;
+}
+
 /* locks held by regulator_enable() */
 static int _regulator_enable(struct regulator_dev *rdev)
 {
-        int ret, delay;
+        int ret;
 
         /* check voltage and requested load before enabling */
         if (rdev->constraints &&
@@ -1485,40 +1477,10 @@ static int _regulator_enable(struct regulator_dev *rdev)
                         if (!_regulator_can_change_status(rdev))
                                 return -EPERM;
 
-                        if (!rdev->desc->ops->enable)
-                                return -EINVAL;
-
-                        /* Query before enabling in case configuration
-                         * dependent.  */
-                        ret = _regulator_get_enable_time(rdev);
-                        if (ret >= 0) {
-                                delay = ret;
-                        } else {
-                                rdev_warn(rdev, "enable_time() failed: %d\n",
-                                           ret);
-                                delay = 0;
-                        }
-
-                        trace_regulator_enable(rdev_get_name(rdev));
-
-                        /* Allow the regulator to ramp; it would be useful
-                         * to extend this for bulk operations so that the
-                         * regulators can ramp together.  */
-                        ret = rdev->desc->ops->enable(rdev);
+                        ret = _regulator_do_enable(rdev);
                         if (ret < 0)
                                 return ret;
 
-                        trace_regulator_enable_delay(rdev_get_name(rdev));
-
-                        if (delay >= 1000) {
-                                mdelay(delay / 1000);
-                                udelay(delay % 1000);
-                        } else if (delay) {
-                                udelay(delay);
-                        }
-
-                        trace_regulator_enable_complete(rdev_get_name(rdev));
-
                 } else if (ret < 0) {
                         rdev_err(rdev, "is_enabled() failed: %d\n", ret);
                         return ret;
@@ -1567,6 +1529,30 @@ int regulator_enable(struct regulator *regulator)
 }
 EXPORT_SYMBOL_GPL(regulator_enable);
 
+static int _regulator_do_disable(struct regulator_dev *rdev)
+{
+        int ret;
+
+        trace_regulator_disable(rdev_get_name(rdev));
+
+        if (rdev->ena_gpio) {
+                gpio_set_value_cansleep(rdev->ena_gpio,
+                                        rdev->ena_gpio_invert);
+                rdev->ena_gpio_state = 0;
+
+        } else if (rdev->desc->ops->disable) {
+                ret = rdev->desc->ops->disable(rdev);
+                if (ret != 0)
+                        return ret;
+        }
+
+        trace_regulator_disable_complete(rdev_get_name(rdev));
+
+        _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
+                             NULL);
+        return 0;
+}
+
 /* locks held by regulator_disable() */
 static int _regulator_disable(struct regulator_dev *rdev)
 {
@@ -1581,20 +1567,12 @@ static int _regulator_disable(struct regulator_dev *rdev)
             (rdev->constraints && !rdev->constraints->always_on)) {
 
                 /* we are last user */
-                if (_regulator_can_change_status(rdev) &&
-                    rdev->desc->ops->disable) {
-                        trace_regulator_disable(rdev_get_name(rdev));
-
-                        ret = rdev->desc->ops->disable(rdev);
+                if (_regulator_can_change_status(rdev)) {
+                        ret = _regulator_do_disable(rdev);
                         if (ret < 0) {
                                 rdev_err(rdev, "failed to disable\n");
                                 return ret;
                         }
-
-                        trace_regulator_disable_complete(rdev_get_name(rdev));
-
-                        _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
-                                             NULL);
                 }
 
                 rdev->use_count = 0;
@@ -1812,6 +1790,10 @@ EXPORT_SYMBOL_GPL(regulator_disable_regmap);
 
 static int _regulator_is_enabled(struct regulator_dev *rdev)
 {
+        /* A GPIO control always takes precedence */
+        if (rdev->ena_gpio)
+                return rdev->ena_gpio_state;
+
         /* If we don't know then assume that the regulator is always on */
         if (!rdev->desc->ops->is_enabled)
                 return 1;
@@ -1883,6 +1865,31 @@ int regulator_list_voltage_linear(struct regulator_dev *rdev,
 EXPORT_SYMBOL_GPL(regulator_list_voltage_linear);
 
 /**
+ * regulator_list_voltage_table - List voltages with table based mapping
+ *
+ * @rdev: Regulator device
+ * @selector: Selector to convert into a voltage
+ *
+ * Regulators with table based mapping between voltages and
+ * selectors can set volt_table in the regulator descriptor
+ * and then use this function as their list_voltage() operation.
+ */
+int regulator_list_voltage_table(struct regulator_dev *rdev,
+                                 unsigned int selector)
+{
+        if (!rdev->desc->volt_table) {
+                BUG_ON(!rdev->desc->volt_table);
+                return -EINVAL;
+        }
+
+        if (selector >= rdev->desc->n_voltages)
+                return -EINVAL;
+
+        return rdev->desc->volt_table[selector];
+}
+EXPORT_SYMBOL_GPL(regulator_list_voltage_table);
+
+/**
  * regulator_list_voltage - enumerate supported voltages
  * @regulator: regulator source
  * @selector: identify voltage to list
@@ -1928,8 +1935,18 @@ EXPORT_SYMBOL_GPL(regulator_list_voltage);
 int regulator_is_supported_voltage(struct regulator *regulator,
                                    int min_uV, int max_uV)
 {
+        struct regulator_dev *rdev = regulator->rdev;
         int i, voltages, ret;
 
+        /* If we can't change voltage check the current voltage */
+        if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
+                ret = regulator_get_voltage(regulator);
+                if (ret >= 0)
+                        return (min_uV >= ret && ret <= max_uV);
+                else
+                        return ret;
+        }
+
         ret = regulator_count_voltages(regulator);
         if (ret < 0)
                 return ret;
@@ -2045,6 +2062,14 @@ int regulator_map_voltage_linear(struct regulator_dev *rdev,
 {
         int ret, voltage;
 
+        /* Allow uV_step to be 0 for fixed voltage */
+        if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
+                if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
+                        return 0;
+                else
+                        return -EINVAL;
+        }
+
         if (!rdev->desc->uV_step) {
                 BUG_ON(!rdev->desc->uV_step);
                 return -EINVAL;
@@ -2071,7 +2096,7 @@ static int _regulator_do_set_voltage(struct regulator_dev *rdev,
 {
         int ret;
         int delay = 0;
-        int best_val;
+        int best_val = 0;
         unsigned int selector;
         int old_selector = -1;
 
@@ -2084,7 +2109,8 @@ static int _regulator_do_set_voltage(struct regulator_dev *rdev,
          * If we can't obtain the old selector there is not enough
          * info to call set_voltage_time_sel().
          */
-        if (rdev->desc->ops->set_voltage_time_sel &&
+        if (_regulator_is_enabled(rdev) &&
+            rdev->desc->ops->set_voltage_time_sel &&
             rdev->desc->ops->get_voltage_sel) {
                 old_selector = rdev->desc->ops->get_voltage_sel(rdev);
                 if (old_selector < 0)
@@ -2094,29 +2120,45 @@ static int _regulator_do_set_voltage(struct regulator_dev *rdev,
         if (rdev->desc->ops->set_voltage) {
                 ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
                                                    &selector);
+
+                if (ret >= 0) {
+                        if (rdev->desc->ops->list_voltage)
+                                best_val = rdev->desc->ops->list_voltage(rdev,
+                                                                         selector);
+                        else
+                                best_val = _regulator_get_voltage(rdev);
+                }
+
         } else if (rdev->desc->ops->set_voltage_sel) {
-                if (rdev->desc->ops->map_voltage)
+                if (rdev->desc->ops->map_voltage) {
                         ret = rdev->desc->ops->map_voltage(rdev, min_uV,
                                                            max_uV);
-                else
-                        ret = regulator_map_voltage_iterate(rdev, min_uV,
-                                                            max_uV);
+                } else {
+                        if (rdev->desc->ops->list_voltage ==
+                            regulator_list_voltage_linear)
+                                ret = regulator_map_voltage_linear(rdev,
+                                                                min_uV, max_uV);
+                        else
+                                ret = regulator_map_voltage_iterate(rdev,
+                                                                min_uV, max_uV);
+                }
 
                 if (ret >= 0) {
-                        selector = ret;
-                        ret = rdev->desc->ops->set_voltage_sel(rdev, ret);
+                        best_val = rdev->desc->ops->list_voltage(rdev, ret);
+                        if (min_uV <= best_val && max_uV >= best_val) {
+                                selector = ret;
+                                ret = rdev->desc->ops->set_voltage_sel(rdev,
+                                                                       ret);
+                        } else {
+                                ret = -EINVAL;
+                        }
                 }
         } else {
                 ret = -EINVAL;
         }
 
-        if (rdev->desc->ops->list_voltage)
-                best_val = rdev->desc->ops->list_voltage(rdev, selector);
-        else
-                best_val = -1;
-
         /* Call set_voltage_time_sel if successfully obtained old_selector */
-        if (ret == 0 && old_selector >= 0 &&
+        if (ret == 0 && _regulator_is_enabled(rdev) && old_selector >= 0 &&
             rdev->desc->ops->set_voltage_time_sel) {
 
                 delay = rdev->desc->ops->set_voltage_time_sel(rdev,
@@ -2126,19 +2168,19 @@ static int _regulator_do_set_voltage(struct regulator_dev *rdev,
                                   delay);
                         delay = 0;
                 }
-        }
 
-        /* Insert any necessary delays */
-        if (delay >= 1000) {
-                mdelay(delay / 1000);
-                udelay(delay % 1000);
-        } else if (delay) {
-                udelay(delay);
+                /* Insert any necessary delays */
+                if (delay >= 1000) {
+                        mdelay(delay / 1000);
+                        udelay(delay % 1000);
+                } else if (delay) {
+                        udelay(delay);
+                }
         }
 
-        if (ret == 0)
+        if (ret == 0 && best_val >= 0)
                 _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
-                                     NULL);
+                                     (void *)best_val);
 
         trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
 
@@ -2249,6 +2291,46 @@ int regulator_set_voltage_time(struct regulator *regulator,
 EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
 
 /**
+ *regulator_set_voltage_time_sel - get raise/fall time
+ * @regulator: regulator source
+ * @old_selector: selector for starting voltage
+ * @new_selector: selector for target voltage
+ *
+ * Provided with the starting and target voltage selectors, this function
+ * returns time in microseconds required to rise or fall to this new voltage
+ *
+ * Drivers providing ramp_delay in regulation_constraints can use this as their
+ * set_voltage_time_sel() operation.
+ */
+int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
+                                   unsigned int old_selector,
+                                   unsigned int new_selector)
+{
+        unsigned int ramp_delay = 0;
+        int old_volt, new_volt;
+
+        if (rdev->constraints->ramp_delay)
+                ramp_delay = rdev->constraints->ramp_delay;
+        else if (rdev->desc->ramp_delay)
+                ramp_delay = rdev->desc->ramp_delay;
+
+        if (ramp_delay == 0) {
+                rdev_warn(rdev, "ramp_delay not set\n");
+                return 0;
+        }
+
+        /* sanity check */
+        if (!rdev->desc->ops->list_voltage)
+                return -EINVAL;
+
+        old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
+        new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
+
+        return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
+}
+EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
+
+/**
  * regulator_sync_voltage - re-apply last regulator output voltage
  * @regulator: regulator source
  *
@@ -2519,9 +2601,12 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
 {
         struct regulator_dev *rdev = regulator->rdev;
         struct regulator *consumer;
-        int ret, output_uV, input_uV, total_uA_load = 0;
+        int ret, output_uV, input_uV = 0, total_uA_load = 0;
         unsigned int mode;
 
+        if (rdev->supply)
+                input_uV = regulator_get_voltage(rdev->supply);
+
         mutex_lock(&rdev->mutex);
 
         /*
@@ -2554,10 +2639,7 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
                 goto out;
         }
 
-        /* get input voltage */
-        input_uV = 0;
-        if (rdev->supply)
-                input_uV = regulator_get_voltage(rdev->supply);
+        /* No supply? Use constraint voltage */
         if (input_uV <= 0)
                 input_uV = rdev->constraints->input_uV;
         if (input_uV <= 0) {
@@ -2628,7 +2710,7 @@ static void _notifier_call_chain(struct regulator_dev *rdev,
                                   unsigned long event, void *data)
 {
         /* call rdev chain first */
-        blocking_notifier_call_chain(&rdev->notifier, event, NULL);
+        blocking_notifier_call_chain(&rdev->notifier, event, data);
 }
 
 /**
@@ -2909,10 +2991,10 @@ int regulator_mode_to_status(unsigned int mode)
                 return REGULATOR_STATUS_NORMAL;
         case REGULATOR_MODE_IDLE:
                 return REGULATOR_STATUS_IDLE;
-        case REGULATOR_STATUS_STANDBY:
+        case REGULATOR_MODE_STANDBY:
                 return REGULATOR_STATUS_STANDBY;
         default:
-                return 0;
+                return REGULATOR_STATUS_UNDEFINED;
         }
 }
 EXPORT_SYMBOL_GPL(regulator_mode_to_status);
@@ -3105,7 +3187,10 @@ regulator_register(const struct regulator_desc *regulator_desc,
         rdev->reg_data = config->driver_data;
         rdev->owner = regulator_desc->owner;
         rdev->desc = regulator_desc;
-        rdev->regmap = config->regmap;
+        if (config->regmap)
+                rdev->regmap = config->regmap;
+        else
+                rdev->regmap = dev_get_regmap(dev, NULL);
         INIT_LIST_HEAD(&rdev->consumer_list);
         INIT_LIST_HEAD(&rdev->list);
         BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
@@ -3132,6 +3217,26 @@ regulator_register(const struct regulator_desc *regulator_desc,
 
         dev_set_drvdata(&rdev->dev, rdev);
 
+        if (config->ena_gpio) {
+                ret = gpio_request_one(config->ena_gpio,
+                                       GPIOF_DIR_OUT | config->ena_gpio_flags,
+                                       rdev_get_name(rdev));
+                if (ret != 0) {
+                        rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
+                                 config->ena_gpio, ret);
+                        goto clean;
+                }
+
+                rdev->ena_gpio = config->ena_gpio;
+                rdev->ena_gpio_invert = config->ena_gpio_invert;
+
+                if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH)
+                        rdev->ena_gpio_state = 1;
+
+                if (rdev->ena_gpio_invert)
+                        rdev->ena_gpio_state = !rdev->ena_gpio_state;
+        }
+
         /* set regulator constraints */
         if (init_data)
                 constraints = &init_data->constraints;
@@ -3200,6 +3305,8 @@ unset_supplies:
 scrub:
         if (rdev->supply)
                 regulator_put(rdev->supply);
+        if (rdev->ena_gpio)
+                gpio_free(rdev->ena_gpio);
         kfree(rdev->constraints);
         device_unregister(&rdev->dev);
         /* device core frees rdev */
@@ -3233,6 +3340,8 @@ void regulator_unregister(struct regulator_dev *rdev)
         unset_regulator_supplies(rdev);
         list_del(&rdev->list);
         kfree(rdev->constraints);
+        if (rdev->ena_gpio)
+                gpio_free(rdev->ena_gpio);
         device_unregister(&rdev->dev);
         mutex_unlock(&regulator_list_mutex);
 }
@@ -3472,6 +3581,15 @@ static int __init regulator_init_complete(void)
         struct regulation_constraints *c;
         int enabled, ret;
 
+        /*
+         * Since DT doesn't provide an idiomatic mechanism for
+         * enabling full constraints and since it's much more natural
+         * with DT to provide them just assume that a DT enabled
+         * system has full constraints.
+         */
+        if (of_have_populated_dt())
+                has_full_constraints = true;
+
         mutex_lock(&regulator_list_mutex);
 
         /* If we have a full configuration then disable any regulators
diff --git a/drivers/regulator/da903x.c b/drivers/regulator/da903x.c
index 1005f5f7e603..36c5b92fe0af 100644
--- a/drivers/regulator/da903x.c
+++ b/drivers/regulator/da903x.c
@@ -107,6 +107,9 @@ static int da903x_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
         struct device *da9034_dev = to_da903x_dev(rdev);
         uint8_t val, mask;
 
+        if (rdev->desc->n_voltages == 1)
+                return -EINVAL;
+
         val = selector << info->vol_shift;
         mask = ((1 << info->vol_nbits) - 1)  << info->vol_shift;
 
@@ -120,6 +123,9 @@ static int da903x_get_voltage_sel(struct regulator_dev *rdev)
         uint8_t val, mask;
         int ret;
 
+        if (rdev->desc->n_voltages == 1)
+                return 0;
+
         ret = da903x_read(da9034_dev, info->vol_reg, &val);
         if (ret)
                 return ret;
diff --git a/drivers/regulator/da9052-regulator.c b/drivers/regulator/da9052-regulator.c
index 88976d8d44ed..903299cf15cf 100644
--- a/drivers/regulator/da9052-regulator.c
+++ b/drivers/regulator/da9052-regulator.c
@@ -405,12 +405,12 @@ static int __devinit da9052_regulator_probe(struct platform_device *pdev)
                 if (!nproot)
                         return -ENODEV;
 
-                for (np = of_get_next_child(nproot, NULL); np;
-                     np = of_get_next_child(nproot, np)) {
+                for_each_child_of_node(nproot, np) {
                         if (!of_node_cmp(np->name,
                                          regulator->info->reg_desc.name)) {
                                 config.init_data = of_get_regulator_init_data(
                                         &pdev->dev, np);
+                                config.of_node = np;
                                 break;
                         }
                 }
diff --git a/drivers/regulator/fixed-helper.c b/drivers/regulator/fixed-helper.c
index cacd33c9d042..f9d027992aae 100644
--- a/drivers/regulator/fixed-helper.c
+++ b/drivers/regulator/fixed-helper.c
@@ -1,4 +1,5 @@
 #include <linux/slab.h>
+#include <linux/string.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/machine.h>
 #include <linux/regulator/fixed.h>
@@ -13,17 +14,20 @@ static void regulator_fixed_release(struct device *dev)
 {
         struct fixed_regulator_data *data = container_of(dev,
                         struct fixed_regulator_data, pdev.dev);
+        kfree(data->cfg.supply_name);
         kfree(data);
 }
 
 /**
- * regulator_register_fixed - register a no-op fixed regulator
+ * regulator_register_fixed_name - register a no-op fixed regulator
  * @id: platform device id
+ * @name: name to be used for the regulator
  * @supplies: consumers for this regulator
  * @num_supplies: number of consumers
+ * @uv: voltage in microvolts
  */
-struct platform_device *regulator_register_fixed(int id,
-                struct regulator_consumer_supply *supplies, int num_supplies)
+struct platform_device *regulator_register_always_on(int id, const char *name,
+        struct regulator_consumer_supply *supplies, int num_supplies, int uv)
 {
         struct fixed_regulator_data *data;
 
@@ -31,8 +35,13 @@ struct platform_device *regulator_register_fixed(int id,
         if (!data)
                 return NULL;
 
-        data->cfg.supply_name = "fixed-dummy";
-        data->cfg.microvolts = 0;
+        data->cfg.supply_name = kstrdup(name, GFP_KERNEL);
+        if (!data->cfg.supply_name) {
+                kfree(data);
+                return NULL;
+        }
+
+        data->cfg.microvolts = uv;
         data->cfg.gpio = -EINVAL;
         data->cfg.enabled_at_boot = 1;
         data->cfg.init_data = &data->init_data;
diff --git a/drivers/regulator/fixed.c b/drivers/regulator/fixed.c
index f09fe7b20e82..185468c4d38f 100644
--- a/drivers/regulator/fixed.c
+++ b/drivers/regulator/fixed.c
@@ -35,10 +35,6 @@ struct fixed_voltage_data {
         struct regulator_desc desc;
         struct regulator_dev *dev;
         int microvolts;
-        int gpio;
-        unsigned startup_delay;
-        bool enable_high;
-        bool is_enabled;
 };
 
 
@@ -61,11 +57,11 @@ of_get_fixed_voltage_config(struct device *dev)
         config = devm_kzalloc(dev, sizeof(struct fixed_voltage_config),
                                                                  GFP_KERNEL);
         if (!config)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         config->init_data = of_get_regulator_init_data(dev, dev->of_node);
         if (!config->init_data)
-                return NULL;
+                return ERR_PTR(-EINVAL);
 
         init_data = config->init_data;
         init_data->constraints.apply_uV = 0;
@@ -76,13 +72,26 @@ of_get_fixed_voltage_config(struct device *dev)
         } else {
                 dev_err(dev,
                          "Fixed regulator specified with variable voltages\n");
-                return NULL;
+                return ERR_PTR(-EINVAL);
         }
 
         if (init_data->constraints.boot_on)
                 config->enabled_at_boot = true;
 
         config->gpio = of_get_named_gpio(np, "gpio", 0);
+        /*
+         * of_get_named_gpio() currently returns ENODEV rather than
+         * EPROBE_DEFER. This code attempts to be compatible with both
+         * for now; the ENODEV check can be removed once the API is fixed.
+         * of_get_named_gpio() doesn't differentiate between a missing
+         * property (which would be fine here, since the GPIO is optional)
+         * and some other error. Patches have been posted for both issues.
+         * Once they are check in, we should replace this with:
+         * if (config->gpio < 0 && config->gpio != -ENOENT)
+         */
+        if ((config->gpio == -ENODEV) || (config->gpio == -EPROBE_DEFER))
+                return ERR_PTR(-EPROBE_DEFER);
+
         delay = of_get_property(np, "startup-delay-us", NULL);
         if (delay)
                 config->startup_delay = be32_to_cpu(*delay);
@@ -93,41 +102,10 @@ of_get_fixed_voltage_config(struct device *dev)
         if (of_find_property(np, "gpio-open-drain", NULL))
                 config->gpio_is_open_drain = true;
 
-        return config;
-}
-
-static int fixed_voltage_is_enabled(struct regulator_dev *dev)
-{
-        struct fixed_voltage_data *data = rdev_get_drvdata(dev);
-
-        return data->is_enabled;
-}
-
-static int fixed_voltage_enable(struct regulator_dev *dev)
-{
-        struct fixed_voltage_data *data = rdev_get_drvdata(dev);
-
-        gpio_set_value_cansleep(data->gpio, data->enable_high);
-        data->is_enabled = true;
-
-        return 0;
-}
-
-static int fixed_voltage_disable(struct regulator_dev *dev)
-{
-        struct fixed_voltage_data *data = rdev_get_drvdata(dev);
-
-        gpio_set_value_cansleep(data->gpio, !data->enable_high);
-        data->is_enabled = false;
-
-        return 0;
-}
+        if (of_find_property(np, "vin-supply", NULL))
+                config->input_supply = "vin";
 
-static int fixed_voltage_enable_time(struct regulator_dev *dev)
-{
-        struct fixed_voltage_data *data = rdev_get_drvdata(dev);
-
-        return data->startup_delay;
+        return config;
 }
 
 static int fixed_voltage_get_voltage(struct regulator_dev *dev)
@@ -151,15 +129,6 @@ static int fixed_voltage_list_voltage(struct regulator_dev *dev,
         return data->microvolts;
 }
 
-static struct regulator_ops fixed_voltage_gpio_ops = {
-        .is_enabled = fixed_voltage_is_enabled,
-        .enable = fixed_voltage_enable,
-        .disable = fixed_voltage_disable,
-        .enable_time = fixed_voltage_enable_time,
-        .get_voltage = fixed_voltage_get_voltage,
-        .list_voltage = fixed_voltage_list_voltage,
-};
-
 static struct regulator_ops fixed_voltage_ops = {
         .get_voltage = fixed_voltage_get_voltage,
         .list_voltage = fixed_voltage_list_voltage,
@@ -172,10 +141,13 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
         struct regulator_config cfg = { };
         int ret;
 
-        if (pdev->dev.of_node)
+        if (pdev->dev.of_node) {
                 config = of_get_fixed_voltage_config(&pdev->dev);
-        else
+                if (IS_ERR(config))
+                        return PTR_ERR(config);
+        } else {
                 config = pdev->dev.platform_data;
+        }
 
         if (!config)
                 return -ENOMEM;
@@ -196,59 +168,44 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
         }
         drvdata->desc.type = REGULATOR_VOLTAGE;
         drvdata->desc.owner = THIS_MODULE;
+        drvdata->desc.ops = &fixed_voltage_ops;
 
-        if (config->microvolts)
-                drvdata->desc.n_voltages = 1;
+        drvdata->desc.enable_time = config->startup_delay;
 
-        drvdata->microvolts = config->microvolts;
-        drvdata->gpio = config->gpio;
-        drvdata->startup_delay = config->startup_delay;
-
-        if (gpio_is_valid(config->gpio)) {
-                int gpio_flag;
-                drvdata->enable_high = config->enable_high;
-
-                /* FIXME: Remove below print warning
-                 *
-                 * config->gpio must be set to -EINVAL by platform code if
-                 * GPIO control is not required. However, early adopters
-                 * not requiring GPIO control may forget to initialize
-                 * config->gpio to -EINVAL. This will cause GPIO 0 to be used
-                 * for GPIO control.
-                 *
-                 * This warning will be removed once there are a couple of users
-                 * for this driver.
-                 */
-                if (!config->gpio)
-                        dev_warn(&pdev->dev,
-                                "using GPIO 0 for regulator enable control\n");
-
-                /*
-                 * set output direction without changing state
-                 * to prevent glitch
-                 */
-                drvdata->is_enabled = config->enabled_at_boot;
-                ret = drvdata->is_enabled ?
-                                config->enable_high : !config->enable_high;
-                gpio_flag = ret ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
-
-                if (config->gpio_is_open_drain)
-                        gpio_flag |= GPIOF_OPEN_DRAIN;
-
-                ret = gpio_request_one(config->gpio, gpio_flag,
-                                                config->supply_name);
-                if (ret) {
+        if (config->input_supply) {
+                drvdata->desc.supply_name = kstrdup(config->input_supply,
+                                                        GFP_KERNEL);
+                if (!drvdata->desc.supply_name) {
                         dev_err(&pdev->dev,
-                           "Could not obtain regulator enable GPIO %d: %d\n",
-                                                        config->gpio, ret);
+                                "Failed to allocate input supply\n");
+                        ret = -ENOMEM;
                         goto err_name;
                 }
+        }
+
+        if (config->microvolts)
+                drvdata->desc.n_voltages = 1;
 
-                drvdata->desc.ops = &fixed_voltage_gpio_ops;
+        drvdata->microvolts = config->microvolts;
 
+        if (config->gpio >= 0)
+                cfg.ena_gpio = config->gpio;
+        cfg.ena_gpio_invert = !config->enable_high;
+        if (config->enabled_at_boot) {
+                if (config->enable_high) {
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+                } else {
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
+                }
         } else {
-                drvdata->desc.ops = &fixed_voltage_ops;
+                if (config->enable_high) {
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
+                } else {
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+                }
         }
+        if (config->gpio_is_open_drain)
+                cfg.ena_gpio_flags |= GPIOF_OPEN_DRAIN;
 
         cfg.dev = &pdev->dev;
         cfg.init_data = config->init_data;
@@ -259,7 +216,7 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
         if (IS_ERR(drvdata->dev)) {
                 ret = PTR_ERR(drvdata->dev);
                 dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
-                goto err_gpio;
+                goto err_input;
         }
 
         platform_set_drvdata(pdev, drvdata);
@@ -269,9 +226,8 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
 
         return 0;
 
-err_gpio:
-        if (gpio_is_valid(config->gpio))
-                gpio_free(config->gpio);
+err_input:
+        kfree(drvdata->desc.supply_name);
 err_name:
         kfree(drvdata->desc.name);
 err:
@@ -283,8 +239,7 @@ static int __devexit reg_fixed_voltage_remove(struct platform_device *pdev)
         struct fixed_voltage_data *drvdata = platform_get_drvdata(pdev);
 
         regulator_unregister(drvdata->dev);
-        if (gpio_is_valid(drvdata->gpio))
-                gpio_free(drvdata->gpio);
+        kfree(drvdata->desc.supply_name);
         kfree(drvdata->desc.name);
 
         return 0;
@@ -296,8 +251,6 @@ static const struct of_device_id fixed_of_match[] __devinitconst = {
         {},
 };
 MODULE_DEVICE_TABLE(of, fixed_of_match);
-#else
-#define fixed_of_match NULL
 #endif
 
 static struct platform_driver regulator_fixed_voltage_driver = {
@@ -306,7 +259,7 @@ static struct platform_driver regulator_fixed_voltage_driver = {
         .driver         = {
                 .name           = "reg-fixed-voltage",
                 .owner          = THIS_MODULE,
-                .of_match_table = fixed_of_match,
+                .of_match_table = of_match_ptr(fixed_of_match),
         },
 };
 
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c
index 242851a4c1a6..34b67bee9323 100644
--- a/drivers/regulator/gpio-regulator.c
+++ b/drivers/regulator/gpio-regulator.c
@@ -36,11 +36,6 @@ struct gpio_regulator_data {
         struct regulator_desc desc;
         struct regulator_dev *dev;
 
-        int enable_gpio;
-        bool enable_high;
-        bool is_enabled;
-        unsigned startup_delay;
-
         struct gpio *gpios;
         int nr_gpios;
 
@@ -50,44 +45,6 @@ struct gpio_regulator_data {
         int state;
 };
 
-static int gpio_regulator_is_enabled(struct regulator_dev *dev)
-{
-        struct gpio_regulator_data *data = rdev_get_drvdata(dev);
-
-        return data->is_enabled;
-}
-
-static int gpio_regulator_enable(struct regulator_dev *dev)
-{
-        struct gpio_regulator_data *data = rdev_get_drvdata(dev);
-
-        if (gpio_is_valid(data->enable_gpio)) {
-                gpio_set_value_cansleep(data->enable_gpio, data->enable_high);
-                data->is_enabled = true;
-        }
-
-        return 0;
-}
-
-static int gpio_regulator_disable(struct regulator_dev *dev)
-{
-        struct gpio_regulator_data *data = rdev_get_drvdata(dev);
-
-        if (gpio_is_valid(data->enable_gpio)) {
-                gpio_set_value_cansleep(data->enable_gpio, !data->enable_high);
-                data->is_enabled = false;
-        }
-
-        return 0;
-}
-
-static int gpio_regulator_enable_time(struct regulator_dev *dev)
-{
-        struct gpio_regulator_data *data = rdev_get_drvdata(dev);
-
-        return data->startup_delay;
-}
-
 static int gpio_regulator_get_value(struct regulator_dev *dev)
 {
         struct gpio_regulator_data *data = rdev_get_drvdata(dev);
@@ -153,20 +110,12 @@ static int gpio_regulator_set_current_limit(struct regulator_dev *dev,
 }
 
 static struct regulator_ops gpio_regulator_voltage_ops = {
-        .is_enabled = gpio_regulator_is_enabled,
-        .enable = gpio_regulator_enable,
-        .disable = gpio_regulator_disable,
-        .enable_time = gpio_regulator_enable_time,
         .get_voltage = gpio_regulator_get_value,
         .set_voltage = gpio_regulator_set_voltage,
         .list_voltage = gpio_regulator_list_voltage,
 };
 
 static struct regulator_ops gpio_regulator_current_ops = {
-        .is_enabled = gpio_regulator_is_enabled,
-        .enable = gpio_regulator_enable,
-        .disable = gpio_regulator_disable,
-        .enable_time = gpio_regulator_enable_time,
         .get_current_limit = gpio_regulator_get_value,
         .set_current_limit = gpio_regulator_set_current_limit,
 };
@@ -213,6 +162,7 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
         drvdata->nr_states = config->nr_states;
 
         drvdata->desc.owner = THIS_MODULE;
+        drvdata->desc.enable_time = config->startup_delay;
 
         /* handle regulator type*/
         switch (config->type) {
@@ -232,52 +182,12 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
                 break;
         }
 
-        drvdata->enable_gpio = config->enable_gpio;
-        drvdata->startup_delay = config->startup_delay;
-
-        if (gpio_is_valid(config->enable_gpio)) {
-                drvdata->enable_high = config->enable_high;
-
-                ret = gpio_request(config->enable_gpio, config->supply_name);
-                if (ret) {
-                        dev_err(&pdev->dev,
-                           "Could not obtain regulator enable GPIO %d: %d\n",
-                                                config->enable_gpio, ret);
-                        goto err_memstate;
-                }
-
-                /* set output direction without changing state
-                 * to prevent glitch
-                 */
-                if (config->enabled_at_boot) {
-                        drvdata->is_enabled = true;
-                        ret = gpio_direction_output(config->enable_gpio,
-                                                    config->enable_high);
-                } else {
-                        drvdata->is_enabled = false;
-                        ret = gpio_direction_output(config->enable_gpio,
-                                                    !config->enable_high);
-                }
-
-                if (ret) {
-                        dev_err(&pdev->dev,
-                           "Could not configure regulator enable GPIO %d direction: %d\n",
-                                                config->enable_gpio, ret);
-                        goto err_enablegpio;
-                }
-        } else {
-                /* Regulator without GPIO control is considered
-                 * always enabled
-                 */
-                drvdata->is_enabled = true;
-        }
-
         drvdata->nr_gpios = config->nr_gpios;
         ret = gpio_request_array(drvdata->gpios, drvdata->nr_gpios);
         if (ret) {
                 dev_err(&pdev->dev,
                    "Could not obtain regulator setting GPIOs: %d\n", ret);
-                goto err_enablegpio;
+                goto err_memstate;
         }
 
         /* build initial state from gpio init data. */
@@ -292,6 +202,21 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
         cfg.init_data = config->init_data;
         cfg.driver_data = drvdata;
 
+        if (config->enable_gpio >= 0)
+                cfg.ena_gpio = config->enable_gpio;
+        cfg.ena_gpio_invert = !config->enable_high;
+        if (config->enabled_at_boot) {
+                if (config->enable_high)
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+                else
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
+        } else {
+                if (config->enable_high)
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
+                else
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+        }
+
         drvdata->dev = regulator_register(&drvdata->desc, &cfg);
         if (IS_ERR(drvdata->dev)) {
                 ret = PTR_ERR(drvdata->dev);
@@ -305,9 +230,6 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
 
 err_stategpio:
         gpio_free_array(drvdata->gpios, drvdata->nr_gpios);
-err_enablegpio:
-        if (gpio_is_valid(config->enable_gpio))
-                gpio_free(config->enable_gpio);
 err_memstate:
         kfree(drvdata->states);
 err_memgpio:
@@ -329,9 +251,6 @@ static int __devexit gpio_regulator_remove(struct platform_device *pdev)
         kfree(drvdata->states);
         kfree(drvdata->gpios);
 
-        if (gpio_is_valid(drvdata->enable_gpio))
-                gpio_free(drvdata->enable_gpio);
-
         kfree(drvdata->desc.name);
 
         return 0;
diff --git a/drivers/regulator/isl6271a-regulator.c b/drivers/regulator/isl6271a-regulator.c
index 56d273f25603..1d145a07ada9 100644
--- a/drivers/regulator/isl6271a-regulator.c
+++ b/drivers/regulator/isl6271a-regulator.c
@@ -75,19 +75,12 @@ static struct regulator_ops isl_core_ops = {
 
 static int isl6271a_get_fixed_voltage(struct regulator_dev *dev)
 {
-        int id = rdev_get_id(dev);
-        return (id == 1) ? 1100000 : 1300000;
-}
-
-static int isl6271a_list_fixed_voltage(struct regulator_dev *dev, unsigned selector)
-{
-        int id = rdev_get_id(dev);
-        return (id == 1) ? 1100000 : 1300000;
+        return dev->desc->min_uV;
 }
 
 static struct regulator_ops isl_fixed_ops = {
         .get_voltage    = isl6271a_get_fixed_voltage,
-        .list_voltage   = isl6271a_list_fixed_voltage,
+        .list_voltage   = regulator_list_voltage_linear,
 };
 
 static const struct regulator_desc isl_rd[] = {
@@ -107,6 +100,7 @@ static const struct regulator_desc isl_rd[] = {
                 .ops            = &isl_fixed_ops,
                 .type           = REGULATOR_VOLTAGE,
                 .owner          = THIS_MODULE,
+                .min_uV         = 1100000,
         }, {
                 .name           = "LDO2",
                 .id             = 2,
@@ -114,6 +108,7 @@ static const struct regulator_desc isl_rd[] = {
                 .ops            = &isl_fixed_ops,
                 .type           = REGULATOR_VOLTAGE,
                 .owner          = THIS_MODULE,
+                .min_uV         = 1300000,
         },
 };
 
diff --git a/drivers/regulator/lp3971.c b/drivers/regulator/lp3971.c
index 981bea9cb9d7..7c6e3b8ff484 100644
--- a/drivers/regulator/lp3971.c
+++ b/drivers/regulator/lp3971.c
@@ -65,11 +65,11 @@ static const int buck_base_addr[] = {
 #define LP3971_BUCK_TARGET_VOL1_REG(x) (buck_base_addr[x])
 #define LP3971_BUCK_TARGET_VOL2_REG(x) (buck_base_addr[x]+1)
 
-static const int buck_voltage_map[] = {
-           0,  800,  850,  900,  950, 1000, 1050, 1100,
-        1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500,
-        1550, 1600, 1650, 1700, 1800, 1900, 2500, 2800,
-        3000, 3300,
+static const unsigned int buck_voltage_map[] = {
+              0,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
+        1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
+        1550000, 1600000, 1650000, 1700000, 1800000, 1900000, 2500000, 2800000,
+        3000000, 3300000,
 };
 
 #define BUCK_TARGET_VOL_MASK 0x3f
@@ -98,39 +98,19 @@ static const int buck_voltage_map[] = {
 #define LDO_VOL_CONTR_SHIFT(x) ((x & 1) << 2)
 #define LDO_VOL_CONTR_MASK 0x0f
 
-static const int ldo45_voltage_map[] = {
-        1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350,
-        1400, 1500, 1800, 1900, 2500, 2800, 3000, 3300,
+static const unsigned int ldo45_voltage_map[] = {
+        1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000, 1350000,
+        1400000, 1500000, 1800000, 1900000, 2500000, 2800000, 3000000, 3300000,
 };
 
-static const int ldo123_voltage_map[] = {
-        1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
-        2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300,
+static const unsigned int ldo123_voltage_map[] = {
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2900000, 3000000, 3100000, 3200000, 3300000,
 };
 
-static const int *ldo_voltage_map[] = {
-        ldo123_voltage_map, /* LDO1 */
-        ldo123_voltage_map, /* LDO2 */
-        ldo123_voltage_map, /* LDO3 */
-        ldo45_voltage_map, /* LDO4 */
-        ldo45_voltage_map, /* LDO5 */
-};
-
-#define LDO_VOL_VALUE_MAP(x) (ldo_voltage_map[(x - LP3971_LDO1)])
-
 #define LDO_VOL_MIN_IDX 0x00
 #define LDO_VOL_MAX_IDX 0x0f
 
-static int lp3971_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
-{
-        int ldo = rdev_get_id(dev) - LP3971_LDO1;
-
-        if (index > LDO_VOL_MAX_IDX)
-                return -EINVAL;
-
-        return 1000 * LDO_VOL_VALUE_MAP(ldo)[index];
-}
-
 static int lp3971_ldo_is_enabled(struct regulator_dev *dev)
 {
         struct lp3971 *lp3971 = rdev_get_drvdata(dev);
@@ -169,7 +149,7 @@ static int lp3971_ldo_get_voltage(struct regulator_dev *dev)
         reg = lp3971_reg_read(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo));
         val = (reg >> LDO_VOL_CONTR_SHIFT(ldo)) & LDO_VOL_CONTR_MASK;
 
-        return 1000 * LDO_VOL_VALUE_MAP(ldo)[val];
+        return dev->desc->volt_table[val];
 }
 
 static int lp3971_ldo_set_voltage_sel(struct regulator_dev *dev,
@@ -184,7 +164,7 @@ static int lp3971_ldo_set_voltage_sel(struct regulator_dev *dev,
 }
 
 static struct regulator_ops lp3971_ldo_ops = {
-        .list_voltage = lp3971_ldo_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .is_enabled = lp3971_ldo_is_enabled,
         .enable = lp3971_ldo_enable,
         .disable = lp3971_ldo_disable,
@@ -192,14 +172,6 @@ static struct regulator_ops lp3971_ldo_ops = {
         .set_voltage_sel = lp3971_ldo_set_voltage_sel,
 };
 
-static int lp3971_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
-{
-        if (index < BUCK_TARGET_VOL_MIN_IDX || index > BUCK_TARGET_VOL_MAX_IDX)
-                return -EINVAL;
-
-        return 1000 * buck_voltage_map[index];
-}
-
 static int lp3971_dcdc_is_enabled(struct regulator_dev *dev)
 {
         struct lp3971 *lp3971 = rdev_get_drvdata(dev);
@@ -240,7 +212,7 @@ static int lp3971_dcdc_get_voltage(struct regulator_dev *dev)
         reg &= BUCK_TARGET_VOL_MASK;
 
         if (reg <= BUCK_TARGET_VOL_MAX_IDX)
-                val = 1000 * buck_voltage_map[reg];
+                val = buck_voltage_map[reg];
         else {
                 val = 0;
                 dev_warn(&dev->dev, "chip reported incorrect voltage value.\n");
@@ -273,7 +245,7 @@ static int lp3971_dcdc_set_voltage_sel(struct regulator_dev *dev,
 }
 
 static struct regulator_ops lp3971_dcdc_ops = {
-        .list_voltage = lp3971_dcdc_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .is_enabled = lp3971_dcdc_is_enabled,
         .enable = lp3971_dcdc_enable,
         .disable = lp3971_dcdc_disable,
@@ -287,6 +259,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO1,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo123_voltage_map),
+                .volt_table = ldo123_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -295,6 +268,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO2,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo123_voltage_map),
+                .volt_table = ldo123_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -303,6 +277,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO3,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo123_voltage_map),
+                .volt_table = ldo123_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -311,6 +286,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO4,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo45_voltage_map),
+                .volt_table = ldo45_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -319,6 +295,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO5,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo45_voltage_map),
+                .volt_table = ldo45_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -327,6 +304,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_DCDC1,
                 .ops = &lp3971_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
+                .volt_table = buck_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -335,6 +313,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_DCDC2,
                 .ops = &lp3971_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
+                .volt_table = buck_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -343,6 +322,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_DCDC3,
                 .ops = &lp3971_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
+                .volt_table = buck_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
diff --git a/drivers/regulator/lp3972.c b/drivers/regulator/lp3972.c
index de073df7d344..3cdc755d9b22 100644
--- a/drivers/regulator/lp3972.c
+++ b/drivers/regulator/lp3972.c
@@ -74,54 +74,40 @@ struct lp3972 {
 #define LP3972_OVER2_LDO4_EN    BIT(4)
 #define LP3972_OVER1_S_EN       BIT(2)
 
-static const int ldo1_voltage_map[] = {
-        1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
-        1900, 1925, 1950, 1975, 2000,
+static const unsigned int ldo1_voltage_map[] = {
+        1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
+        1900000, 1925000, 1950000, 1975000, 2000000,
 };
 
-static const int ldo23_voltage_map[] = {
-        1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
-        2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300,
+static const unsigned int ldo23_voltage_map[] = {
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2900000, 3000000, 3100000, 3200000, 3300000,
 };
 
-static const int ldo4_voltage_map[] = {
-        1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350,
-        1400, 1500, 1800, 1900, 2500, 2800, 3000, 3300,
+static const unsigned int ldo4_voltage_map[] = {
+        1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000, 1350000,
+        1400000, 1500000, 1800000, 1900000, 2500000, 2800000, 3000000, 3300000,
 };
 
-static const int ldo5_voltage_map[] = {
-           0,    0,    0,    0,    0,  850,  875,  900,
-         925,  950,  975, 1000, 1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
+static const unsigned int ldo5_voltage_map[] = {
+              0,       0,       0,       0,       0,  850000,  875000,  900000,
+         925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
+        1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
+        1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
 };
 
-static const int buck1_voltage_map[] = {
-         725,  750,  775,  800,  825,  850,  875,  900,
-         925,  950,  975, 1000, 1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
+static const unsigned int buck1_voltage_map[] = {
+         725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
+         925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
+        1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
+        1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
 };
 
-static const int buck23_voltage_map[] = {
-           0,  800,  850,  900,  950, 1000, 1050, 1100,
-        1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500,
-        1550, 1600, 1650, 1700, 1800, 1900, 2500, 2800,
-        3000, 3300,
-};
-
-static const int *ldo_voltage_map[] = {
-        ldo1_voltage_map,
-        ldo23_voltage_map,
-        ldo23_voltage_map,
-        ldo4_voltage_map,
-        ldo5_voltage_map,
-};
-
-static const int *buck_voltage_map[] = {
-        buck1_voltage_map,
-        buck23_voltage_map,
-        buck23_voltage_map,
+static const unsigned int buck23_voltage_map[] = {
+              0,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
+        1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
+        1550000, 1600000, 1650000, 1700000, 1800000, 1900000, 2500000, 2800000,
+        3000000, 3300000,
 };
 
 static const int ldo_output_enable_mask[] = {
@@ -160,7 +146,6 @@ static const int buck_base_addr[] = {
         LP3972_B3TV_REG,
 };
 
-#define LP3972_LDO_VOL_VALUE_MAP(x) (ldo_voltage_map[x])
 #define LP3972_LDO_OUTPUT_ENABLE_MASK(x) (ldo_output_enable_mask[x])
 #define LP3972_LDO_OUTPUT_ENABLE_REG(x) (ldo_output_enable_addr[x])
 
@@ -177,7 +162,6 @@ static const int buck_base_addr[] = {
 #define LP3972_LDO_VOL_MIN_IDX(x) (((x) == 4) ? 0x05 : 0x00)
 #define LP3972_LDO_VOL_MAX_IDX(x) ((x) ? (((x) == 4) ? 0x1f : 0x0f) : 0x0c)
 
-#define LP3972_BUCK_VOL_VALUE_MAP(x) (buck_voltage_map[x])
 #define LP3972_BUCK_VOL_ENABLE_REG(x) (buck_vol_enable_addr[x])
 #define LP3972_BUCK_VOL1_REG(x) (buck_base_addr[x])
 #define LP3972_BUCK_VOL_MASK 0x1f
@@ -242,17 +226,6 @@ static int lp3972_set_bits(struct lp3972 *lp3972, u8 reg, u16 mask, u16 val)
         return ret;
 }
 
-static int lp3972_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
-{
-        int ldo = rdev_get_id(dev) - LP3972_LDO1;
-
-        if (index < LP3972_LDO_VOL_MIN_IDX(ldo) ||
-            index > LP3972_LDO_VOL_MAX_IDX(ldo))
-                return -EINVAL;
-
-        return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[index];
-}
-
 static int lp3972_ldo_is_enabled(struct regulator_dev *dev)
 {
         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
@@ -294,7 +267,7 @@ static int lp3972_ldo_get_voltage(struct regulator_dev *dev)
         reg = lp3972_reg_read(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo));
         val = (reg >> LP3972_LDO_VOL_CONTR_SHIFT(ldo)) & mask;
 
-        return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[val];
+        return dev->desc->volt_table[val];
 }
 
 static int lp3972_ldo_set_voltage_sel(struct regulator_dev *dev,
@@ -337,7 +310,7 @@ static int lp3972_ldo_set_voltage_sel(struct regulator_dev *dev,
 }
 
 static struct regulator_ops lp3972_ldo_ops = {
-        .list_voltage = lp3972_ldo_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .is_enabled = lp3972_ldo_is_enabled,
         .enable = lp3972_ldo_enable,
         .disable = lp3972_ldo_disable,
@@ -345,17 +318,6 @@ static struct regulator_ops lp3972_ldo_ops = {
         .set_voltage_sel = lp3972_ldo_set_voltage_sel,
 };
 
-static int lp3972_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
-{
-        int buck = rdev_get_id(dev) - LP3972_DCDC1;
-
-        if (index < LP3972_BUCK_VOL_MIN_IDX(buck) ||
-            index > LP3972_BUCK_VOL_MAX_IDX(buck))
-                return -EINVAL;
-
-        return 1000 * buck_voltage_map[buck][index];
-}
-
 static int lp3972_dcdc_is_enabled(struct regulator_dev *dev)
 {
         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
@@ -401,7 +363,7 @@ static int lp3972_dcdc_get_voltage(struct regulator_dev *dev)
         reg = lp3972_reg_read(lp3972, LP3972_BUCK_VOL1_REG(buck));
         reg &= LP3972_BUCK_VOL_MASK;
         if (reg <= LP3972_BUCK_VOL_MAX_IDX(buck))
-                val = 1000 * buck_voltage_map[buck][reg];
+                val = dev->desc->volt_table[reg];
         else {
                 val = 0;
                 dev_warn(&dev->dev, "chip reported incorrect voltage value."
@@ -436,7 +398,7 @@ static int lp3972_dcdc_set_voltage_sel(struct regulator_dev *dev,
 }
 
 static struct regulator_ops lp3972_dcdc_ops = {
-        .list_voltage = lp3972_dcdc_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .is_enabled = lp3972_dcdc_is_enabled,
         .enable = lp3972_dcdc_enable,
         .disable = lp3972_dcdc_disable,
@@ -450,6 +412,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO1,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo1_voltage_map),
+                .volt_table = ldo1_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -458,6 +421,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO2,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
+                .volt_table = ldo23_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -466,6 +430,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO3,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
+                .volt_table = ldo23_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -474,6 +439,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO4,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo4_voltage_map),
+                .volt_table = ldo4_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -482,6 +448,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO5,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo5_voltage_map),
+                .volt_table = ldo5_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -490,6 +457,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_DCDC1,
                 .ops = &lp3972_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck1_voltage_map),
+                .volt_table = buck1_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -498,6 +466,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_DCDC2,
                 .ops = &lp3972_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
+                .volt_table = buck23_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -506,6 +475,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_DCDC3,
                 .ops = &lp3972_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
+                .volt_table = buck23_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
diff --git a/drivers/regulator/lp872x.c b/drivers/regulator/lp872x.c
new file mode 100644
index 000000000000..212c38eaba70
--- /dev/null
+++ b/drivers/regulator/lp872x.c
@@ -0,0 +1,943 @@
+/*
+ * Copyright 2012 Texas Instruments
+ *
+ * Author: Milo(Woogyom) Kim <milo.kim@ti.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/slab.h>
+#include <linux/i2c.h>
+#include <linux/regmap.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/regulator/lp872x.h>
+#include <linux/regulator/driver.h>
+#include <linux/platform_device.h>
+
+/* Registers : LP8720/8725 shared */
+#define LP872X_GENERAL_CFG              0x00
+#define LP872X_LDO1_VOUT                0x01
+#define LP872X_LDO2_VOUT                0x02
+#define LP872X_LDO3_VOUT                0x03
+#define LP872X_LDO4_VOUT                0x04
+#define LP872X_LDO5_VOUT                0x05
+
+/* Registers : LP8720 */
+#define LP8720_BUCK_VOUT1               0x06
+#define LP8720_BUCK_VOUT2               0x07
+#define LP8720_ENABLE                   0x08
+
+/* Registers : LP8725 */
+#define LP8725_LILO1_VOUT               0x06
+#define LP8725_LILO2_VOUT               0x07
+#define LP8725_BUCK1_VOUT1              0x08
+#define LP8725_BUCK1_VOUT2              0x09
+#define LP8725_BUCK2_VOUT1              0x0A
+#define LP8725_BUCK2_VOUT2              0x0B
+#define LP8725_BUCK_CTRL                0x0C
+#define LP8725_LDO_CTRL                 0x0D
+
+/* Mask/shift : LP8720/LP8725 shared */
+#define LP872X_VOUT_M                   0x1F
+#define LP872X_START_DELAY_M            0xE0
+#define LP872X_START_DELAY_S            5
+#define LP872X_EN_LDO1_M                BIT(0)
+#define LP872X_EN_LDO2_M                BIT(1)
+#define LP872X_EN_LDO3_M                BIT(2)
+#define LP872X_EN_LDO4_M                BIT(3)
+#define LP872X_EN_LDO5_M                BIT(4)
+
+/* Mask/shift : LP8720 */
+#define LP8720_TIMESTEP_S               0               /* Addr 00h */
+#define LP8720_TIMESTEP_M               BIT(0)
+#define LP8720_EXT_DVS_M                BIT(2)
+#define LP8720_BUCK_FPWM_S              5               /* Addr 07h */
+#define LP8720_BUCK_FPWM_M              BIT(5)
+#define LP8720_EN_BUCK_M                BIT(5)          /* Addr 08h */
+#define LP8720_DVS_SEL_M                BIT(7)
+
+/* Mask/shift : LP8725 */
+#define LP8725_TIMESTEP_M               0xC0            /* Addr 00h */
+#define LP8725_TIMESTEP_S               6
+#define LP8725_BUCK1_EN_M               BIT(0)
+#define LP8725_DVS1_M                   BIT(2)
+#define LP8725_DVS2_M                   BIT(3)
+#define LP8725_BUCK2_EN_M               BIT(4)
+#define LP8725_BUCK_CL_M                0xC0            /* Addr 09h, 0Bh */
+#define LP8725_BUCK_CL_S                6
+#define LP8725_BUCK1_FPWM_S             1               /* Addr 0Ch */
+#define LP8725_BUCK1_FPWM_M             BIT(1)
+#define LP8725_BUCK2_FPWM_S             5
+#define LP8725_BUCK2_FPWM_M             BIT(5)
+#define LP8725_EN_LILO1_M               BIT(5)          /* Addr 0Dh */
+#define LP8725_EN_LILO2_M               BIT(6)
+
+/* PWM mode */
+#define LP872X_FORCE_PWM                1
+#define LP872X_AUTO_PWM                 0
+
+#define LP8720_NUM_REGULATORS           6
+#define LP8725_NUM_REGULATORS           9
+#define EXTERN_DVS_USED                 0
+#define MAX_DELAY                       6
+
+/* dump registers in regmap-debugfs */
+#define MAX_REGISTERS                   0x0F
+
+enum lp872x_id {
+        LP8720,
+        LP8725,
+};
+
+struct lp872x {
+        struct regmap *regmap;
+        struct device *dev;
+        enum lp872x_id chipid;
+        struct lp872x_platform_data *pdata;
+        struct regulator_dev **regulators;
+        int num_regulators;
+        enum lp872x_dvs_state dvs_pin;
+        int dvs_gpio;
+};
+
+/* LP8720/LP8725 shared voltage table for LDOs */
+static const unsigned int lp872x_ldo_vtbl[] = {
+        1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000, 1550000,
+        1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000, 2000000,
+        2100000, 2200000, 2300000, 2400000, 2500000, 2600000, 2650000, 2700000,
+        2750000, 2800000, 2850000, 2900000, 2950000, 3000000, 3100000, 3300000,
+};
+
+/* LP8720 LDO4 voltage table */
+static const unsigned int lp8720_ldo4_vtbl[] = {
+         800000,  850000,  900000, 1000000, 1100000, 1200000, 1250000, 1300000,
+        1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
+        1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
+        2400000, 2500000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000,
+};
+
+/* LP8725 LILO(Low Input Low Output) voltage table */
+static const unsigned int lp8725_lilo_vtbl[] = {
+         800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
+        1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000,
+};
+
+/* LP8720 BUCK voltage table */
+#define EXT_R           0       /* external resistor divider */
+static const unsigned int lp8720_buck_vtbl[] = {
+          EXT_R,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
+        1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
+        1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
+        1950000, 2000000, 2050000, 2100000, 2150000, 2200000, 2250000, 2300000,
+};
+
+/* LP8725 BUCK voltage table */
+static const unsigned int lp8725_buck_vtbl[] = {
+         800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
+        1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
+        1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
+        2400000, 2500000, 2600000, 2700000, 2800000, 2850000, 2900000, 3000000,
+};
+
+/* LP8725 BUCK current limit */
+static const unsigned int lp8725_buck_uA[] = {
+        460000, 780000, 1050000, 1370000,
+};
+
+static int lp872x_read_byte(struct lp872x *lp, u8 addr, u8 *data)
+{
+        int ret;
+        unsigned int val;
+
+        ret = regmap_read(lp->regmap, addr, &val);
+        if (ret < 0) {
+                dev_err(lp->dev, "failed to read 0x%.2x\n", addr);
+                return ret;
+        }
+
+        *data = (u8)val;
+        return 0;
+}
+
+static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
+{
+        return regmap_write(lp->regmap, addr, data);
+}
+
+static inline int lp872x_update_bits(struct lp872x *lp, u8 addr,
+                                unsigned int mask, u8 data)
+{
+        return regmap_update_bits(lp->regmap, addr, mask, data);
+}
+
+static int _rdev_to_offset(struct regulator_dev *rdev)
+{
+        enum lp872x_regulator_id id = rdev_get_id(rdev);
+
+        switch (id) {
+        case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
+                return id;
+        case LP8725_ID_LDO1 ... LP8725_ID_BUCK2:
+                return id - LP8725_ID_BASE;
+        default:
+                return -EINVAL;
+        }
+}
+
+static int lp872x_get_timestep_usec(struct lp872x *lp)
+{
+        enum lp872x_id chip = lp->chipid;
+        u8 val, mask, shift;
+        int *time_usec, size, ret;
+        int lp8720_time_usec[] = { 25, 50 };
+        int lp8725_time_usec[] = { 32, 64, 128, 256 };
+
+        switch (chip) {
+        case LP8720:
+                mask = LP8720_TIMESTEP_M;
+                shift = LP8720_TIMESTEP_S;
+                time_usec = &lp8720_time_usec[0];
+                size = ARRAY_SIZE(lp8720_time_usec);
+                break;
+        case LP8725:
+                mask = LP8725_TIMESTEP_M;
+                shift = LP8725_TIMESTEP_S;
+                time_usec = &lp8725_time_usec[0];
+                size = ARRAY_SIZE(lp8725_time_usec);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
+        if (ret)
+                return -EINVAL;
+
+        val = (val & mask) >> shift;
+        if (val >= size)
+                return -EINVAL;
+
+        return *(time_usec + val);
+}
+
+static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id regulator = rdev_get_id(rdev);
+        int time_step_us = lp872x_get_timestep_usec(lp);
+        int ret, offset;
+        u8 addr, val;
+
+        if (time_step_us < 0)
+                return -EINVAL;
+
+        switch (regulator) {
+        case LP8720_ID_LDO1 ... LP8720_ID_LDO5:
+        case LP8725_ID_LDO1 ... LP8725_ID_LILO2:
+                offset = _rdev_to_offset(rdev);
+                if (offset < 0)
+                        return -EINVAL;
+
+                addr = LP872X_LDO1_VOUT + offset;
+                break;
+        case LP8720_ID_BUCK:
+                addr = LP8720_BUCK_VOUT1;
+                break;
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK1_VOUT1;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK2_VOUT1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = lp872x_read_byte(lp, addr, &val);
+        if (ret)
+                return ret;
+
+        val = (val & LP872X_START_DELAY_M) >> LP872X_START_DELAY_S;
+
+        return val > MAX_DELAY ? 0 : val * time_step_us;
+}
+
+static void lp872x_set_dvs(struct lp872x *lp, int gpio)
+{
+        enum lp872x_dvs_sel dvs_sel = lp->pdata->dvs->vsel;
+        enum lp872x_dvs_state state;
+
+        state = dvs_sel == SEL_V1 ? DVS_HIGH : DVS_LOW;
+        gpio_set_value(gpio, state);
+        lp->dvs_pin = state;
+}
+
+static u8 lp872x_select_buck_vout_addr(struct lp872x *lp,
+                                enum lp872x_regulator_id buck)
+{
+        u8 val, addr;
+
+        if (lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val))
+                return 0;
+
+        switch (buck) {
+        case LP8720_ID_BUCK:
+                if (val & LP8720_EXT_DVS_M) {
+                        addr = (lp->dvs_pin == DVS_HIGH) ?
+                                LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
+                } else {
+                        if (lp872x_read_byte(lp, LP8720_ENABLE, &val))
+                                return 0;
+
+                        addr = val & LP8720_DVS_SEL_M ?
+                                LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
+                }
+                break;
+        case LP8725_ID_BUCK1:
+                if (val & LP8725_DVS1_M)
+                        addr = LP8725_BUCK1_VOUT1;
+                else
+                        addr = (lp->dvs_pin == DVS_HIGH) ?
+                                LP8725_BUCK1_VOUT1 : LP8725_BUCK1_VOUT2;
+                break;
+        case LP8725_ID_BUCK2:
+                addr =  val & LP8725_DVS2_M ?
+                        LP8725_BUCK2_VOUT1 : LP8725_BUCK2_VOUT2;
+                break;
+        default:
+                return 0;
+        }
+
+        return addr;
+}
+
+static bool lp872x_is_valid_buck_addr(u8 addr)
+{
+        switch (addr) {
+        case LP8720_BUCK_VOUT1:
+        case LP8720_BUCK_VOUT2:
+        case LP8725_BUCK1_VOUT1:
+        case LP8725_BUCK1_VOUT2:
+        case LP8725_BUCK2_VOUT1:
+        case LP8725_BUCK2_VOUT2:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static int lp872x_buck_set_voltage_sel(struct regulator_dev *rdev,
+                                        unsigned selector)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, mask = LP872X_VOUT_M;
+        struct lp872x_dvs *dvs = lp->pdata->dvs;
+
+        if (dvs && gpio_is_valid(dvs->gpio))
+                lp872x_set_dvs(lp, dvs->gpio);
+
+        addr = lp872x_select_buck_vout_addr(lp, buck);
+        if (!lp872x_is_valid_buck_addr(addr))
+                return -EINVAL;
+
+        return lp872x_update_bits(lp, addr, mask, selector);
+}
+
+static int lp872x_buck_get_voltage_sel(struct regulator_dev *rdev)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, val;
+        int ret;
+
+        addr = lp872x_select_buck_vout_addr(lp, buck);
+        if (!lp872x_is_valid_buck_addr(addr))
+                return -EINVAL;
+
+        ret = lp872x_read_byte(lp, addr, &val);
+        if (ret)
+                return ret;
+
+        return val & LP872X_VOUT_M;
+}
+
+static int lp8725_buck_set_current_limit(struct regulator_dev *rdev,
+                                        int min_uA, int max_uA)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        int i, max = ARRAY_SIZE(lp8725_buck_uA);
+        u8 addr, val;
+
+        switch (buck) {
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK1_VOUT2;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK2_VOUT2;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        for (i = 0 ; i < max ; i++)
+                if (lp8725_buck_uA[i] >= min_uA &&
+                        lp8725_buck_uA[i] <= max_uA)
+                        break;
+
+        if (i == max)
+                return -EINVAL;
+
+        val = i << LP8725_BUCK_CL_S;
+
+        return lp872x_update_bits(lp, addr, LP8725_BUCK_CL_M, val);
+}
+
+static int lp8725_buck_get_current_limit(struct regulator_dev *rdev)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, val;
+        int ret;
+
+        switch (buck) {
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK1_VOUT2;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK2_VOUT2;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = lp872x_read_byte(lp, addr, &val);
+        if (ret)
+                return ret;
+
+        val = (val & LP8725_BUCK_CL_M) >> LP8725_BUCK_CL_S;
+
+        return (val < ARRAY_SIZE(lp8725_buck_uA)) ?
+                        lp8725_buck_uA[val] : -EINVAL;
+}
+
+static int lp872x_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, mask, shift, val;
+
+        switch (buck) {
+        case LP8720_ID_BUCK:
+                addr = LP8720_BUCK_VOUT2;
+                mask = LP8720_BUCK_FPWM_M;
+                shift = LP8720_BUCK_FPWM_S;
+                break;
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK_CTRL;
+                mask = LP8725_BUCK1_FPWM_M;
+                shift = LP8725_BUCK1_FPWM_S;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK_CTRL;
+                mask = LP8725_BUCK2_FPWM_M;
+                shift = LP8725_BUCK2_FPWM_S;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (mode == REGULATOR_MODE_FAST)
+                val = LP872X_FORCE_PWM << shift;
+        else if (mode == REGULATOR_MODE_NORMAL)
+                val = LP872X_AUTO_PWM << shift;
+        else
+                return -EINVAL;
+
+        return lp872x_update_bits(lp, addr, mask, val);
+}
+
+static unsigned int lp872x_buck_get_mode(struct regulator_dev *rdev)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, mask, val;
+        int ret;
+
+        switch (buck) {
+        case LP8720_ID_BUCK:
+                addr = LP8720_BUCK_VOUT2;
+                mask = LP8720_BUCK_FPWM_M;
+                break;
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK_CTRL;
+                mask = LP8725_BUCK1_FPWM_M;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK_CTRL;
+                mask = LP8725_BUCK2_FPWM_M;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = lp872x_read_byte(lp, addr, &val);
+        if (ret)
+                return ret;
+
+        return val & mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
+}
+
+static struct regulator_ops lp872x_ldo_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp872x_regulator_enable_time,
+};
+
+static struct regulator_ops lp8720_buck_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = lp872x_buck_set_voltage_sel,
+        .get_voltage_sel = lp872x_buck_get_voltage_sel,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp872x_regulator_enable_time,
+        .set_mode = lp872x_buck_set_mode,
+        .get_mode = lp872x_buck_get_mode,
+};
+
+static struct regulator_ops lp8725_buck_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = lp872x_buck_set_voltage_sel,
+        .get_voltage_sel = lp872x_buck_get_voltage_sel,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp872x_regulator_enable_time,
+        .set_mode = lp872x_buck_set_mode,
+        .get_mode = lp872x_buck_get_mode,
+        .set_current_limit = lp8725_buck_set_current_limit,
+        .get_current_limit = lp8725_buck_get_current_limit,
+};
+
+static struct regulator_desc lp8720_regulator_desc[] = {
+        {
+                .name = "ldo1",
+                .id = LP8720_ID_LDO1,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO1_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO1_M,
+        },
+        {
+                .name = "ldo2",
+                .id = LP8720_ID_LDO2,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO2_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO2_M,
+        },
+        {
+                .name = "ldo3",
+                .id = LP8720_ID_LDO3,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO3_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO3_M,
+        },
+        {
+                .name = "ldo4",
+                .id = LP8720_ID_LDO4,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp8720_ldo4_vtbl),
+                .volt_table = lp8720_ldo4_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO4_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO4_M,
+        },
+        {
+                .name = "ldo5",
+                .id = LP8720_ID_LDO5,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO5_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO5_M,
+        },
+        {
+                .name = "buck",
+                .id = LP8720_ID_BUCK,
+                .ops = &lp8720_buck_ops,
+                .n_voltages = ARRAY_SIZE(lp8720_buck_vtbl),
+                .volt_table = lp8720_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP8720_EN_BUCK_M,
+        },
+};
+
+static struct regulator_desc lp8725_regulator_desc[] = {
+        {
+                .name = "ldo1",
+                .id = LP8725_ID_LDO1,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO1_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO1_M,
+        },
+        {
+                .name = "ldo2",
+                .id = LP8725_ID_LDO2,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO2_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO2_M,
+        },
+        {
+                .name = "ldo3",
+                .id = LP8725_ID_LDO3,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO3_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO3_M,
+        },
+        {
+                .name = "ldo4",
+                .id = LP8725_ID_LDO4,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO4_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO4_M,
+        },
+        {
+                .name = "ldo5",
+                .id = LP8725_ID_LDO5,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO5_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO5_M,
+        },
+        {
+                .name = "lilo1",
+                .id = LP8725_ID_LILO1,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
+                .volt_table = lp8725_lilo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8725_LILO1_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP8725_EN_LILO1_M,
+        },
+        {
+                .name = "lilo2",
+                .id = LP8725_ID_LILO2,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
+                .volt_table = lp8725_lilo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8725_LILO2_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP8725_EN_LILO2_M,
+        },
+        {
+                .name = "buck1",
+                .id = LP8725_ID_BUCK1,
+                .ops = &lp8725_buck_ops,
+                .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
+                .volt_table = lp8725_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP872X_GENERAL_CFG,
+                .enable_mask = LP8725_BUCK1_EN_M,
+        },
+        {
+                .name = "buck2",
+                .id = LP8725_ID_BUCK2,
+                .ops = &lp8725_buck_ops,
+                .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
+                .volt_table = lp8725_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP872X_GENERAL_CFG,
+                .enable_mask = LP8725_BUCK2_EN_M,
+        },
+};
+
+static int lp872x_check_dvs_validity(struct lp872x *lp)
+{
+        struct lp872x_dvs *dvs = lp->pdata->dvs;
+        u8 val = 0;
+        int ret;
+
+        ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
+        if (ret)
+                return ret;
+
+        ret = 0;
+        if (lp->chipid == LP8720) {
+                if (val & LP8720_EXT_DVS_M)
+                        ret = dvs ? 0 : -EINVAL;
+        } else {
+                if ((val & LP8725_DVS1_M) == EXTERN_DVS_USED)
+                        ret = dvs ? 0 : -EINVAL;
+        }
+
+        return ret;
+}
+
+static int lp872x_init_dvs(struct lp872x *lp)
+{
+        int ret, gpio;
+        struct lp872x_dvs *dvs = lp->pdata->dvs;
+        enum lp872x_dvs_state pinstate;
+
+        ret = lp872x_check_dvs_validity(lp);
+        if (ret) {
+                dev_warn(lp->dev, "invalid dvs data: %d\n", ret);
+                return ret;
+        }
+
+        gpio = dvs->gpio;
+        if (!gpio_is_valid(gpio)) {
+                dev_err(lp->dev, "invalid gpio: %d\n", gpio);
+                return -EINVAL;
+        }
+
+        pinstate = dvs->init_state;
+        ret = devm_gpio_request_one(lp->dev, gpio, pinstate, "LP872X DVS");
+        if (ret) {
+                dev_err(lp->dev, "gpio request err: %d\n", ret);
+                return ret;
+        }
+
+        lp->dvs_pin = pinstate;
+        lp->dvs_gpio = gpio;
+
+        return 0;
+}
+
+static int lp872x_config(struct lp872x *lp)
+{
+        struct lp872x_platform_data *pdata = lp->pdata;
+        int ret;
+
+        if (!pdata->update_config)
+                return 0;
+
+        ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
+        if (ret)
+                return ret;
+
+        return lp872x_init_dvs(lp);
+}
+
+static struct regulator_init_data
+*lp872x_find_regulator_init_data(int id, struct lp872x *lp)
+{
+        int i;
+
+        for (i = 0; i < lp->num_regulators; i++) {
+                if (lp->pdata->regulator_data[i].id == id)
+                        return lp->pdata->regulator_data[i].init_data;
+        }
+
+        return NULL;
+}
+
+static int lp872x_regulator_register(struct lp872x *lp)
+{
+        struct regulator_desc *desc;
+        struct regulator_config cfg = { };
+        struct regulator_dev *rdev;
+        int i, ret;
+
+        for (i = 0 ; i < lp->num_regulators ; i++) {
+                desc = (lp->chipid == LP8720) ? &lp8720_regulator_desc[i] :
+                                                &lp8725_regulator_desc[i];
+
+                cfg.dev = lp->dev;
+                cfg.init_data = lp872x_find_regulator_init_data(desc->id, lp);
+                cfg.driver_data = lp;
+                cfg.regmap = lp->regmap;
+
+                rdev = regulator_register(desc, &cfg);
+                if (IS_ERR(rdev)) {
+                        dev_err(lp->dev, "regulator register err");
+                        ret =  PTR_ERR(rdev);
+                        goto err;
+                }
+
+                *(lp->regulators + i) = rdev;
+        }
+
+        return 0;
+err:
+        while (--i >= 0) {
+                rdev = *(lp->regulators + i);
+                regulator_unregister(rdev);
+        }
+        return ret;
+}
+
+static void lp872x_regulator_unregister(struct lp872x *lp)
+{
+        struct regulator_dev *rdev;
+        int i;
+
+        for (i = 0 ; i < lp->num_regulators ; i++) {
+                rdev = *(lp->regulators + i);
+                regulator_unregister(rdev);
+        }
+}
+
+static const struct regmap_config lp872x_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = MAX_REGISTERS,
+};
+
+static int lp872x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
+{
+        struct lp872x *lp;
+        struct lp872x_platform_data *pdata = cl->dev.platform_data;
+        int ret, size, num_regulators;
+        const int lp872x_num_regulators[] = {
+                [LP8720] = LP8720_NUM_REGULATORS,
+                [LP8725] = LP8725_NUM_REGULATORS,
+        };
+
+        if (!pdata) {
+                dev_err(&cl->dev, "no platform data\n");
+                return -EINVAL;
+        }
+
+        lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);
+        if (!lp)
+                goto err_mem;
+
+        num_regulators = lp872x_num_regulators[id->driver_data];
+        size = sizeof(struct regulator_dev *) * num_regulators;
+
+        lp->regulators = devm_kzalloc(&cl->dev, size, GFP_KERNEL);
+        if (!lp->regulators)
+                goto err_mem;
+
+        lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);
+        if (IS_ERR(lp->regmap)) {
+                ret = PTR_ERR(lp->regmap);
+                dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
+                goto err_dev;
+        }
+
+        lp->dev = &cl->dev;
+        lp->pdata = pdata;
+        lp->chipid = id->driver_data;
+        lp->num_regulators = num_regulators;
+        i2c_set_clientdata(cl, lp);
+
+        ret = lp872x_config(lp);
+        if (ret)
+                goto err_dev;
+
+        return lp872x_regulator_register(lp);
+
+err_mem:
+        return -ENOMEM;
+err_dev:
+        return ret;
+}
+
+static int __devexit lp872x_remove(struct i2c_client *cl)
+{
+        struct lp872x *lp = i2c_get_clientdata(cl);
+
+        lp872x_regulator_unregister(lp);
+        return 0;
+}
+
+static const struct i2c_device_id lp872x_ids[] = {
+        {"lp8720", LP8720},
+        {"lp8725", LP8725},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, lp872x_ids);
+
+static struct i2c_driver lp872x_driver = {
+        .driver = {
+                .name = "lp872x",
+                .owner = THIS_MODULE,
+        },
+        .probe = lp872x_probe,
+        .remove = __devexit_p(lp872x_remove),
+        .id_table = lp872x_ids,
+};
+
+module_i2c_driver(lp872x_driver);
+
+MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
+MODULE_AUTHOR("Milo Kim");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/lp8788-buck.c b/drivers/regulator/lp8788-buck.c
new file mode 100644
index 000000000000..6356e821400f
--- /dev/null
+++ b/drivers/regulator/lp8788-buck.c
@@ -0,0 +1,629 @@
+/*
+ * TI LP8788 MFD - buck regulator driver
+ *
+ * Copyright 2012 Texas Instruments
+ *
+ * Author: Milo(Woogyom) Kim <milo.kim@ti.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/slab.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/mfd/lp8788.h>
+#include <linux/gpio.h>
+
+/* register address */
+#define LP8788_EN_BUCK                  0x0C
+#define LP8788_BUCK_DVS_SEL             0x1D
+#define LP8788_BUCK1_VOUT0              0x1E
+#define LP8788_BUCK1_VOUT1              0x1F
+#define LP8788_BUCK1_VOUT2              0x20
+#define LP8788_BUCK1_VOUT3              0x21
+#define LP8788_BUCK2_VOUT0              0x22
+#define LP8788_BUCK2_VOUT1              0x23
+#define LP8788_BUCK2_VOUT2              0x24
+#define LP8788_BUCK2_VOUT3              0x25
+#define LP8788_BUCK3_VOUT               0x26
+#define LP8788_BUCK4_VOUT               0x27
+#define LP8788_BUCK1_TIMESTEP           0x28
+#define LP8788_BUCK_PWM                 0x2D
+
+/* mask/shift bits */
+#define LP8788_EN_BUCK1_M               BIT(0)  /* Addr 0Ch */
+#define LP8788_EN_BUCK2_M               BIT(1)
+#define LP8788_EN_BUCK3_M               BIT(2)
+#define LP8788_EN_BUCK4_M               BIT(3)
+#define LP8788_BUCK1_DVS_SEL_M          0x04    /* Addr 1Dh */
+#define LP8788_BUCK1_DVS_M              0x03
+#define LP8788_BUCK1_DVS_S              0
+#define LP8788_BUCK2_DVS_SEL_M          0x40
+#define LP8788_BUCK2_DVS_M              0x30
+#define LP8788_BUCK2_DVS_S              4
+#define LP8788_BUCK1_DVS_I2C            BIT(2)
+#define LP8788_BUCK2_DVS_I2C            BIT(6)
+#define LP8788_BUCK1_DVS_PIN            (0 << 2)
+#define LP8788_BUCK2_DVS_PIN            (0 << 6)
+#define LP8788_VOUT_M                   0x1F    /* Addr 1Eh ~ 27h */
+#define LP8788_STARTUP_TIME_M           0xF8    /* Addr 28h ~ 2Bh */
+#define LP8788_STARTUP_TIME_S           3
+#define LP8788_FPWM_BUCK1_M             BIT(0)  /* Addr 2Dh */
+#define LP8788_FPWM_BUCK1_S             0
+#define LP8788_FPWM_BUCK2_M             BIT(1)
+#define LP8788_FPWM_BUCK2_S             1
+#define LP8788_FPWM_BUCK3_M             BIT(2)
+#define LP8788_FPWM_BUCK3_S             2
+#define LP8788_FPWM_BUCK4_M             BIT(3)
+#define LP8788_FPWM_BUCK4_S             3
+
+#define INVALID_ADDR                    0xFF
+#define LP8788_FORCE_PWM                1
+#define LP8788_AUTO_PWM                 0
+#define PIN_LOW                         0
+#define PIN_HIGH                        1
+#define ENABLE_TIME_USEC                32
+
+enum lp8788_dvs_state {
+        DVS_LOW  = GPIOF_OUT_INIT_LOW,
+        DVS_HIGH = GPIOF_OUT_INIT_HIGH,
+};
+
+enum lp8788_dvs_mode {
+        REGISTER,
+        EXTPIN,
+};
+
+enum lp8788_buck_id {
+        BUCK1,
+        BUCK2,
+        BUCK3,
+        BUCK4,
+};
+
+struct lp8788_pwm_map {
+        u8 mask;
+        u8 shift;
+};
+
+struct lp8788_buck {
+        struct lp8788 *lp;
+        struct regulator_dev *regulator;
+        struct lp8788_pwm_map *pmap;
+        void *dvs;
+};
+
+/* BUCK 1 ~ 4 voltage table */
+static const int lp8788_buck_vtbl[] = {
+         500000,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
+        1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
+        1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
+        1950000, 2000000,
+};
+
+/* buck pwm mode selection : used for set/get_mode in regulator ops
+ * @forced pwm : fast mode
+ * @auto pwm   : normal mode
+ */
+static struct lp8788_pwm_map buck_pmap[] = {
+        [BUCK1] = {
+                .mask = LP8788_FPWM_BUCK1_M,
+                .shift = LP8788_FPWM_BUCK1_S,
+        },
+        [BUCK2] = {
+                .mask = LP8788_FPWM_BUCK2_M,
+                .shift = LP8788_FPWM_BUCK2_S,
+        },
+        [BUCK3] = {
+                .mask = LP8788_FPWM_BUCK3_M,
+                .shift = LP8788_FPWM_BUCK3_S,
+        },
+        [BUCK4] = {
+                .mask = LP8788_FPWM_BUCK4_M,
+                .shift = LP8788_FPWM_BUCK4_S,
+        },
+};
+
+static const u8 buck1_vout_addr[] = {
+        LP8788_BUCK1_VOUT0, LP8788_BUCK1_VOUT1,
+        LP8788_BUCK1_VOUT2, LP8788_BUCK1_VOUT3,
+};
+
+static const u8 buck2_vout_addr[] = {
+        LP8788_BUCK2_VOUT0, LP8788_BUCK2_VOUT1,
+        LP8788_BUCK2_VOUT2, LP8788_BUCK2_VOUT3,
+};
+
+static void lp8788_buck1_set_dvs(struct lp8788_buck *buck)
+{
+        struct lp8788_buck1_dvs *dvs = (struct lp8788_buck1_dvs *)buck->dvs;
+        enum lp8788_dvs_state pinstate;
+
+        if (!dvs)
+                return;
+
+        pinstate = dvs->vsel == DVS_SEL_V0 ? DVS_LOW : DVS_HIGH;
+        if (gpio_is_valid(dvs->gpio))
+                gpio_set_value(dvs->gpio, pinstate);
+}
+
+static void lp8788_buck2_set_dvs(struct lp8788_buck *buck)
+{
+        struct lp8788_buck2_dvs *dvs = (struct lp8788_buck2_dvs *)buck->dvs;
+        enum lp8788_dvs_state pin1, pin2;
+
+        if (!dvs)
+                return;
+
+        switch (dvs->vsel) {
+        case DVS_SEL_V0:
+                pin1 = DVS_LOW;
+                pin2 = DVS_LOW;
+                break;
+        case DVS_SEL_V1:
+                pin1 = DVS_HIGH;
+                pin2 = DVS_LOW;
+                break;
+        case DVS_SEL_V2:
+                pin1 = DVS_LOW;
+                pin2 = DVS_HIGH;
+                break;
+        case DVS_SEL_V3:
+                pin1 = DVS_HIGH;
+                pin2 = DVS_HIGH;
+                break;
+        default:
+                return;
+        }
+
+        if (gpio_is_valid(dvs->gpio[0]))
+                gpio_set_value(dvs->gpio[0], pin1);
+
+        if (gpio_is_valid(dvs->gpio[1]))
+                gpio_set_value(dvs->gpio[1], pin2);
+}
+
+static void lp8788_set_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
+{
+        switch (id) {
+        case BUCK1:
+                lp8788_buck1_set_dvs(buck);
+                break;
+        case BUCK2:
+                lp8788_buck2_set_dvs(buck);
+                break;
+        default:
+                break;
+        }
+}
+
+static enum lp8788_dvs_mode
+lp8788_get_buck_dvs_ctrl_mode(struct lp8788_buck *buck, enum lp8788_buck_id id)
+{
+        u8 val, mask;
+
+        switch (id) {
+        case BUCK1:
+                mask = LP8788_BUCK1_DVS_SEL_M;
+                break;
+        case BUCK2:
+                mask = LP8788_BUCK2_DVS_SEL_M;
+                break;
+        default:
+                return REGISTER;
+        }
+
+        lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
+
+        return val & mask ? REGISTER : EXTPIN;
+}
+
+static bool lp8788_is_valid_buck_addr(u8 addr)
+{
+        switch (addr) {
+        case LP8788_BUCK1_VOUT0:
+        case LP8788_BUCK1_VOUT1:
+        case LP8788_BUCK1_VOUT2:
+        case LP8788_BUCK1_VOUT3:
+        case LP8788_BUCK2_VOUT0:
+        case LP8788_BUCK2_VOUT1:
+        case LP8788_BUCK2_VOUT2:
+        case LP8788_BUCK2_VOUT3:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static u8 lp8788_select_buck_vout_addr(struct lp8788_buck *buck,
+                                        enum lp8788_buck_id id)
+{
+        enum lp8788_dvs_mode mode = lp8788_get_buck_dvs_ctrl_mode(buck, id);
+        struct lp8788_buck1_dvs *b1_dvs;
+        struct lp8788_buck2_dvs *b2_dvs;
+        u8 val, idx, addr;
+        int pin1, pin2;
+
+        switch (id) {
+        case BUCK1:
+                if (mode == EXTPIN) {
+                        b1_dvs = (struct lp8788_buck1_dvs *)buck->dvs;
+                        if (!b1_dvs)
+                                goto err;
+
+                        idx = gpio_get_value(b1_dvs->gpio) ? 1 : 0;
+                } else {
+                        lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
+                        idx = (val & LP8788_BUCK1_DVS_M) >> LP8788_BUCK1_DVS_S;
+                }
+                addr = buck1_vout_addr[idx];
+                break;
+        case BUCK2:
+                if (mode == EXTPIN) {
+                        b2_dvs = (struct lp8788_buck2_dvs *)buck->dvs;
+                        if (!b2_dvs)
+                                goto err;
+
+                        pin1 = gpio_get_value(b2_dvs->gpio[0]);
+                        pin2 = gpio_get_value(b2_dvs->gpio[1]);
+
+                        if (pin1 == PIN_LOW && pin2 == PIN_LOW)
+                                idx = 0;
+                        else if (pin1 == PIN_LOW && pin2 == PIN_HIGH)
+                                idx = 2;
+                        else if (pin1 == PIN_HIGH && pin2 == PIN_LOW)
+                                idx = 1;
+                        else
+                                idx = 3;
+                } else {
+                        lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
+                        idx = (val & LP8788_BUCK2_DVS_M) >> LP8788_BUCK2_DVS_S;
+                }
+                addr = buck2_vout_addr[idx];
+                break;
+        default:
+                goto err;
+        }
+
+        return addr;
+err:
+        return INVALID_ADDR;
+}
+
+static int lp8788_buck12_set_voltage_sel(struct regulator_dev *rdev,
+                                        unsigned selector)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        enum lp8788_buck_id id = rdev_get_id(rdev);
+        u8 addr;
+
+        if (buck->dvs)
+                lp8788_set_dvs(buck, id);
+
+        addr = lp8788_select_buck_vout_addr(buck, id);
+        if (!lp8788_is_valid_buck_addr(addr))
+                return -EINVAL;
+
+        return lp8788_update_bits(buck->lp, addr, LP8788_VOUT_M, selector);
+}
+
+static int lp8788_buck12_get_voltage_sel(struct regulator_dev *rdev)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        enum lp8788_buck_id id = rdev_get_id(rdev);
+        int ret;
+        u8 val, addr;
+
+        addr = lp8788_select_buck_vout_addr(buck, id);
+        if (!lp8788_is_valid_buck_addr(addr))
+                return -EINVAL;
+
+        ret = lp8788_read_byte(buck->lp, addr, &val);
+        if (ret)
+                return ret;
+
+        return val & LP8788_VOUT_M;
+}
+
+static int lp8788_buck_enable_time(struct regulator_dev *rdev)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        enum lp8788_buck_id id = rdev_get_id(rdev);
+        u8 val, addr = LP8788_BUCK1_TIMESTEP + id;
+
+        if (lp8788_read_byte(buck->lp, addr, &val))
+                return -EINVAL;
+
+        val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;
+
+        return ENABLE_TIME_USEC * val;
+}
+
+static int lp8788_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        struct lp8788_pwm_map *pmap = buck->pmap;
+        u8 val;
+
+        if (!pmap)
+                return -EINVAL;
+
+        switch (mode) {
+        case REGULATOR_MODE_FAST:
+                val = LP8788_FORCE_PWM << pmap->shift;
+                break;
+        case REGULATOR_MODE_NORMAL:
+                val = LP8788_AUTO_PWM << pmap->shift;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, pmap->mask, val);
+}
+
+static unsigned int lp8788_buck_get_mode(struct regulator_dev *rdev)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        struct lp8788_pwm_map *pmap = buck->pmap;
+        u8 val;
+        int ret;
+
+        if (!pmap)
+                return -EINVAL;
+
+        ret = lp8788_read_byte(buck->lp, LP8788_BUCK_PWM, &val);
+        if (ret)
+                return ret;
+
+        return val & pmap->mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
+}
+
+static struct regulator_ops lp8788_buck12_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = lp8788_buck12_set_voltage_sel,
+        .get_voltage_sel = lp8788_buck12_get_voltage_sel,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp8788_buck_enable_time,
+        .set_mode = lp8788_buck_set_mode,
+        .get_mode = lp8788_buck_get_mode,
+};
+
+static struct regulator_ops lp8788_buck34_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp8788_buck_enable_time,
+        .set_mode = lp8788_buck_set_mode,
+        .get_mode = lp8788_buck_get_mode,
+};
+
+static struct regulator_desc lp8788_buck_desc[] = {
+        {
+                .name = "buck1",
+                .id = BUCK1,
+                .ops = &lp8788_buck12_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
+                .volt_table = lp8788_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_BUCK,
+                .enable_mask = LP8788_EN_BUCK1_M,
+        },
+        {
+                .name = "buck2",
+                .id = BUCK2,
+                .ops = &lp8788_buck12_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
+                .volt_table = lp8788_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_BUCK,
+                .enable_mask = LP8788_EN_BUCK2_M,
+        },
+        {
+                .name = "buck3",
+                .id = BUCK3,
+                .ops = &lp8788_buck34_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
+                .volt_table = lp8788_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_BUCK3_VOUT,
+                .vsel_mask = LP8788_VOUT_M,
+                .enable_reg = LP8788_EN_BUCK,
+                .enable_mask = LP8788_EN_BUCK3_M,
+        },
+        {
+                .name = "buck4",
+                .id = BUCK4,
+                .ops = &lp8788_buck34_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
+                .volt_table = lp8788_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_BUCK4_VOUT,
+                .vsel_mask = LP8788_VOUT_M,
+                .enable_reg = LP8788_EN_BUCK,
+                .enable_mask = LP8788_EN_BUCK4_M,
+        },
+};
+
+static int lp8788_set_default_dvs_ctrl_mode(struct lp8788 *lp,
+                                        enum lp8788_buck_id id)
+{
+        u8 mask, val;
+
+        switch (id) {
+        case BUCK1:
+                mask = LP8788_BUCK1_DVS_SEL_M;
+                val  = LP8788_BUCK1_DVS_I2C;
+                break;
+        case BUCK2:
+                mask = LP8788_BUCK2_DVS_SEL_M;
+                val  = LP8788_BUCK2_DVS_I2C;
+                break;
+        default:
+                return 0;
+        }
+
+        return lp8788_update_bits(lp, LP8788_BUCK_DVS_SEL, mask, val);
+}
+
+static int _gpio_request(struct lp8788_buck *buck, int gpio, char *name)
+{
+        struct device *dev = buck->lp->dev;
+
+        if (!gpio_is_valid(gpio)) {
+                dev_err(dev, "invalid gpio: %d\n", gpio);
+                return -EINVAL;
+        }
+
+        return devm_gpio_request_one(dev, gpio, DVS_LOW, name);
+}
+
+static int lp8788_dvs_gpio_request(struct lp8788_buck *buck,
+                                enum lp8788_buck_id id)
+{
+        struct lp8788_platform_data *pdata = buck->lp->pdata;
+        char *b1_name = "LP8788_B1_DVS";
+        char *b2_name[] = { "LP8788_B2_DVS1", "LP8788_B2_DVS2" };
+        int i, gpio, ret;
+
+        switch (id) {
+        case BUCK1:
+                gpio = pdata->buck1_dvs->gpio;
+                ret = _gpio_request(buck, gpio, b1_name);
+                if (ret)
+                        return ret;
+
+                buck->dvs = pdata->buck1_dvs;
+                break;
+        case BUCK2:
+                for (i = 0 ; i < LP8788_NUM_BUCK2_DVS ; i++) {
+                        gpio = pdata->buck2_dvs->gpio[i];
+                        ret = _gpio_request(buck, gpio, b2_name[i]);
+                        if (ret)
+                                return ret;
+                }
+                buck->dvs = pdata->buck2_dvs;
+                break;
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+static int lp8788_init_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
+{
+        struct lp8788_platform_data *pdata = buck->lp->pdata;
+        u8 mask[] = { LP8788_BUCK1_DVS_SEL_M, LP8788_BUCK2_DVS_SEL_M };
+        u8 val[]  = { LP8788_BUCK1_DVS_PIN, LP8788_BUCK2_DVS_PIN };
+
+        /* no dvs for buck3, 4 */
+        if (id == BUCK3 || id == BUCK4)
+                return 0;
+
+        /* no dvs platform data, then dvs will be selected by I2C registers */
+        if (!pdata)
+                goto set_default_dvs_mode;
+
+        if ((id == BUCK1 && !pdata->buck1_dvs) ||
+                (id == BUCK2 && !pdata->buck2_dvs))
+                goto set_default_dvs_mode;
+
+        if (lp8788_dvs_gpio_request(buck, id))
+                goto set_default_dvs_mode;
+
+        return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
+                                val[id]);
+
+set_default_dvs_mode:
+        return lp8788_set_default_dvs_ctrl_mode(buck->lp, id);
+}
+
+static __devinit int lp8788_buck_probe(struct platform_device *pdev)
+{
+        struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
+        int id = pdev->id;
+        struct lp8788_buck *buck;
+        struct regulator_config cfg = { };
+        struct regulator_dev *rdev;
+        int ret;
+
+        buck = devm_kzalloc(lp->dev, sizeof(struct lp8788_buck), GFP_KERNEL);
+        if (!buck)
+                return -ENOMEM;
+
+        buck->lp = lp;
+        buck->pmap = &buck_pmap[id];
+
+        ret = lp8788_init_dvs(buck, id);
+        if (ret)
+                return ret;
+
+        cfg.dev = lp->dev;
+        cfg.init_data = lp->pdata ? lp->pdata->buck_data[id] : NULL;
+        cfg.driver_data = buck;
+        cfg.regmap = lp->regmap;
+
+        rdev = regulator_register(&lp8788_buck_desc[id], &cfg);
+        if (IS_ERR(rdev)) {
+                ret = PTR_ERR(rdev);
+                dev_err(lp->dev, "BUCK%d regulator register err = %d\n",
+                                id + 1, ret);
+                return ret;
+        }
+
+        buck->regulator = rdev;
+        platform_set_drvdata(pdev, buck);
+
+        return 0;
+}
+
+static int __devexit lp8788_buck_remove(struct platform_device *pdev)
+{
+        struct lp8788_buck *buck = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        regulator_unregister(buck->regulator);
+
+        return 0;
+}
+
+static struct platform_driver lp8788_buck_driver = {
+        .probe = lp8788_buck_probe,
+        .remove = __devexit_p(lp8788_buck_remove),
+        .driver = {
+                .name = LP8788_DEV_BUCK,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init lp8788_buck_init(void)
+{
+        return platform_driver_register(&lp8788_buck_driver);
+}
+subsys_initcall(lp8788_buck_init);
+
+static void __exit lp8788_buck_exit(void)
+{
+        platform_driver_unregister(&lp8788_buck_driver);
+}
+module_exit(lp8788_buck_exit);
+
+MODULE_DESCRIPTION("TI LP8788 BUCK Driver");
+MODULE_AUTHOR("Milo Kim");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:lp8788-buck");
diff --git a/drivers/regulator/lp8788-ldo.c b/drivers/regulator/lp8788-ldo.c
new file mode 100644
index 000000000000..d2122e41a96d
--- /dev/null
+++ b/drivers/regulator/lp8788-ldo.c
@@ -0,0 +1,842 @@
+/*
+ * TI LP8788 MFD - ldo regulator driver
+ *
+ * Copyright 2012 Texas Instruments
+ *
+ * Author: Milo(Woogyom) Kim <milo.kim@ti.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/slab.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/gpio.h>
+#include <linux/mfd/lp8788.h>
+
+/* register address */
+#define LP8788_EN_LDO_A                 0x0D    /* DLDO 1 ~ 8 */
+#define LP8788_EN_LDO_B                 0x0E    /* DLDO 9 ~ 12, ALDO 1 ~ 4 */
+#define LP8788_EN_LDO_C                 0x0F    /* ALDO 5 ~ 10 */
+#define LP8788_EN_SEL                   0x10
+#define LP8788_DLDO1_VOUT               0x2E
+#define LP8788_DLDO2_VOUT               0x2F
+#define LP8788_DLDO3_VOUT               0x30
+#define LP8788_DLDO4_VOUT               0x31
+#define LP8788_DLDO5_VOUT               0x32
+#define LP8788_DLDO6_VOUT               0x33
+#define LP8788_DLDO7_VOUT               0x34
+#define LP8788_DLDO8_VOUT               0x35
+#define LP8788_DLDO9_VOUT               0x36
+#define LP8788_DLDO10_VOUT              0x37
+#define LP8788_DLDO11_VOUT              0x38
+#define LP8788_DLDO12_VOUT              0x39
+#define LP8788_ALDO1_VOUT               0x3A
+#define LP8788_ALDO2_VOUT               0x3B
+#define LP8788_ALDO3_VOUT               0x3C
+#define LP8788_ALDO4_VOUT               0x3D
+#define LP8788_ALDO5_VOUT               0x3E
+#define LP8788_ALDO6_VOUT               0x3F
+#define LP8788_ALDO7_VOUT               0x40
+#define LP8788_ALDO8_VOUT               0x41
+#define LP8788_ALDO9_VOUT               0x42
+#define LP8788_ALDO10_VOUT              0x43
+#define LP8788_DLDO1_TIMESTEP           0x44
+
+/* mask/shift bits */
+#define LP8788_EN_DLDO1_M               BIT(0)  /* Addr 0Dh ~ 0Fh */
+#define LP8788_EN_DLDO2_M               BIT(1)
+#define LP8788_EN_DLDO3_M               BIT(2)
+#define LP8788_EN_DLDO4_M               BIT(3)
+#define LP8788_EN_DLDO5_M               BIT(4)
+#define LP8788_EN_DLDO6_M               BIT(5)
+#define LP8788_EN_DLDO7_M               BIT(6)
+#define LP8788_EN_DLDO8_M               BIT(7)
+#define LP8788_EN_DLDO9_M               BIT(0)
+#define LP8788_EN_DLDO10_M              BIT(1)
+#define LP8788_EN_DLDO11_M              BIT(2)
+#define LP8788_EN_DLDO12_M              BIT(3)
+#define LP8788_EN_ALDO1_M               BIT(4)
+#define LP8788_EN_ALDO2_M               BIT(5)
+#define LP8788_EN_ALDO3_M               BIT(6)
+#define LP8788_EN_ALDO4_M               BIT(7)
+#define LP8788_EN_ALDO5_M               BIT(0)
+#define LP8788_EN_ALDO6_M               BIT(1)
+#define LP8788_EN_ALDO7_M               BIT(2)
+#define LP8788_EN_ALDO8_M               BIT(3)
+#define LP8788_EN_ALDO9_M               BIT(4)
+#define LP8788_EN_ALDO10_M              BIT(5)
+#define LP8788_EN_SEL_DLDO911_M         BIT(0)  /* Addr 10h */
+#define LP8788_EN_SEL_DLDO7_M           BIT(1)
+#define LP8788_EN_SEL_ALDO7_M           BIT(2)
+#define LP8788_EN_SEL_ALDO5_M           BIT(3)
+#define LP8788_EN_SEL_ALDO234_M         BIT(4)
+#define LP8788_EN_SEL_ALDO1_M           BIT(5)
+#define LP8788_VOUT_5BIT_M              0x1F    /* Addr 2Eh ~ 43h */
+#define LP8788_VOUT_4BIT_M              0x0F
+#define LP8788_VOUT_3BIT_M              0x07
+#define LP8788_VOUT_1BIT_M              0x01
+#define LP8788_STARTUP_TIME_M           0xF8    /* Addr 44h ~ 59h */
+#define LP8788_STARTUP_TIME_S           3
+
+#define ENABLE_TIME_USEC                32
+#define ENABLE                          GPIOF_OUT_INIT_HIGH
+#define DISABLE                         GPIOF_OUT_INIT_LOW
+
+enum lp8788_enable_mode {
+        REGISTER,
+        EXTPIN,
+};
+
+enum lp8788_ldo_id {
+        DLDO1,
+        DLDO2,
+        DLDO3,
+        DLDO4,
+        DLDO5,
+        DLDO6,
+        DLDO7,
+        DLDO8,
+        DLDO9,
+        DLDO10,
+        DLDO11,
+        DLDO12,
+        ALDO1,
+        ALDO2,
+        ALDO3,
+        ALDO4,
+        ALDO5,
+        ALDO6,
+        ALDO7,
+        ALDO8,
+        ALDO9,
+        ALDO10,
+};
+
+struct lp8788_ldo {
+        struct lp8788 *lp;
+        struct regulator_desc *desc;
+        struct regulator_dev *regulator;
+        struct lp8788_ldo_enable_pin *en_pin;
+};
+
+/* DLDO 1, 2, 3, 9 voltage table */
+const int lp8788_dldo1239_vtbl[] = {
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2900000, 3000000, 2850000, 2850000, 2850000,
+        2850000, 2850000, 2850000, 2850000, 2850000, 2850000, 2850000, 2850000,
+        2850000, 2850000, 2850000, 2850000, 2850000, 2850000, 2850000, 2850000,
+};
+
+/* DLDO 4 voltage table */
+static const int lp8788_dldo4_vtbl[] = { 1800000, 3000000 };
+
+/* DLDO 5, 7, 8 and ALDO 6 voltage table */
+static const int lp8788_dldo578_aldo6_vtbl[] = {
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2900000, 3000000, 3000000, 3000000, 3000000,
+};
+
+/* DLDO 6 voltage table */
+static const int lp8788_dldo6_vtbl[] = {
+        3000000, 3100000, 3200000, 3300000, 3400000, 3500000, 3600000, 3600000,
+};
+
+/* DLDO 10, 11 voltage table */
+static const int lp8788_dldo1011_vtbl[] = {
+        1100000, 1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000,
+        1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000,
+};
+
+/* ALDO 1 voltage table */
+static const int lp8788_aldo1_vtbl[] = { 1800000, 2850000 };
+
+/* ALDO 7 voltage table */
+static const int lp8788_aldo7_vtbl[] = {
+        1200000, 1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1800000,
+};
+
+static enum lp8788_ldo_id lp8788_dldo_id[] = {
+        DLDO1,
+        DLDO2,
+        DLDO3,
+        DLDO4,
+        DLDO5,
+        DLDO6,
+        DLDO7,
+        DLDO8,
+        DLDO9,
+        DLDO10,
+        DLDO11,
+        DLDO12,
+};
+
+static enum lp8788_ldo_id lp8788_aldo_id[] = {
+        ALDO1,
+        ALDO2,
+        ALDO3,
+        ALDO4,
+        ALDO5,
+        ALDO6,
+        ALDO7,
+        ALDO8,
+        ALDO9,
+        ALDO10,
+};
+
+/* DLDO 7, 9 and 11, ALDO 1 ~ 5 and 7
+   : can be enabled either by external pin or by i2c register */
+static enum lp8788_enable_mode
+lp8788_get_ldo_enable_mode(struct lp8788_ldo *ldo, enum lp8788_ldo_id id)
+{
+        int ret;
+        u8 val, mask;
+
+        ret = lp8788_read_byte(ldo->lp, LP8788_EN_SEL, &val);
+        if (ret)
+                return ret;
+
+        switch (id) {
+        case DLDO7:
+                mask =  LP8788_EN_SEL_DLDO7_M;
+                break;
+        case DLDO9:
+        case DLDO11:
+                mask =  LP8788_EN_SEL_DLDO911_M;
+                break;
+        case ALDO1:
+                mask =  LP8788_EN_SEL_ALDO1_M;
+                break;
+        case ALDO2 ... ALDO4:
+                mask =  LP8788_EN_SEL_ALDO234_M;
+                break;
+        case ALDO5:
+                mask =  LP8788_EN_SEL_ALDO5_M;
+                break;
+        case ALDO7:
+                mask =  LP8788_EN_SEL_ALDO7_M;
+                break;
+        default:
+                return REGISTER;
+        }
+
+        return val & mask ? EXTPIN : REGISTER;
+}
+
+static int lp8788_ldo_ctrl_by_extern_pin(struct lp8788_ldo *ldo, int pinstate)
+{
+        struct lp8788_ldo_enable_pin *pin = ldo->en_pin;
+
+        if (!pin)
+                return -EINVAL;
+
+        if (gpio_is_valid(pin->gpio))
+                gpio_set_value(pin->gpio, pinstate);
+
+        return 0;
+}
+
+static int lp8788_ldo_is_enabled_by_extern_pin(struct lp8788_ldo *ldo)
+{
+        struct lp8788_ldo_enable_pin *pin = ldo->en_pin;
+
+        if (!pin)
+                return -EINVAL;
+
+        return gpio_get_value(pin->gpio) ? 1 : 0;
+}
+
+static int lp8788_ldo_enable(struct regulator_dev *rdev)
+{
+        struct lp8788_ldo *ldo = rdev_get_drvdata(rdev);
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+        enum lp8788_enable_mode mode = lp8788_get_ldo_enable_mode(ldo, id);
+
+        switch (mode) {
+        case EXTPIN:
+                return lp8788_ldo_ctrl_by_extern_pin(ldo, ENABLE);
+        case REGISTER:
+                return regulator_enable_regmap(rdev);
+        default:
+                return -EINVAL;
+        }
+}
+
+static int lp8788_ldo_disable(struct regulator_dev *rdev)
+{
+        struct lp8788_ldo *ldo = rdev_get_drvdata(rdev);
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+        enum lp8788_enable_mode mode = lp8788_get_ldo_enable_mode(ldo, id);
+
+        switch (mode) {
+        case EXTPIN:
+                return lp8788_ldo_ctrl_by_extern_pin(ldo, DISABLE);
+        case REGISTER:
+                return regulator_disable_regmap(rdev);
+        default:
+                return -EINVAL;
+        }
+}
+
+static int lp8788_ldo_is_enabled(struct regulator_dev *rdev)
+{
+        struct lp8788_ldo *ldo = rdev_get_drvdata(rdev);
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+        enum lp8788_enable_mode mode = lp8788_get_ldo_enable_mode(ldo, id);
+
+        switch (mode) {
+        case EXTPIN:
+                return lp8788_ldo_is_enabled_by_extern_pin(ldo);
+        case REGISTER:
+                return regulator_is_enabled_regmap(rdev);
+        default:
+                return -EINVAL;
+        }
+}
+
+static int lp8788_ldo_enable_time(struct regulator_dev *rdev)
+{
+        struct lp8788_ldo *ldo = rdev_get_drvdata(rdev);
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+        u8 val, addr = LP8788_DLDO1_TIMESTEP + id;
+
+        if (lp8788_read_byte(ldo->lp, addr, &val))
+                return -EINVAL;
+
+        val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;
+
+        return ENABLE_TIME_USEC * val;
+}
+
+static int lp8788_ldo_fixed_get_voltage(struct regulator_dev *rdev)
+{
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+
+        switch (id) {
+        case ALDO2 ... ALDO5:
+                return 2850000;
+        case DLDO12:
+        case ALDO8 ... ALDO9:
+                return 2500000;
+        case ALDO10:
+                return 1100000;
+        default:
+                return -EINVAL;
+        }
+}
+
+static struct regulator_ops lp8788_ldo_voltage_table_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .enable = lp8788_ldo_enable,
+        .disable = lp8788_ldo_disable,
+        .is_enabled = lp8788_ldo_is_enabled,
+        .enable_time = lp8788_ldo_enable_time,
+};
+
+static struct regulator_ops lp8788_ldo_voltage_fixed_ops = {
+        .get_voltage = lp8788_ldo_fixed_get_voltage,
+        .enable = lp8788_ldo_enable,
+        .disable = lp8788_ldo_disable,
+        .is_enabled = lp8788_ldo_is_enabled,
+        .enable_time = lp8788_ldo_enable_time,
+};
+
+static struct regulator_desc lp8788_dldo_desc[] = {
+        {
+                .name = "dldo1",
+                .id = DLDO1,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1239_vtbl),
+                .volt_table = lp8788_dldo1239_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO1_VOUT,
+                .vsel_mask = LP8788_VOUT_5BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO1_M,
+        },
+        {
+                .name = "dldo2",
+                .id = DLDO2,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1239_vtbl),
+                .volt_table = lp8788_dldo1239_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO2_VOUT,
+                .vsel_mask = LP8788_VOUT_5BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO2_M,
+        },
+        {
+                .name = "dldo3",
+                .id = DLDO3,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1239_vtbl),
+                .volt_table = lp8788_dldo1239_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO3_VOUT,
+                .vsel_mask = LP8788_VOUT_5BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO3_M,
+        },
+        {
+                .name = "dldo4",
+                .id = DLDO4,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo4_vtbl),
+                .volt_table = lp8788_dldo4_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO4_VOUT,
+                .vsel_mask = LP8788_VOUT_1BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO4_M,
+        },
+        {
+                .name = "dldo5",
+                .id = DLDO5,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo578_aldo6_vtbl),
+                .volt_table = lp8788_dldo578_aldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO5_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO5_M,
+        },
+        {
+                .name = "dldo6",
+                .id = DLDO6,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo6_vtbl),
+                .volt_table = lp8788_dldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO6_VOUT,
+                .vsel_mask = LP8788_VOUT_3BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO6_M,
+        },
+        {
+                .name = "dldo7",
+                .id = DLDO7,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo578_aldo6_vtbl),
+                .volt_table = lp8788_dldo578_aldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO7_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO7_M,
+        },
+        {
+                .name = "dldo8",
+                .id = DLDO8,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo578_aldo6_vtbl),
+                .volt_table = lp8788_dldo578_aldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO8_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO8_M,
+        },
+        {
+                .name = "dldo9",
+                .id = DLDO9,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1239_vtbl),
+                .volt_table = lp8788_dldo1239_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO9_VOUT,
+                .vsel_mask = LP8788_VOUT_5BIT_M,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_DLDO9_M,
+        },
+        {
+                .name = "dldo10",
+                .id = DLDO10,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1011_vtbl),
+                .volt_table = lp8788_dldo1011_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO10_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_DLDO10_M,
+        },
+        {
+                .name = "dldo11",
+                .id = DLDO11,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1011_vtbl),
+                .volt_table = lp8788_dldo1011_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO11_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_DLDO11_M,
+        },
+        {
+                .name = "dldo12",
+                .id = DLDO12,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_DLDO12_M,
+        },
+};
+
+static struct regulator_desc lp8788_aldo_desc[] = {
+        {
+                .name = "aldo1",
+                .id = ALDO1,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_aldo1_vtbl),
+                .volt_table = lp8788_aldo1_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_ALDO1_VOUT,
+                .vsel_mask = LP8788_VOUT_1BIT_M,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_ALDO1_M,
+        },
+        {
+                .name = "aldo2",
+                .id = ALDO2,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_ALDO2_M,
+        },
+        {
+                .name = "aldo3",
+                .id = ALDO3,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_ALDO3_M,
+        },
+        {
+                .name = "aldo4",
+                .id = ALDO4,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_ALDO4_M,
+        },
+        {
+                .name = "aldo5",
+                .id = ALDO5,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO5_M,
+        },
+        {
+                .name = "aldo6",
+                .id = ALDO6,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo578_aldo6_vtbl),
+                .volt_table = lp8788_dldo578_aldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_ALDO6_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO6_M,
+        },
+        {
+                .name = "aldo7",
+                .id = ALDO7,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_aldo7_vtbl),
+                .volt_table = lp8788_aldo7_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_ALDO7_VOUT,
+                .vsel_mask = LP8788_VOUT_3BIT_M,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO7_M,
+        },
+        {
+                .name = "aldo8",
+                .id = ALDO8,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO8_M,
+        },
+        {
+                .name = "aldo9",
+                .id = ALDO9,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO9_M,
+        },
+        {
+                .name = "aldo10",
+                .id = ALDO10,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO10_M,
+        },
+};
+
+static int lp8788_gpio_request_ldo_en(struct lp8788_ldo *ldo,
+                                enum lp8788_ext_ldo_en_id id)
+{
+        struct device *dev = ldo->lp->dev;
+        struct lp8788_ldo_enable_pin *pin = ldo->en_pin;
+        int ret, gpio, pinstate;
+        char *name[] = {
+                [EN_ALDO1]   = "LP8788_EN_ALDO1",
+                [EN_ALDO234] = "LP8788_EN_ALDO234",
+                [EN_ALDO5]   = "LP8788_EN_ALDO5",
+                [EN_ALDO7]   = "LP8788_EN_ALDO7",
+                [EN_DLDO7]   = "LP8788_EN_DLDO7",
+                [EN_DLDO911] = "LP8788_EN_DLDO911",
+        };
+
+        gpio = pin->gpio;
+        if (!gpio_is_valid(gpio)) {
+                dev_err(dev, "invalid gpio: %d\n", gpio);
+                return -EINVAL;
+        }
+
+        pinstate = pin->init_state;
+        ret = devm_gpio_request_one(dev, gpio, pinstate, name[id]);
+        if (ret == -EBUSY) {
+                dev_warn(dev, "gpio%d already used\n", gpio);
+                return 0;
+        }
+
+        return ret;
+}
+
+static int lp8788_config_ldo_enable_mode(struct lp8788_ldo *ldo,
+                                        enum lp8788_ldo_id id)
+{
+        int ret;
+        struct lp8788 *lp = ldo->lp;
+        struct lp8788_platform_data *pdata = lp->pdata;
+        enum lp8788_ext_ldo_en_id enable_id;
+        u8 en_mask[] = {
+                [EN_ALDO1]   = LP8788_EN_SEL_ALDO1_M,
+                [EN_ALDO234] = LP8788_EN_SEL_ALDO234_M,
+                [EN_ALDO5]   = LP8788_EN_SEL_ALDO5_M,
+                [EN_ALDO7]   = LP8788_EN_SEL_ALDO7_M,
+                [EN_DLDO7]   = LP8788_EN_SEL_DLDO7_M,
+                [EN_DLDO911] = LP8788_EN_SEL_DLDO911_M,
+        };
+        u8 val[] = {
+                [EN_ALDO1]   = 0 << 5,
+                [EN_ALDO234] = 0 << 4,
+                [EN_ALDO5]   = 0 << 3,
+                [EN_ALDO7]   = 0 << 2,
+                [EN_DLDO7]   = 0 << 1,
+                [EN_DLDO911] = 0 << 0,
+        };
+
+        switch (id) {
+        case DLDO7:
+                enable_id = EN_DLDO7;
+                break;
+        case DLDO9:
+        case DLDO11:
+                enable_id = EN_DLDO911;
+                break;
+        case ALDO1:
+                enable_id = EN_ALDO1;
+                break;
+        case ALDO2 ... ALDO4:
+                enable_id = EN_ALDO234;
+                break;
+        case ALDO5:
+                enable_id = EN_ALDO5;
+                break;
+        case ALDO7:
+                enable_id = EN_ALDO7;
+                break;
+        default:
+                return 0;
+        }
+
+        /* if no platform data for ldo pin, then set default enable mode */
+        if (!pdata || !pdata->ldo_pin || !pdata->ldo_pin[enable_id])
+                goto set_default_ldo_enable_mode;
+
+        ldo->en_pin = pdata->ldo_pin[enable_id];
+
+        ret = lp8788_gpio_request_ldo_en(ldo, enable_id);
+        if (ret)
+                goto set_default_ldo_enable_mode;
+
+        return ret;
+
+set_default_ldo_enable_mode:
+        return lp8788_update_bits(lp, LP8788_EN_SEL, en_mask[enable_id],
+                                val[enable_id]);
+}
+
+static __devinit int lp8788_dldo_probe(struct platform_device *pdev)
+{
+        struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
+        int id = pdev->id;
+        struct lp8788_ldo *ldo;
+        struct regulator_config cfg = { };
+        struct regulator_dev *rdev;
+        int ret;
+
+        ldo = devm_kzalloc(lp->dev, sizeof(struct lp8788_ldo), GFP_KERNEL);
+        if (!ldo)
+                return -ENOMEM;
+
+        ldo->lp = lp;
+        ret = lp8788_config_ldo_enable_mode(ldo, lp8788_dldo_id[id]);
+        if (ret)
+                return ret;
+
+        cfg.dev = lp->dev;
+        cfg.init_data = lp->pdata ? lp->pdata->dldo_data[id] : NULL;
+        cfg.driver_data = ldo;
+        cfg.regmap = lp->regmap;
+
+        rdev = regulator_register(&lp8788_dldo_desc[id], &cfg);
+        if (IS_ERR(rdev)) {
+                ret = PTR_ERR(rdev);
+                dev_err(lp->dev, "DLDO%d regulator register err = %d\n",
+                                id + 1, ret);
+                return ret;
+        }
+
+        ldo->regulator = rdev;
+        platform_set_drvdata(pdev, ldo);
+
+        return 0;
+}
+
+static int __devexit lp8788_dldo_remove(struct platform_device *pdev)
+{
+        struct lp8788_ldo *ldo = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        regulator_unregister(ldo->regulator);
+
+        return 0;
+}
+
+static struct platform_driver lp8788_dldo_driver = {
+        .probe = lp8788_dldo_probe,
+        .remove = __devexit_p(lp8788_dldo_remove),
+        .driver = {
+                .name = LP8788_DEV_DLDO,
+                .owner = THIS_MODULE,
+        },
+};
+
+static __devinit int lp8788_aldo_probe(struct platform_device *pdev)
+{
+        struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
+        int id = pdev->id;
+        struct lp8788_ldo *ldo;
+        struct regulator_config cfg = { };
+        struct regulator_dev *rdev;
+        int ret;
+
+        ldo = devm_kzalloc(lp->dev, sizeof(struct lp8788_ldo), GFP_KERNEL);
+        if (!ldo)
+                return -ENOMEM;
+
+        ldo->lp = lp;
+        ret = lp8788_config_ldo_enable_mode(ldo, lp8788_aldo_id[id]);
+        if (ret)
+                return ret;
+
+        cfg.dev = lp->dev;
+        cfg.init_data = lp->pdata ? lp->pdata->aldo_data[id] : NULL;
+        cfg.driver_data = ldo;
+        cfg.regmap = lp->regmap;
+
+        rdev = regulator_register(&lp8788_aldo_desc[id], &cfg);
+        if (IS_ERR(rdev)) {
+                ret = PTR_ERR(rdev);
+                dev_err(lp->dev, "ALDO%d regulator register err = %d\n",
+                                id + 1, ret);
+                return ret;
+        }
+
+        ldo->regulator = rdev;
+        platform_set_drvdata(pdev, ldo);
+
+        return 0;
+}
+
+static int __devexit lp8788_aldo_remove(struct platform_device *pdev)
+{
+        struct lp8788_ldo *ldo = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        regulator_unregister(ldo->regulator);
+
+        return 0;
+}
+
+static struct platform_driver lp8788_aldo_driver = {
+        .probe = lp8788_aldo_probe,
+        .remove = __devexit_p(lp8788_aldo_remove),
+        .driver = {
+                .name = LP8788_DEV_ALDO,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init lp8788_ldo_init(void)
+{
+        int ret;
+
+        ret = platform_driver_register(&lp8788_dldo_driver);
+        if (ret)
+                return ret;
+
+        return platform_driver_register(&lp8788_aldo_driver);
+}
+subsys_initcall(lp8788_ldo_init);
+
+static void __exit lp8788_ldo_exit(void)
+{
+        platform_driver_unregister(&lp8788_aldo_driver);
+        platform_driver_unregister(&lp8788_dldo_driver);
+}
+module_exit(lp8788_ldo_exit);
+
+MODULE_DESCRIPTION("TI LP8788 LDO Driver");
+MODULE_AUTHOR("Milo Kim");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:lp8788-dldo");
+MODULE_ALIAS("platform:lp8788-aldo");
diff --git a/drivers/regulator/max1586.c b/drivers/regulator/max1586.c
index b9444ee08da9..f67af3c1b963 100644
--- a/drivers/regulator/max1586.c
+++ b/drivers/regulator/max1586.c
@@ -48,6 +48,14 @@ struct max1586_data {
 };
 
 /*
+ * V6 voltage
+ * On I2C bus, sending a "x" byte to the max1586 means :
+ *   set V6 to either 0V, 1.8V, 2.5V, 3V depending on (x & 0x3)
+ * As regulator framework doesn't accept voltages to be 0V, we use 1uV.
+ */
+static int v6_voltages_uv[] = { 1, 1800000, 2500000, 3000000 };
+
+/*
  * V3 voltage
  * On I2C bus, sending a "x" byte to the max1586 means :
  *   set V3 to 0.700V + (x & 0x1f) * 0.025V
@@ -55,113 +63,49 @@ struct max1586_data {
  * R24 and R25=100kOhm as described in the data sheet.
  * The gain is approximately: 1 + R24/R25 + R24/185.5kOhm
  */
-static int max1586_v3_calc_voltage(struct max1586_data *max1586,
-        unsigned selector)
-{
-        unsigned range_uV = max1586->max_uV - max1586->min_uV;
-
-        return max1586->min_uV + (selector * range_uV / MAX1586_V3_MAX_VSEL);
-}
-
-static int max1586_v3_set(struct regulator_dev *rdev, int min_uV, int max_uV,
-                          unsigned *selector)
+static int max1586_v3_set_voltage_sel(struct regulator_dev *rdev,
+                                      unsigned selector)
 {
         struct max1586_data *max1586 = rdev_get_drvdata(rdev);
         struct i2c_client *client = max1586->client;
-        unsigned range_uV = max1586->max_uV - max1586->min_uV;
         u8 v3_prog;
 
-        if (min_uV > max1586->max_uV || max_uV < max1586->min_uV)
-                return -EINVAL;
-        if (min_uV < max1586->min_uV)
-                min_uV = max1586->min_uV;
-
-        *selector = DIV_ROUND_UP((min_uV - max1586->min_uV) *
-                                 MAX1586_V3_MAX_VSEL, range_uV);
-        if (max1586_v3_calc_voltage(max1586, *selector) > max_uV)
-                return -EINVAL;
-
         dev_dbg(&client->dev, "changing voltage v3 to %dmv\n",
-                max1586_v3_calc_voltage(max1586, *selector) / 1000);
+                regulator_list_voltage_linear(rdev, selector) / 1000);
 
-        v3_prog = I2C_V3_SELECT | (u8) *selector;
+        v3_prog = I2C_V3_SELECT | (u8) selector;
         return i2c_smbus_write_byte(client, v3_prog);
 }
 
-static int max1586_v3_list(struct regulator_dev *rdev, unsigned selector)
-{
-        struct max1586_data *max1586 = rdev_get_drvdata(rdev);
-
-        if (selector > MAX1586_V3_MAX_VSEL)
-                return -EINVAL;
-        return max1586_v3_calc_voltage(max1586, selector);
-}
-
-/*
- * V6 voltage
- * On I2C bus, sending a "x" byte to the max1586 means :
- *   set V6 to either 0V, 1.8V, 2.5V, 3V depending on (x & 0x3)
- * As regulator framework doesn't accept voltages to be 0V, we use 1uV.
- */
-static int max1586_v6_calc_voltage(unsigned selector)
-{
-        static int voltages_uv[] = { 1, 1800000, 2500000, 3000000 };
-
-        return voltages_uv[selector];
-}
-
-static int max1586_v6_set(struct regulator_dev *rdev, int min_uV, int max_uV,
-                          unsigned int *selector)
+static int max1586_v6_set_voltage_sel(struct regulator_dev *rdev,
+                                      unsigned int selector)
 {
         struct i2c_client *client = rdev_get_drvdata(rdev);
         u8 v6_prog;
 
-        if (min_uV < MAX1586_V6_MIN_UV || min_uV > MAX1586_V6_MAX_UV)
-                return -EINVAL;
-        if (max_uV < MAX1586_V6_MIN_UV || max_uV > MAX1586_V6_MAX_UV)
-                return -EINVAL;
-
-        if (min_uV < 1800000)
-                *selector = 0;
-        else if (min_uV < 2500000)
-                *selector = 1;
-        else if (min_uV < 3000000)
-                *selector = 2;
-        else if (min_uV >= 3000000)
-                *selector = 3;
-
-        if (max1586_v6_calc_voltage(*selector) > max_uV)
-                return -EINVAL;
-
         dev_dbg(&client->dev, "changing voltage v6 to %dmv\n",
-                max1586_v6_calc_voltage(*selector) / 1000);
+                rdev->desc->volt_table[selector] / 1000);
 
-        v6_prog = I2C_V6_SELECT | (u8) *selector;
+        v6_prog = I2C_V6_SELECT | (u8) selector;
         return i2c_smbus_write_byte(client, v6_prog);
 }
 
-static int max1586_v6_list(struct regulator_dev *rdev, unsigned selector)
-{
-        if (selector > MAX1586_V6_MAX_VSEL)
-                return -EINVAL;
-        return max1586_v6_calc_voltage(selector);
-}
-
 /*
  * The Maxim 1586 controls V3 and V6 voltages, but offers no way of reading back
  * the set up value.
  */
 static struct regulator_ops max1586_v3_ops = {
-        .set_voltage = max1586_v3_set,
-        .list_voltage = max1586_v3_list,
+        .set_voltage_sel = max1586_v3_set_voltage_sel,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
 };
 
 static struct regulator_ops max1586_v6_ops = {
-        .set_voltage = max1586_v6_set,
-        .list_voltage = max1586_v6_list,
+        .set_voltage_sel = max1586_v6_set_voltage_sel,
+        .list_voltage = regulator_list_voltage_table,
 };
 
-static const struct regulator_desc max1586_reg[] = {
+static struct regulator_desc max1586_reg[] = {
         {
                 .name = "Output_V3",
                 .id = MAX1586_V3,
@@ -176,6 +120,7 @@ static const struct regulator_desc max1586_reg[] = {
                 .ops = &max1586_v6_ops,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = MAX1586_V6_MAX_VSEL + 1,
+                .volt_table = v6_voltages_uv,
                 .owner = THIS_MODULE,
         },
 };
@@ -213,6 +158,13 @@ static int __devinit max1586_pmic_probe(struct i2c_client *client,
                         goto err;
                 }
 
+                if (id == MAX1586_V3) {
+                        max1586_reg[id].min_uV = max1586->min_uV;
+                        max1586_reg[id].uV_step =
+                                        (max1586->max_uV - max1586->min_uV) /
+                                        MAX1586_V3_MAX_VSEL;
+                }
+
                 config.dev = &client->dev;
                 config.init_data = pdata->subdevs[i].platform_data;
                 config.driver_data = max1586;
diff --git a/drivers/regulator/max77686.c b/drivers/regulator/max77686.c
new file mode 100644
index 000000000000..c564af6f05a3
--- /dev/null
+++ b/drivers/regulator/max77686.c
@@ -0,0 +1,389 @@
+/*
+ * max77686.c - Regulator driver for the Maxim 77686
+ *
+ * Copyright (C) 2012 Samsung Electronics
+ * Chiwoong Byun <woong.byun@smasung.com>
+ * Jonghwa Lee <jonghwa3.lee@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
+ *
+ * This driver is based on max8997.c
+ */
+
+#include <linux/kernel.h>
+#include <linux/bug.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/regulator/of_regulator.h>
+#include <linux/mfd/max77686.h>
+#include <linux/mfd/max77686-private.h>
+
+#define MAX77686_LDO_MINUV      800000
+#define MAX77686_LDO_UVSTEP     50000
+#define MAX77686_LDO_LOW_MINUV  800000
+#define MAX77686_LDO_LOW_UVSTEP 25000
+#define MAX77686_BUCK_MINUV     750000
+#define MAX77686_BUCK_UVSTEP    50000
+#define MAX77686_RAMP_DELAY     100000                  /* uV/us */
+#define MAX77686_DVS_RAMP_DELAY 27500                   /* uV/us */
+#define MAX77686_DVS_MINUV      600000
+#define MAX77686_DVS_UVSTEP     12500
+
+#define MAX77686_OPMODE_SHIFT   6
+#define MAX77686_OPMODE_BUCK234_SHIFT   4
+#define MAX77686_OPMODE_MASK    0x3
+
+#define MAX77686_VSEL_MASK      0x3F
+#define MAX77686_DVS_VSEL_MASK  0xFF
+
+#define MAX77686_RAMP_RATE_MASK 0xC0
+
+#define MAX77686_REGULATORS     MAX77686_REG_MAX
+#define MAX77686_LDOS           26
+
+enum max77686_ramp_rate {
+        RAMP_RATE_13P75MV,
+        RAMP_RATE_27P5MV,
+        RAMP_RATE_55MV,
+        RAMP_RATE_NO_CTRL,      /* 100mV/us */
+};
+
+struct max77686_data {
+        struct regulator_dev **rdev;
+};
+
+static int max77686_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
+{
+        unsigned int ramp_value = RAMP_RATE_NO_CTRL;
+
+        switch (ramp_delay) {
+        case 1 ... 13750:
+                ramp_value = RAMP_RATE_13P75MV;
+                break;
+        case 13751 ... 27500:
+                ramp_value = RAMP_RATE_27P5MV;
+                break;
+        case 27501 ... 55000:
+                ramp_value = RAMP_RATE_55MV;
+                break;
+        case 55001 ... 100000:
+                break;
+        default:
+                pr_warn("%s: ramp_delay: %d not supported, setting 100000\n",
+                        rdev->desc->name, ramp_delay);
+        }
+
+        return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
+                                  MAX77686_RAMP_RATE_MASK, ramp_value << 6);
+}
+
+static struct regulator_ops max77686_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+};
+
+static struct regulator_ops max77686_buck_dvs_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+        .set_ramp_delay         = max77686_set_ramp_delay,
+};
+
+#define regulator_desc_ldo(num)         {                               \
+        .name           = "LDO"#num,                                    \
+        .id             = MAX77686_LDO##num,                            \
+        .ops            = &max77686_ops,                                \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_LDO_MINUV,                           \
+        .uV_step        = MAX77686_LDO_UVSTEP,                          \
+        .ramp_delay     = MAX77686_RAMP_DELAY,                          \
+        .n_voltages     = MAX77686_VSEL_MASK + 1,                       \
+        .vsel_reg       = MAX77686_REG_LDO1CTRL1 + num - 1,             \
+        .vsel_mask      = MAX77686_VSEL_MASK,                           \
+        .enable_reg     = MAX77686_REG_LDO1CTRL1 + num - 1,             \
+        .enable_mask    = MAX77686_OPMODE_MASK                          \
+                        << MAX77686_OPMODE_SHIFT,                       \
+}
+#define regulator_desc_ldo_low(num)             {                       \
+        .name           = "LDO"#num,                                    \
+        .id             = MAX77686_LDO##num,                            \
+        .ops            = &max77686_ops,                                \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_LDO_LOW_MINUV,                       \
+        .uV_step        = MAX77686_LDO_LOW_UVSTEP,                      \
+        .ramp_delay     = MAX77686_RAMP_DELAY,                          \
+        .n_voltages     = MAX77686_VSEL_MASK + 1,                       \
+        .vsel_reg       = MAX77686_REG_LDO1CTRL1 + num - 1,             \
+        .vsel_mask      = MAX77686_VSEL_MASK,                           \
+        .enable_reg     = MAX77686_REG_LDO1CTRL1 + num - 1,             \
+        .enable_mask    = MAX77686_OPMODE_MASK                          \
+                        << MAX77686_OPMODE_SHIFT,                       \
+}
+#define regulator_desc_buck(num)                {                       \
+        .name           = "BUCK"#num,                                   \
+        .id             = MAX77686_BUCK##num,                           \
+        .ops            = &max77686_ops,                                \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_BUCK_MINUV,                          \
+        .uV_step        = MAX77686_BUCK_UVSTEP,                         \
+        .ramp_delay     = MAX77686_RAMP_DELAY,                          \
+        .n_voltages     = MAX77686_VSEL_MASK + 1,                       \
+        .vsel_reg       = MAX77686_REG_BUCK5OUT + (num - 5) * 2,        \
+        .vsel_mask      = MAX77686_VSEL_MASK,                           \
+        .enable_reg     = MAX77686_REG_BUCK5CTRL + (num - 5) * 2,       \
+        .enable_mask    = MAX77686_OPMODE_MASK,                         \
+}
+#define regulator_desc_buck1(num)               {                       \
+        .name           = "BUCK"#num,                                   \
+        .id             = MAX77686_BUCK##num,                           \
+        .ops            = &max77686_ops,                                \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_BUCK_MINUV,                          \
+        .uV_step        = MAX77686_BUCK_UVSTEP,                         \
+        .ramp_delay     = MAX77686_RAMP_DELAY,                          \
+        .n_voltages     = MAX77686_VSEL_MASK + 1,                       \
+        .vsel_reg       = MAX77686_REG_BUCK1OUT,                        \
+        .vsel_mask      = MAX77686_VSEL_MASK,                           \
+        .enable_reg     = MAX77686_REG_BUCK1CTRL,                       \
+        .enable_mask    = MAX77686_OPMODE_MASK,                         \
+}
+#define regulator_desc_buck_dvs(num)            {                       \
+        .name           = "BUCK"#num,                                   \
+        .id             = MAX77686_BUCK##num,                           \
+        .ops            = &max77686_buck_dvs_ops,                       \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_DVS_MINUV,                           \
+        .uV_step        = MAX77686_DVS_UVSTEP,                          \
+        .ramp_delay     = MAX77686_DVS_RAMP_DELAY,                      \
+        .n_voltages     = MAX77686_DVS_VSEL_MASK + 1,                   \
+        .vsel_reg       = MAX77686_REG_BUCK2DVS1 + (num - 2) * 10,      \
+        .vsel_mask      = MAX77686_DVS_VSEL_MASK,                       \
+        .enable_reg     = MAX77686_REG_BUCK2CTRL1 + (num - 2) * 10,     \
+        .enable_mask    = MAX77686_OPMODE_MASK                          \
+                        << MAX77686_OPMODE_BUCK234_SHIFT,               \
+}
+
+static struct regulator_desc regulators[] = {
+        regulator_desc_ldo_low(1),
+        regulator_desc_ldo_low(2),
+        regulator_desc_ldo(3),
+        regulator_desc_ldo(4),
+        regulator_desc_ldo(5),
+        regulator_desc_ldo_low(6),
+        regulator_desc_ldo_low(7),
+        regulator_desc_ldo_low(8),
+        regulator_desc_ldo(9),
+        regulator_desc_ldo(10),
+        regulator_desc_ldo(11),
+        regulator_desc_ldo(12),
+        regulator_desc_ldo(13),
+        regulator_desc_ldo(14),
+        regulator_desc_ldo_low(15),
+        regulator_desc_ldo(16),
+        regulator_desc_ldo(17),
+        regulator_desc_ldo(18),
+        regulator_desc_ldo(19),
+        regulator_desc_ldo(20),
+        regulator_desc_ldo(21),
+        regulator_desc_ldo(22),
+        regulator_desc_ldo(23),
+        regulator_desc_ldo(24),
+        regulator_desc_ldo(25),
+        regulator_desc_ldo(26),
+        regulator_desc_buck1(1),
+        regulator_desc_buck_dvs(2),
+        regulator_desc_buck_dvs(3),
+        regulator_desc_buck_dvs(4),
+        regulator_desc_buck(5),
+        regulator_desc_buck(6),
+        regulator_desc_buck(7),
+        regulator_desc_buck(8),
+        regulator_desc_buck(9),
+};
+
+#ifdef CONFIG_OF
+static int max77686_pmic_dt_parse_pdata(struct max77686_dev *iodev,
+                                        struct max77686_platform_data *pdata)
+{
+        struct device_node *pmic_np, *regulators_np;
+        struct max77686_regulator_data *rdata;
+        struct of_regulator_match rmatch;
+        unsigned int i;
+
+        pmic_np = iodev->dev->of_node;
+        regulators_np = of_find_node_by_name(pmic_np, "voltage-regulators");
+        if (!regulators_np) {
+                dev_err(iodev->dev, "could not find regulators sub-node\n");
+                return -EINVAL;
+        }
+
+        pdata->num_regulators = ARRAY_SIZE(regulators);
+        rdata = devm_kzalloc(iodev->dev, sizeof(*rdata) *
+                             pdata->num_regulators, GFP_KERNEL);
+        if (!rdata) {
+                dev_err(iodev->dev,
+                        "could not allocate memory for regulator data\n");
+                return -ENOMEM;
+        }
+
+        for (i = 0; i < pdata->num_regulators; i++) {
+                rmatch.name = regulators[i].name;
+                rmatch.init_data = NULL;
+                rmatch.of_node = NULL;
+                of_regulator_match(iodev->dev, regulators_np, &rmatch, 1);
+                rdata[i].initdata = rmatch.init_data;
+        }
+
+        pdata->regulators = rdata;
+
+        return 0;
+}
+#else
+static int max77686_pmic_dt_parse_pdata(struct max77686_dev *iodev,
+                                        struct max77686_platform_data *pdata)
+{
+        return 0;
+}
+#endif /* CONFIG_OF */
+
+static __devinit int max77686_pmic_probe(struct platform_device *pdev)
+{
+        struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        struct max77686_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct regulator_dev **rdev;
+        struct max77686_data *max77686;
+        int i,  size;
+        int ret = 0;
+        struct regulator_config config = { };
+
+        dev_dbg(&pdev->dev, "%s\n", __func__);
+
+        if (!pdata) {
+                dev_err(&pdev->dev, "no platform data found for regulator\n");
+                return -ENODEV;
+        }
+
+        if (iodev->dev->of_node) {
+                ret = max77686_pmic_dt_parse_pdata(iodev, pdata);
+                if (ret)
+                        return ret;
+        }
+
+        if (pdata->num_regulators != MAX77686_REGULATORS) {
+                dev_err(&pdev->dev,
+                        "Invalid initial data for regulator's initialiation\n");
+                return -EINVAL;
+        }
+
+        max77686 = devm_kzalloc(&pdev->dev, sizeof(struct max77686_data),
+                                GFP_KERNEL);
+        if (!max77686)
+                return -ENOMEM;
+
+        size = sizeof(struct regulator_dev *) * MAX77686_REGULATORS;
+        max77686->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
+        if (!max77686->rdev)
+                return -ENOMEM;
+
+        rdev = max77686->rdev;
+        config.dev = &pdev->dev;
+        config.regmap = iodev->regmap;
+        platform_set_drvdata(pdev, max77686);
+
+        for (i = 0; i < MAX77686_REGULATORS; i++) {
+                config.init_data = pdata->regulators[i].initdata;
+
+                rdev[i] = regulator_register(&regulators[i], &config);
+                if (IS_ERR(rdev[i])) {
+                        ret = PTR_ERR(rdev[i]);
+                        dev_err(&pdev->dev,
+                                "regulator init failed for %d\n", i);
+                                rdev[i] = NULL;
+                                goto err;
+                }
+        }
+
+        return 0;
+err:
+        while (--i >= 0)
+                regulator_unregister(rdev[i]);
+        return ret;
+}
+
+static int __devexit max77686_pmic_remove(struct platform_device *pdev)
+{
+        struct max77686_data *max77686 = platform_get_drvdata(pdev);
+        struct regulator_dev **rdev = max77686->rdev;
+        int i;
+
+        for (i = 0; i < MAX77686_REGULATORS; i++)
+                if (rdev[i])
+                        regulator_unregister(rdev[i]);
+
+        return 0;
+}
+
+static const struct platform_device_id max77686_pmic_id[] = {
+        {"max77686-pmic", 0},
+        { },
+};
+MODULE_DEVICE_TABLE(platform, max77686_pmic_id);
+
+static struct platform_driver max77686_pmic_driver = {
+        .driver = {
+                .name = "max77686-pmic",
+                .owner = THIS_MODULE,
+        },
+        .probe = max77686_pmic_probe,
+        .remove = __devexit_p(max77686_pmic_remove),
+        .id_table = max77686_pmic_id,
+};
+
+static int __init max77686_pmic_init(void)
+{
+        return platform_driver_register(&max77686_pmic_driver);
+}
+subsys_initcall(max77686_pmic_init);
+
+static void __exit max77686_pmic_cleanup(void)
+{
+        platform_driver_unregister(&max77686_pmic_driver);
+}
+module_exit(max77686_pmic_cleanup);
+
+MODULE_DESCRIPTION("MAXIM 77686 Regulator Driver");
+MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/max8952.c b/drivers/regulator/max8952.c
index 910c9b26d499..355ca7bad9d5 100644
--- a/drivers/regulator/max8952.c
+++ b/drivers/regulator/max8952.c
@@ -51,7 +51,6 @@ struct max8952_data {
 
         bool vid0;
         bool vid1;
-        bool en;
 };
 
 static int max8952_read_reg(struct max8952_data *max8952, u8 reg)
@@ -80,38 +79,6 @@ static int max8952_list_voltage(struct regulator_dev *rdev,
         return (max8952->pdata->dvs_mode[selector] * 10 + 770) * 1000;
 }
 
-static int max8952_is_enabled(struct regulator_dev *rdev)
-{
-        struct max8952_data *max8952 = rdev_get_drvdata(rdev);
-        return max8952->en;
-}
-
-static int max8952_enable(struct regulator_dev *rdev)
-{
-        struct max8952_data *max8952 = rdev_get_drvdata(rdev);
-
-        /* If not valid, assume "ALWAYS_HIGH" */
-        if (gpio_is_valid(max8952->pdata->gpio_en))
-                gpio_set_value(max8952->pdata->gpio_en, 1);
-
-        max8952->en = true;
-        return 0;
-}
-
-static int max8952_disable(struct regulator_dev *rdev)
-{
-        struct max8952_data *max8952 = rdev_get_drvdata(rdev);
-
-        /* If not valid, assume "ALWAYS_HIGH" -> not permitted */
-        if (gpio_is_valid(max8952->pdata->gpio_en))
-                gpio_set_value(max8952->pdata->gpio_en, 0);
-        else
-                return -EPERM;
-
-        max8952->en = false;
-        return 0;
-}
-
 static int max8952_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct max8952_data *max8952 = rdev_get_drvdata(rdev);
@@ -146,12 +113,8 @@ static int max8952_set_voltage_sel(struct regulator_dev *rdev,
 
 static struct regulator_ops max8952_ops = {
         .list_voltage           = max8952_list_voltage,
-        .is_enabled             = max8952_is_enabled,
-        .enable                 = max8952_enable,
-        .disable                = max8952_disable,
         .get_voltage_sel        = max8952_get_voltage_sel,
         .set_voltage_sel        = max8952_set_voltage_sel,
-        .set_suspend_disable    = max8952_disable,
 };
 
 static const struct regulator_desc regulator = {
@@ -194,6 +157,10 @@ static int __devinit max8952_pmic_probe(struct i2c_client *client,
         config.init_data = &pdata->reg_data;
         config.driver_data = max8952;
 
+        config.ena_gpio = pdata->gpio_en;
+        if (pdata->reg_data.constraints.boot_on)
+                config.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+
         max8952->rdev = regulator_register(&regulator, &config);
 
         if (IS_ERR(max8952->rdev)) {
@@ -202,27 +169,9 @@ static int __devinit max8952_pmic_probe(struct i2c_client *client,
                 return ret;
         }
 
-        max8952->en = !!(pdata->reg_data.constraints.boot_on);
         max8952->vid0 = pdata->default_mode & 0x1;
         max8952->vid1 = (pdata->default_mode >> 1) & 0x1;
 
-        if (gpio_is_valid(pdata->gpio_en)) {
-                if (!gpio_request(pdata->gpio_en, "MAX8952 EN"))
-                        gpio_direction_output(pdata->gpio_en, max8952->en);
-                else
-                        err = 1;
-        } else
-                err = 2;
-
-        if (err) {
-                dev_info(max8952->dev, "EN gpio invalid: assume that EN"
-                                "is always High\n");
-                max8952->en = 1;
-                pdata->gpio_en = -1; /* Mark invalid */
-        }
-
-        err = 0;
-
         if (gpio_is_valid(pdata->gpio_vid0) &&
                         gpio_is_valid(pdata->gpio_vid1)) {
                 if (!gpio_request(pdata->gpio_vid0, "MAX8952 VID0"))
@@ -308,7 +257,6 @@ static int __devexit max8952_pmic_remove(struct i2c_client *client)
 
         gpio_free(pdata->gpio_vid0);
         gpio_free(pdata->gpio_vid1);
-        gpio_free(pdata->gpio_en);
         return 0;
 }
 
diff --git a/drivers/regulator/max8997.c b/drivers/regulator/max8997.c
index 704cd49ef375..e39a0c7260dc 100644
--- a/drivers/regulator/max8997.c
+++ b/drivers/regulator/max8997.c
@@ -1025,7 +1025,6 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
          */
         if (pdata->buck1_gpiodvs || pdata->buck2_gpiodvs ||
                         pdata->buck5_gpiodvs) {
-                bool gpio1set = false, gpio2set = false;
 
                 if (!gpio_is_valid(pdata->buck125_gpios[0]) ||
                                 !gpio_is_valid(pdata->buck125_gpios[1]) ||
@@ -1035,40 +1034,20 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                         goto err_out;
                 }
 
-                ret = gpio_request(pdata->buck125_gpios[0],
-                                "MAX8997 SET1");
-                if (ret == -EBUSY)
-                        dev_warn(&pdev->dev, "Duplicated gpio request"
-                                        " on SET1\n");
-                else if (ret)
+                ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[0],
+                                        "MAX8997 SET1");
+                if (ret)
                         goto err_out;
-                else
-                        gpio1set = true;
-
-                ret = gpio_request(pdata->buck125_gpios[1],
-                                "MAX8997 SET2");
-                if (ret == -EBUSY)
-                        dev_warn(&pdev->dev, "Duplicated gpio request"
-                                        " on SET2\n");
-                else if (ret) {
-                        if (gpio1set)
-                                gpio_free(pdata->buck125_gpios[0]);
+
+                ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[1],
+                                        "MAX8997 SET2");
+                if (ret)
                         goto err_out;
-                } else
-                        gpio2set = true;
 
-                ret = gpio_request(pdata->buck125_gpios[2],
+                ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[2],
                                 "MAX8997 SET3");
-                if (ret == -EBUSY)
-                        dev_warn(&pdev->dev, "Duplicated gpio request"
-                                        " on SET3\n");
-                else if (ret) {
-                        if (gpio1set)
-                                gpio_free(pdata->buck125_gpios[0]);
-                        if (gpio2set)
-                                gpio_free(pdata->buck125_gpios[1]);
+                if (ret)
                         goto err_out;
-                }
 
                 gpio_direction_output(pdata->buck125_gpios[0],
                                 (max8997->buck125_gpioindex >> 2)
@@ -1079,7 +1058,6 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                 gpio_direction_output(pdata->buck125_gpios[2],
                                 (max8997->buck125_gpioindex >> 0)
                                 & 0x1); /* SET3 */
-                ret = 0;
         }
 
         /* DVS-GPIO disabled */
diff --git a/drivers/regulator/max8998.c b/drivers/regulator/max8998.c
index 18bb58b9b96e..5dfa920ff0c8 100644
--- a/drivers/regulator/max8998.c
+++ b/drivers/regulator/max8998.c
@@ -111,27 +111,6 @@ static const struct voltage_map_desc *ldo_voltage_map[] = {
         &buck4_voltage_map_desc,        /* BUCK4 */
 };
 
-static int max8998_list_voltage(struct regulator_dev *rdev,
-                                unsigned int selector)
-{
-        const struct voltage_map_desc *desc;
-        int ldo = rdev_get_id(rdev);
-        int val;
-
-        if (ldo >= ARRAY_SIZE(ldo_voltage_map))
-                return -EINVAL;
-
-        desc = ldo_voltage_map[ldo];
-        if (desc == NULL)
-                return -EINVAL;
-
-        val = desc->min + desc->step * selector;
-        if (val > desc->max)
-                return -EINVAL;
-
-        return val * 1000;
-}
-
 static int max8998_get_enable_register(struct regulator_dev *rdev,
                                         int *reg, int *shift)
 {
@@ -297,41 +276,18 @@ static int max8998_get_voltage_sel(struct regulator_dev *rdev)
         return val;
 }
 
-static int max8998_set_voltage_ldo(struct regulator_dev *rdev,
-                                   int min_uV, int max_uV, unsigned *selector)
+static int max8998_set_voltage_ldo_sel(struct regulator_dev *rdev,
+                                       unsigned selector)
 {
         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
         struct i2c_client *i2c = max8998->iodev->i2c;
-        int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
-        const struct voltage_map_desc *desc;
-        int ldo = rdev_get_id(rdev);
-        int reg, shift = 0, mask, ret, i;
-
-        if (ldo >= ARRAY_SIZE(ldo_voltage_map))
-                return -EINVAL;
-
-        desc = ldo_voltage_map[ldo];
-        if (desc == NULL)
-                return -EINVAL;
-
-        if (max_vol < desc->min || min_vol > desc->max)
-                return -EINVAL;
-
-        if (min_vol < desc->min)
-                min_vol = desc->min;
-
-        i = DIV_ROUND_UP(min_vol - desc->min, desc->step);
-
-        if (desc->min + desc->step*i > max_vol)
-                return -EINVAL;
-
-        *selector = i;
+        int reg, shift = 0, mask, ret;
 
         ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
         if (ret)
                 return ret;
 
-        ret = max8998_update_reg(i2c, reg, i<<shift, mask<<shift);
+        ret = max8998_update_reg(i2c, reg, selector<<shift, mask<<shift);
 
         return ret;
 }
@@ -347,41 +303,18 @@ static inline void buck2_gpio_set(int gpio, int v)
         gpio_set_value(gpio, v & 0x1);
 }
 
-static int max8998_set_voltage_buck(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV, unsigned *selector)
+static int max8998_set_voltage_buck_sel(struct regulator_dev *rdev,
+                                        unsigned selector)
 {
         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
         struct max8998_platform_data *pdata =
                 dev_get_platdata(max8998->iodev->dev);
         struct i2c_client *i2c = max8998->iodev->i2c;
-        int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
-        const struct voltage_map_desc *desc;
         int buck = rdev_get_id(rdev);
         int reg, shift = 0, mask, ret;
-        int i, j, previous_sel;
+        int j, previous_sel;
         static u8 buck1_last_val;
 
-        if (buck >= ARRAY_SIZE(ldo_voltage_map))
-                return -EINVAL;
-
-        desc = ldo_voltage_map[buck];
-
-        if (desc == NULL)
-                return -EINVAL;
-
-        if (max_vol < desc->min || min_vol > desc->max)
-                return -EINVAL;
-
-        if (min_vol < desc->min)
-                min_vol = desc->min;
-
-        i = DIV_ROUND_UP(min_vol - desc->min, desc->step);
-
-        if (desc->min + desc->step*i > max_vol)
-                return -EINVAL;
-
-        *selector = i;
-
         ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
         if (ret)
                 return ret;
@@ -390,19 +323,19 @@ static int max8998_set_voltage_buck(struct regulator_dev *rdev,
 
         /* Check if voltage needs to be changed */
         /* if previous_voltage equal new voltage, return */
-        if (previous_sel == i) {
+        if (previous_sel == selector) {
                 dev_dbg(max8998->dev, "No voltage change, old:%d, new:%d\n",
-                        max8998_list_voltage(rdev, previous_sel),
-                        max8998_list_voltage(rdev, i));
+                        regulator_list_voltage_linear(rdev, previous_sel),
+                        regulator_list_voltage_linear(rdev, selector));
                 return ret;
         }
 
         switch (buck) {
         case MAX8998_BUCK1:
                 dev_dbg(max8998->dev,
-                        "BUCK1, i:%d, buck1_vol1:%d, buck1_vol2:%d\n"
+                        "BUCK1, selector:%d, buck1_vol1:%d, buck1_vol2:%d\n"
                         "buck1_vol3:%d, buck1_vol4:%d\n",
-                        i, max8998->buck1_vol[0], max8998->buck1_vol[1],
+                        selector, max8998->buck1_vol[0], max8998->buck1_vol[1],
                         max8998->buck1_vol[2], max8998->buck1_vol[3]);
 
                 if (gpio_is_valid(pdata->buck1_set1) &&
@@ -411,7 +344,7 @@ static int max8998_set_voltage_buck(struct regulator_dev *rdev,
                         /* check if requested voltage */
                         /* value is already defined */
                         for (j = 0; j < ARRAY_SIZE(max8998->buck1_vol); j++) {
-                                if (max8998->buck1_vol[j] == i) {
+                                if (max8998->buck1_vol[j] == selector) {
                                         max8998->buck1_idx = j;
                                         buck1_gpio_set(pdata->buck1_set1,
                                                        pdata->buck1_set2, j);
@@ -426,11 +359,11 @@ static int max8998_set_voltage_buck(struct regulator_dev *rdev,
                         max8998->buck1_idx = (buck1_last_val % 2) + 2;
                         dev_dbg(max8998->dev, "max8998->buck1_idx:%d\n",
                                 max8998->buck1_idx);
-                        max8998->buck1_vol[max8998->buck1_idx] = i;
+                        max8998->buck1_vol[max8998->buck1_idx] = selector;
                         ret = max8998_get_voltage_register(rdev, &reg,
                                                            &shift,
                                                            &mask);
-                        ret = max8998_write_reg(i2c, reg, i);
+                        ret = max8998_write_reg(i2c, reg, selector);
                         buck1_gpio_set(pdata->buck1_set1,
                                        pdata->buck1_set2, max8998->buck1_idx);
                         buck1_last_val++;
@@ -440,20 +373,20 @@ buck1_exit:
                                 gpio_get_value(pdata->buck1_set2));
                         break;
                 } else {
-                        ret = max8998_write_reg(i2c, reg, i);
+                        ret = max8998_write_reg(i2c, reg, selector);
                 }
                 break;
 
         case MAX8998_BUCK2:
                 dev_dbg(max8998->dev,
-                        "BUCK2, i:%d buck2_vol1:%d, buck2_vol2:%d\n"
-                        , i, max8998->buck2_vol[0], max8998->buck2_vol[1]);
+                        "BUCK2, selector:%d buck2_vol1:%d, buck2_vol2:%d\n",
+                        selector, max8998->buck2_vol[0], max8998->buck2_vol[1]);
                 if (gpio_is_valid(pdata->buck2_set3)) {
 
                         /* check if requested voltage */
                         /* value is already defined */
                         for (j = 0; j < ARRAY_SIZE(max8998->buck2_vol); j++) {
-                                if (max8998->buck2_vol[j] == i) {
+                                if (max8998->buck2_vol[j] == selector) {
                                         max8998->buck2_idx = j;
                                         buck2_gpio_set(pdata->buck2_set3, j);
                                         goto buck2_exit;
@@ -465,20 +398,21 @@ buck1_exit:
 
                         max8998_get_voltage_register(rdev,
                                         &reg, &shift, &mask);
-                        ret = max8998_write_reg(i2c, reg, i);
-                        max8998->buck2_vol[max8998->buck2_idx] = i;
+                        ret = max8998_write_reg(i2c, reg, selector);
+                        max8998->buck2_vol[max8998->buck2_idx] = selector;
                         buck2_gpio_set(pdata->buck2_set3, max8998->buck2_idx);
 buck2_exit:
                         dev_dbg(max8998->dev, "%s: SET3:%d\n", i2c->name,
                                 gpio_get_value(pdata->buck2_set3));
                 } else {
-                        ret = max8998_write_reg(i2c, reg, i);
+                        ret = max8998_write_reg(i2c, reg, selector);
                 }
                 break;
 
         case MAX8998_BUCK3:
         case MAX8998_BUCK4:
-                ret = max8998_update_reg(i2c, reg, i<<shift, mask<<shift);
+                ret = max8998_update_reg(i2c, reg, selector<<shift,
+                                         mask<<shift);
                 break;
         }
 
@@ -519,34 +453,30 @@ static int max8998_set_voltage_buck_time_sel(struct regulator_dev *rdev,
 }
 
 static struct regulator_ops max8998_ldo_ops = {
-        .list_voltage           = max8998_list_voltage,
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
         .is_enabled             = max8998_ldo_is_enabled,
         .enable                 = max8998_ldo_enable,
         .disable                = max8998_ldo_disable,
         .get_voltage_sel        = max8998_get_voltage_sel,
-        .set_voltage            = max8998_set_voltage_ldo,
-        .set_suspend_enable     = max8998_ldo_enable,
-        .set_suspend_disable    = max8998_ldo_disable,
+        .set_voltage_sel        = max8998_set_voltage_ldo_sel,
 };
 
 static struct regulator_ops max8998_buck_ops = {
-        .list_voltage           = max8998_list_voltage,
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
         .is_enabled             = max8998_ldo_is_enabled,
         .enable                 = max8998_ldo_enable,
         .disable                = max8998_ldo_disable,
         .get_voltage_sel        = max8998_get_voltage_sel,
-        .set_voltage            = max8998_set_voltage_buck,
+        .set_voltage_sel        = max8998_set_voltage_buck_sel,
         .set_voltage_time_sel   = max8998_set_voltage_buck_time_sel,
-        .set_suspend_enable     = max8998_ldo_enable,
-        .set_suspend_disable    = max8998_ldo_disable,
 };
 
 static struct regulator_ops max8998_others_ops = {
         .is_enabled             = max8998_ldo_is_enabled,
         .enable                 = max8998_ldo_enable,
         .disable                = max8998_ldo_disable,
-        .set_suspend_enable     = max8998_ldo_enable,
-        .set_suspend_disable    = max8998_ldo_disable,
 };
 
 static struct regulator_desc regulators[] = {
@@ -860,7 +790,10 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                 desc = ldo_voltage_map[id];
                 if (desc && regulators[index].ops != &max8998_others_ops) {
                         int count = (desc->max - desc->min) / desc->step + 1;
+
                         regulators[index].n_voltages = count;
+                        regulators[index].min_uV = desc->min * 1000;
+                        regulators[index].uV_step = desc->step * 1000;
                 }
 
                 config.dev = max8998->dev;
diff --git a/drivers/regulator/mc13783-regulator.c b/drivers/regulator/mc13783-regulator.c
index 7dcdfa283e93..4932e3449fe1 100644
--- a/drivers/regulator/mc13783-regulator.c
+++ b/drivers/regulator/mc13783-regulator.c
@@ -93,78 +93,78 @@
 
 
 /* Voltage Values */
-static const int mc13783_sw3_val[] = {
+static const unsigned int mc13783_sw3_val[] = {
         5000000, 5000000, 5000000, 5500000,
 };
 
-static const int mc13783_vaudio_val[] = {
+static const unsigned int mc13783_vaudio_val[] = {
         2775000,
 };
 
-static const int mc13783_viohi_val[] = {
+static const unsigned int mc13783_viohi_val[] = {
         2775000,
 };
 
-static const int mc13783_violo_val[] = {
+static const unsigned int mc13783_violo_val[] = {
         1200000, 1300000, 1500000, 1800000,
 };
 
-static const int mc13783_vdig_val[] = {
+static const unsigned int mc13783_vdig_val[] = {
         1200000, 1300000, 1500000, 1800000,
 };
 
-static const int mc13783_vgen_val[] = {
+static const unsigned int mc13783_vgen_val[] = {
         1200000, 1300000, 1500000, 1800000,
         1100000, 2000000, 2775000, 2400000,
 };
 
-static const int mc13783_vrfdig_val[] = {
+static const unsigned int mc13783_vrfdig_val[] = {
         1200000, 1500000, 1800000, 1875000,
 };
 
-static const int mc13783_vrfref_val[] = {
+static const unsigned int mc13783_vrfref_val[] = {
         2475000, 2600000, 2700000, 2775000,
 };
 
-static const int mc13783_vrfcp_val[] = {
+static const unsigned int mc13783_vrfcp_val[] = {
         2700000, 2775000,
 };
 
-static const int mc13783_vsim_val[] = {
+static const unsigned int mc13783_vsim_val[] = {
         1800000, 2900000, 3000000,
 };
 
-static const int mc13783_vesim_val[] = {
+static const unsigned int mc13783_vesim_val[] = {
         1800000, 2900000,
 };
 
-static const int mc13783_vcam_val[] = {
+static const unsigned int mc13783_vcam_val[] = {
         1500000, 1800000, 2500000, 2550000,
         2600000, 2750000, 2800000, 3000000,
 };
 
-static const int mc13783_vrfbg_val[] = {
+static const unsigned int mc13783_vrfbg_val[] = {
         1250000,
 };
 
-static const int mc13783_vvib_val[] = {
+static const unsigned int mc13783_vvib_val[] = {
         1300000, 1800000, 2000000, 3000000,
 };
 
-static const int mc13783_vmmc_val[] = {
+static const unsigned int mc13783_vmmc_val[] = {
         1600000, 1800000, 2000000, 2600000,
         2700000, 2800000, 2900000, 3000000,
 };
 
-static const int mc13783_vrf_val[] = {
+static const unsigned int mc13783_vrf_val[] = {
         1500000, 1875000, 2700000, 2775000,
 };
 
-static const int mc13783_gpo_val[] = {
+static const unsigned int mc13783_gpo_val[] = {
         3100000,
 };
 
-static const int mc13783_pwgtdrv_val[] = {
+static const unsigned int mc13783_pwgtdrv_val[] = {
         5500000,
 };
 
@@ -328,7 +328,7 @@ static struct regulator_ops mc13783_gpo_regulator_ops = {
         .enable = mc13783_gpo_regulator_enable,
         .disable = mc13783_gpo_regulator_disable,
         .is_enabled = mc13783_gpo_regulator_is_enabled,
-        .list_voltage = mc13xxx_regulator_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage = mc13xxx_fixed_regulator_set_voltage,
         .get_voltage = mc13xxx_fixed_regulator_get_voltage,
 };
diff --git a/drivers/regulator/mc13892-regulator.c b/drivers/regulator/mc13892-regulator.c
index 970a233dbe46..b388b746452e 100644
--- a/drivers/regulator/mc13892-regulator.c
+++ b/drivers/regulator/mc13892-regulator.c
@@ -150,12 +150,12 @@
 #define MC13892_USB1                            50
 #define MC13892_USB1_VUSBEN                     (1<<3)
 
-static const int mc13892_vcoincell[] = {
+static const unsigned int mc13892_vcoincell[] = {
         2500000, 2700000, 2800000, 2900000, 3000000, 3100000,
         3200000, 3300000,
 };
 
-static const int mc13892_sw1[] = {
+static const unsigned int mc13892_sw1[] = {
         600000,   625000,  650000,  675000,  700000,  725000,
         750000,   775000,  800000,  825000,  850000,  875000,
         900000,   925000,  950000,  975000, 1000000, 1025000,
@@ -164,7 +164,7 @@ static const int mc13892_sw1[] = {
         1350000, 1375000
 };
 
-static const int mc13892_sw[] = {
+static const unsigned int mc13892_sw[] = {
         600000,   625000,  650000,  675000,  700000,  725000,
         750000,   775000,  800000,  825000,  850000,  875000,
         900000,   925000,  950000,  975000, 1000000, 1025000,
@@ -176,65 +176,65 @@ static const int mc13892_sw[] = {
         1800000, 1825000, 1850000, 1875000
 };
 
-static const int mc13892_swbst[] = {
+static const unsigned int mc13892_swbst[] = {
         5000000,
 };
 
-static const int mc13892_viohi[] = {
+static const unsigned int mc13892_viohi[] = {
         2775000,
 };
 
-static const int mc13892_vpll[] = {
+static const unsigned int mc13892_vpll[] = {
         1050000, 1250000, 1650000, 1800000,
 };
 
-static const int mc13892_vdig[] = {
+static const unsigned int mc13892_vdig[] = {
         1050000, 1250000, 1650000, 1800000,
 };
 
-static const int mc13892_vsd[] = {
+static const unsigned int mc13892_vsd[] = {
         1800000, 2000000, 2600000, 2700000,
         2800000, 2900000, 3000000, 3150000,
 };
 
-static const int mc13892_vusb2[] = {
+static const unsigned int mc13892_vusb2[] = {
         2400000, 2600000, 2700000, 2775000,
 };
 
-static const int mc13892_vvideo[] = {
+static const unsigned int mc13892_vvideo[] = {
         2700000, 2775000, 2500000, 2600000,
 };
 
-static const int mc13892_vaudio[] = {
+static const unsigned int mc13892_vaudio[] = {
         2300000, 2500000, 2775000, 3000000,
 };
 
-static const int mc13892_vcam[] = {
+static const unsigned int mc13892_vcam[] = {
         2500000, 2600000, 2750000, 3000000,
 };
 
-static const int mc13892_vgen1[] = {
+static const unsigned int mc13892_vgen1[] = {
         1200000, 1500000, 2775000, 3150000,
 };
 
-static const int mc13892_vgen2[] = {
+static const unsigned int mc13892_vgen2[] = {
         1200000, 1500000, 1600000, 1800000,
         2700000, 2800000, 3000000, 3150000,
 };
 
-static const int mc13892_vgen3[] = {
+static const unsigned int mc13892_vgen3[] = {
         1800000, 2900000,
 };
 
-static const int mc13892_vusb[] = {
+static const unsigned int mc13892_vusb[] = {
         3300000,
 };
 
-static const int mc13892_gpo[] = {
+static const unsigned int mc13892_gpo[] = {
         2750000,
 };
 
-static const int mc13892_pwgtdrv[] = {
+static const unsigned int mc13892_pwgtdrv[] = {
         5000000,
 };
 
@@ -394,7 +394,7 @@ static struct regulator_ops mc13892_gpo_regulator_ops = {
         .enable = mc13892_gpo_regulator_enable,
         .disable = mc13892_gpo_regulator_disable,
         .is_enabled = mc13892_gpo_regulator_is_enabled,
-        .list_voltage = mc13xxx_regulator_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage = mc13xxx_fixed_regulator_set_voltage,
         .get_voltage = mc13xxx_fixed_regulator_get_voltage,
 };
@@ -436,7 +436,7 @@ static int mc13892_sw_regulator_set_voltage_sel(struct regulator_dev *rdev,
         u32 valread;
         int ret;
 
-        value = mc13892_regulators[id].voltages[selector];
+        value = rdev->desc->volt_table[selector];
 
         mc13xxx_lock(priv->mc13xxx);
         ret = mc13xxx_reg_read(priv->mc13xxx,
@@ -469,8 +469,7 @@ err:
 }
 
 static struct regulator_ops mc13892_sw_regulator_ops = {
-        .is_enabled = mc13xxx_sw_regulator_is_enabled,
-        .list_voltage = mc13xxx_regulator_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage_sel = mc13892_sw_regulator_set_voltage_sel,
         .get_voltage = mc13892_sw_regulator_get_voltage,
 };
diff --git a/drivers/regulator/mc13xxx-regulator-core.c b/drivers/regulator/mc13xxx-regulator-core.c
index 4fa9704739bc..d6eda28ca5d0 100644
--- a/drivers/regulator/mc13xxx-regulator-core.c
+++ b/drivers/regulator/mc13xxx-regulator-core.c
@@ -80,20 +80,6 @@ static int mc13xxx_regulator_is_enabled(struct regulator_dev *rdev)
         return (val & mc13xxx_regulators[id].enable_bit) != 0;
 }
 
-int mc13xxx_regulator_list_voltage(struct regulator_dev *rdev,
-                                                unsigned selector)
-{
-        int id = rdev_get_id(rdev);
-        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
-        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
-
-        if (selector >= mc13xxx_regulators[id].desc.n_voltages)
-                return -EINVAL;
-
-        return mc13xxx_regulators[id].voltages[selector];
-}
-EXPORT_SYMBOL_GPL(mc13xxx_regulator_list_voltage);
-
 static int mc13xxx_regulator_set_voltage_sel(struct regulator_dev *rdev,
                                              unsigned selector)
 {
@@ -135,14 +121,14 @@ static int mc13xxx_regulator_get_voltage(struct regulator_dev *rdev)
 
         BUG_ON(val >= mc13xxx_regulators[id].desc.n_voltages);
 
-        return mc13xxx_regulators[id].voltages[val];
+        return rdev->desc->volt_table[val];
 }
 
 struct regulator_ops mc13xxx_regulator_ops = {
         .enable = mc13xxx_regulator_enable,
         .disable = mc13xxx_regulator_disable,
         .is_enabled = mc13xxx_regulator_is_enabled,
-        .list_voltage = mc13xxx_regulator_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage_sel = mc13xxx_regulator_set_voltage_sel,
         .get_voltage = mc13xxx_regulator_get_voltage,
 };
@@ -151,15 +137,13 @@ EXPORT_SYMBOL_GPL(mc13xxx_regulator_ops);
 int mc13xxx_fixed_regulator_set_voltage(struct regulator_dev *rdev, int min_uV,
                int max_uV, unsigned *selector)
 {
-        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
-        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
         int id = rdev_get_id(rdev);
 
         dev_dbg(rdev_get_dev(rdev), "%s id: %d min_uV: %d max_uV: %d\n",
                 __func__, id, min_uV, max_uV);
 
-        if (min_uV >= mc13xxx_regulators[id].voltages[0] &&
-            max_uV <= mc13xxx_regulators[id].voltages[0])
+        if (min_uV <= rdev->desc->volt_table[0] &&
+            rdev->desc->volt_table[0] <= max_uV)
                 return 0;
         else
                 return -EINVAL;
@@ -168,13 +152,11 @@ EXPORT_SYMBOL_GPL(mc13xxx_fixed_regulator_set_voltage);
 
 int mc13xxx_fixed_regulator_get_voltage(struct regulator_dev *rdev)
 {
-        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
-        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
         int id = rdev_get_id(rdev);
 
         dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
 
-        return mc13xxx_regulators[id].voltages[0];
+        return rdev->desc->volt_table[0];
 }
 EXPORT_SYMBOL_GPL(mc13xxx_fixed_regulator_get_voltage);
 
@@ -182,18 +164,12 @@ struct regulator_ops mc13xxx_fixed_regulator_ops = {
         .enable = mc13xxx_regulator_enable,
         .disable = mc13xxx_regulator_disable,
         .is_enabled = mc13xxx_regulator_is_enabled,
-        .list_voltage = mc13xxx_regulator_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage = mc13xxx_fixed_regulator_set_voltage,
         .get_voltage = mc13xxx_fixed_regulator_get_voltage,
 };
 EXPORT_SYMBOL_GPL(mc13xxx_fixed_regulator_ops);
 
-int mc13xxx_sw_regulator_is_enabled(struct regulator_dev *rdev)
-{
-        return 1;
-}
-EXPORT_SYMBOL_GPL(mc13xxx_sw_regulator_is_enabled);
-
 #ifdef CONFIG_OF
 int __devinit mc13xxx_get_num_regulators_dt(struct platform_device *pdev)
 {
diff --git a/drivers/regulator/mc13xxx.h b/drivers/regulator/mc13xxx.h
index 044aba4d28ec..eaff5510b6df 100644
--- a/drivers/regulator/mc13xxx.h
+++ b/drivers/regulator/mc13xxx.h
@@ -22,7 +22,6 @@ struct mc13xxx_regulator {
         int vsel_shift;
         int vsel_mask;
         int hi_bit;
-        int const *voltages;
 };
 
 struct mc13xxx_regulator_priv {
@@ -33,10 +32,6 @@ struct mc13xxx_regulator_priv {
         struct regulator_dev *regulators[];
 };
 
-extern int mc13xxx_sw_regulator(struct regulator_dev *rdev);
-extern int mc13xxx_sw_regulator_is_enabled(struct regulator_dev *rdev);
-extern int mc13xxx_regulator_list_voltage(struct regulator_dev *rdev,
-                                                unsigned selector);
 extern int mc13xxx_fixed_regulator_set_voltage(struct regulator_dev *rdev,
                 int min_uV, int max_uV, unsigned *selector);
 extern int mc13xxx_fixed_regulator_get_voltage(struct regulator_dev *rdev);
@@ -68,6 +63,7 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 .desc = {                                               \
                         .name = #_name,                                 \
                         .n_voltages = ARRAY_SIZE(_voltages),            \
+                        .volt_table =  _voltages,                       \
                         .ops = &_ops,                   \
                         .type = REGULATOR_VOLTAGE,                      \
                         .id = prefix ## _name,          \
@@ -78,7 +74,6 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 .vsel_reg = prefix ## _vsel_reg,                        \
                 .vsel_shift = prefix ## _vsel_reg ## _ ## _name ## VSEL,\
                 .vsel_mask = prefix ## _vsel_reg ## _ ## _name ## VSEL_M,\
-                .voltages =  _voltages,                                 \
         }
 
 #define MC13xxx_FIXED_DEFINE(prefix, _name, _reg, _voltages, _ops)      \
@@ -86,6 +81,7 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 .desc = {                                               \
                         .name = #_name,                                 \
                         .n_voltages = ARRAY_SIZE(_voltages),            \
+                        .volt_table =  _voltages,                       \
                         .ops = &_ops,           \
                         .type = REGULATOR_VOLTAGE,                      \
                         .id = prefix ## _name,          \
@@ -93,7 +89,6 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 },                                                      \
                 .reg = prefix ## _reg,                          \
                 .enable_bit = prefix ## _reg ## _ ## _name ## EN,       \
-                .voltages =  _voltages,                                 \
         }
 
 #define MC13xxx_GPO_DEFINE(prefix, _name, _reg,  _voltages, _ops)       \
@@ -101,6 +96,7 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 .desc = {                                               \
                         .name = #_name,                                 \
                         .n_voltages = ARRAY_SIZE(_voltages),            \
+                        .volt_table =  _voltages,                       \
                         .ops = &_ops,           \
                         .type = REGULATOR_VOLTAGE,                      \
                         .id = prefix ## _name,          \
@@ -108,7 +104,6 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 },                                                      \
                 .reg = prefix ## _reg,                          \
                 .enable_bit = prefix ## _reg ## _ ## _name ## EN,       \
-                .voltages =  _voltages,                                 \
         }
 
 #define MC13xxx_DEFINE_SW(_name, _reg, _vsel_reg, _voltages, ops)       \
diff --git a/drivers/regulator/of_regulator.c b/drivers/regulator/of_regulator.c
index 56593b75168a..3e4106f2bda9 100644
--- a/drivers/regulator/of_regulator.c
+++ b/drivers/regulator/of_regulator.c
@@ -20,7 +20,7 @@ static void of_get_regulation_constraints(struct device_node *np,
                                         struct regulator_init_data **init_data)
 {
         const __be32 *min_uV, *max_uV, *uV_offset;
-        const __be32 *min_uA, *max_uA;
+        const __be32 *min_uA, *max_uA, *ramp_delay;
         struct regulation_constraints *constraints = &(*init_data)->constraints;
 
         constraints->name = of_get_property(np, "regulator-name", NULL);
@@ -60,6 +60,10 @@ static void of_get_regulation_constraints(struct device_node *np,
                 constraints->always_on = true;
         else /* status change should be possible if not always on. */
                 constraints->valid_ops_mask |= REGULATOR_CHANGE_STATUS;
+
+        ramp_delay = of_get_property(np, "regulator-ramp-delay", NULL);
+        if (ramp_delay)
+                constraints->ramp_delay = be32_to_cpu(*ramp_delay);
 }
 
 /**
@@ -88,15 +92,17 @@ struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
 EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
 
 /**
- * of_regulator_match - extract regulator init data
+ * of_regulator_match - extract regulator init data when node
+ * property "regulator-compatible" matches with the regulator name.
  * @dev: device requesting the data
  * @node: parent device node of the regulators
  * @matches: match table for the regulators
  * @num_matches: number of entries in match table
  *
  * This function uses a match table specified by the regulator driver and
- * looks up the corresponding init data in the device tree. Note that the
- * match table is modified in place.
+ * looks up the corresponding init data in the device tree  if
+ * regulator-compatible matches. Note that the match table is modified
+ * in place.
  *
  * Returns the number of matches found or a negative error code on failure.
  */
@@ -106,27 +112,40 @@ int of_regulator_match(struct device *dev, struct device_node *node,
 {
         unsigned int count = 0;
         unsigned int i;
+        const char *regulator_comp;
+        struct device_node *child;
 
         if (!dev || !node)
                 return -EINVAL;
 
-        for (i = 0; i < num_matches; i++) {
-                struct of_regulator_match *match = &matches[i];
-                struct device_node *child;
-
-                child = of_find_node_by_name(node, match->name);
-                if (!child)
-                        continue;
-
-                match->init_data = of_get_regulator_init_data(dev, child);
-                if (!match->init_data) {
-                        dev_err(dev, "failed to parse DT for regulator %s\n",
+        for_each_child_of_node(node, child) {
+                regulator_comp = of_get_property(child,
+                                        "regulator-compatible", NULL);
+                if (!regulator_comp) {
+                        dev_err(dev, "regulator-compatible is missing for node %s\n",
                                 child->name);
-                        return -EINVAL;
+                        continue;
+                }
+                for (i = 0; i < num_matches; i++) {
+                        struct of_regulator_match *match = &matches[i];
+                        if (match->of_node)
+                                continue;
+
+                        if (strcmp(match->name, regulator_comp))
+                                continue;
+
+                        match->init_data =
+                                of_get_regulator_init_data(dev, child);
+                        if (!match->init_data) {
+                                dev_err(dev,
+                                        "failed to parse DT for regulator %s\n",
+                                        child->name);
+                                return -EINVAL;
+                        }
+                        match->of_node = child;
+                        count++;
+                        break;
                 }
-
-                match->of_node = child;
-                count++;
         }
 
         return count;
diff --git a/drivers/regulator/palmas-regulator.c b/drivers/regulator/palmas-regulator.c
index 795f75a6ac33..17d19fbbc490 100644
--- a/drivers/regulator/palmas-regulator.c
+++ b/drivers/regulator/palmas-regulator.c
@@ -257,8 +257,7 @@ static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode)
         unsigned int reg;
 
         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
-        reg &= ~PALMAS_SMPS12_CTRL_STATUS_MASK;
-        reg >>= PALMAS_SMPS12_CTRL_STATUS_SHIFT;
+        reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 
         switch (mode) {
         case REGULATOR_MODE_NORMAL:
@@ -374,11 +373,22 @@ static int palmas_set_voltage_smps_sel(struct regulator_dev *dev,
 static int palmas_map_voltage_smps(struct regulator_dev *rdev,
                 int min_uV, int max_uV)
 {
+        struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
+        int id = rdev_get_id(rdev);
         int ret, voltage;
 
-        ret = ((min_uV - 500000) / 10000) + 1;
-        if (ret < 0)
-                return ret;
+        if (min_uV == 0)
+                return 0;
+
+        if (pmic->range[id]) { /* RANGE is x2 */
+                if (min_uV < 1000000)
+                        min_uV = 1000000;
+                ret = DIV_ROUND_UP(min_uV - 1000000, 20000) + 1;
+        } else {                /* RANGE is x1 */
+                if (min_uV < 500000)
+                        min_uV = 500000;
+                ret = DIV_ROUND_UP(min_uV - 500000, 10000) + 1;
+        }
 
         /* Map back into a voltage to verify we're still in bounds */
         voltage = palmas_list_voltage_smps(rdev, ret);
@@ -400,19 +410,14 @@ static struct regulator_ops palmas_ops_smps = {
         .map_voltage            = palmas_map_voltage_smps,
 };
 
-static int palmas_list_voltage_smps10(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        return 3750000 + (selector * 1250000);
-}
-
 static struct regulator_ops palmas_ops_smps10 = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
-        .list_voltage           = palmas_list_voltage_smps10,
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
 };
 
 static int palmas_is_enabled_ldo(struct regulator_dev *dev)
@@ -522,7 +527,15 @@ static int palmas_smps_init(struct palmas *palmas, int id,
         if (ret)
                 return ret;
 
-        if (id != PALMAS_REG_SMPS10) {
+        switch (id) {
+        case PALMAS_REG_SMPS10:
+                if (reg_init->mode_sleep) {
+                        reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
+                        reg |= reg_init->mode_sleep <<
+                                        PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
+                }
+                break;
+        default:
                 if (reg_init->warm_reset)
                         reg |= PALMAS_SMPS12_CTRL_WR_S;
 
@@ -534,14 +547,8 @@ static int palmas_smps_init(struct palmas *palmas, int id,
                         reg |= reg_init->mode_sleep <<
                                         PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT;
                 }
-        } else {
-                if (reg_init->mode_sleep) {
-                        reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
-                        reg |= reg_init->mode_sleep <<
-                                        PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
-                }
-
         }
+
         ret = palmas_smps_write(palmas, addr, reg);
         if (ret)
                 return ret;
@@ -665,10 +672,8 @@ static __devinit int palmas_probe(struct platform_device *pdev)
                 pmic->desc[id].name = palmas_regs_info[id].name;
                 pmic->desc[id].id = id;
 
-                if (id != PALMAS_REG_SMPS10) {
-                        pmic->desc[id].ops = &palmas_ops_smps;
-                        pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
-                } else {
+                switch (id) {
+                case PALMAS_REG_SMPS10:
                         pmic->desc[id].n_voltages = PALMAS_SMPS10_NUM_VOLTAGES;
                         pmic->desc[id].ops = &palmas_ops_smps10;
                         pmic->desc[id].vsel_reg = PALMAS_SMPS10_CTRL;
@@ -677,6 +682,12 @@ static __devinit int palmas_probe(struct platform_device *pdev)
                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
                                                         PALMAS_SMPS10_STATUS);
                         pmic->desc[id].enable_mask = SMPS10_BOOST_EN;
+                        pmic->desc[id].min_uV = 3750000;
+                        pmic->desc[id].uV_step = 1250000;
+                        break;
+                default:
+                        pmic->desc[id].ops = &palmas_ops_smps;
+                        pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
                 }
 
                 pmic->desc[id].type = REGULATOR_VOLTAGE;
diff --git a/drivers/regulator/pcap-regulator.c b/drivers/regulator/pcap-regulator.c
index 8211101121f0..68777acc099f 100644
--- a/drivers/regulator/pcap-regulator.c
+++ b/drivers/regulator/pcap-regulator.c
@@ -18,80 +18,80 @@
 #include <linux/regulator/machine.h>
 #include <linux/mfd/ezx-pcap.h>
 
-static const u16 V1_table[] = {
-        2775, 1275, 1600, 1725, 1825, 1925, 2075, 2275,
+static const unsigned int V1_table[] = {
+        2775000, 1275000, 1600000, 1725000, 1825000, 1925000, 2075000, 2275000,
 };
 
-static const u16 V2_table[] = {
-        2500, 2775,
+static const unsigned int V2_table[] = {
+        2500000, 2775000,
 };
 
-static const u16 V3_table[] = {
-        1075, 1275, 1550, 1725, 1876, 1950, 2075, 2275,
+static const unsigned int V3_table[] = {
+        1075000, 1275000, 1550000, 1725000, 1876000, 1950000, 2075000, 2275000,
 };
 
-static const u16 V4_table[] = {
-        1275, 1550, 1725, 1875, 1950, 2075, 2275, 2775,
+static const unsigned int V4_table[] = {
+        1275000, 1550000, 1725000, 1875000, 1950000, 2075000, 2275000, 2775000,
 };
 
-static const u16 V5_table[] = {
-        1875, 2275, 2475, 2775,
+static const unsigned int V5_table[] = {
+        1875000, 2275000, 2475000, 2775000,
 };
 
-static const u16 V6_table[] = {
-        2475, 2775,
+static const unsigned int V6_table[] = {
+        2475000, 2775000,
 };
 
-static const u16 V7_table[] = {
-        1875, 2775,
+static const unsigned int V7_table[] = {
+        1875000, 2775000,
 };
 
 #define V8_table V4_table
 
-static const u16 V9_table[] = {
-        1575, 1875, 2475, 2775,
+static const unsigned int V9_table[] = {
+        1575000, 1875000, 2475000, 2775000,
 };
 
-static const u16 V10_table[] = {
-        5000,
+static const unsigned int V10_table[] = {
+        5000000,
 };
 
-static const u16 VAUX1_table[] = {
-        1875, 2475, 2775, 3000,
+static const unsigned int VAUX1_table[] = {
+        1875000, 2475000, 2775000, 3000000,
 };
 
 #define VAUX2_table VAUX1_table
 
-static const u16 VAUX3_table[] = {
-        1200, 1200, 1200, 1200, 1400, 1600, 1800, 2000,
-        2200, 2400, 2600, 2800, 3000, 3200, 3400, 3600,
+static const unsigned int VAUX3_table[] = {
+        1200000, 1200000, 1200000, 1200000, 1400000, 1600000, 1800000, 2000000,
+        2200000, 2400000, 2600000, 2800000, 3000000, 3200000, 3400000, 3600000,
 };
 
-static const u16 VAUX4_table[] = {
-        1800, 1800, 3000, 5000,
+static const unsigned int VAUX4_table[] = {
+        1800000, 1800000, 3000000, 5000000,
 };
 
-static const u16 VSIM_table[] = {
-        1875, 3000,
+static const unsigned int VSIM_table[] = {
+        1875000, 3000000,
 };
 
-static const u16 VSIM2_table[] = {
-        1875,
+static const unsigned int VSIM2_table[] = {
+        1875000,
 };
 
-static const u16 VVIB_table[] = {
-        1300, 1800, 2000, 3000,
+static const unsigned int VVIB_table[] = {
+        1300000, 1800000, 2000000, 3000000,
 };
 
-static const u16 SW1_table[] = {
-        900, 950, 1000, 1050, 1100, 1150, 1200, 1250,
-        1300, 1350, 1400, 1450, 1500, 1600, 1875, 2250,
+static const unsigned int SW1_table[] = {
+         900000,  950000, 1000000, 1050000, 1100000, 1150000, 1200000, 1250000,
+        1300000, 1350000, 1400000, 1450000, 1500000, 1600000, 1875000, 2250000,
 };
 
 #define SW2_table SW1_table
 
-static const u16 SW3_table[] = {
-        4000, 4500, 5000, 5500,
+static const unsigned int SW3_table[] = {
+        4000000, 4500000, 5000000, 5500000,
 };
 
 struct pcap_regulator {
@@ -100,8 +100,6 @@ struct pcap_regulator {
         const u8 index;
         const u8 stby;
         const u8 lowpwr;
-        const u8 n_voltages;
-        const u16 *voltage_table;
 };
 
 #define NA 0xff
@@ -113,8 +111,6 @@ struct pcap_regulator {
                 .index          = _index,                               \
                 .stby           = _stby,                                \
                 .lowpwr         = _lowpwr,                              \
-                .n_voltages     = ARRAY_SIZE(_vreg##_table),            \
-                .voltage_table  = _vreg##_table,                        \
         }
 
 static struct pcap_regulator vreg_table[] = {
@@ -157,11 +153,11 @@ static int pcap_regulator_set_voltage_sel(struct regulator_dev *rdev,
         void *pcap = rdev_get_drvdata(rdev);
 
         /* the regulator doesn't support voltage switching */
-        if (vreg->n_voltages == 1)
+        if (rdev->desc->n_voltages == 1)
                 return -EINVAL;
 
         return ezx_pcap_set_bits(pcap, vreg->reg,
-                                 (vreg->n_voltages - 1) << vreg->index,
+                                 (rdev->desc->n_voltages - 1) << vreg->index,
                                  selector << vreg->index);
 }
 
@@ -171,11 +167,11 @@ static int pcap_regulator_get_voltage_sel(struct regulator_dev *rdev)
         void *pcap = rdev_get_drvdata(rdev);
         u32 tmp;
 
-        if (vreg->n_voltages == 1)
+        if (rdev->desc->n_voltages == 1)
                 return 0;
 
         ezx_pcap_read(pcap, vreg->reg, &tmp);
-        tmp = ((tmp >> vreg->index) & (vreg->n_voltages - 1));
+        tmp = ((tmp >> vreg->index) & (rdev->desc->n_voltages - 1));
         return tmp;
 }
 
@@ -214,16 +210,8 @@ static int pcap_regulator_is_enabled(struct regulator_dev *rdev)
         return (tmp >> vreg->en) & 1;
 }
 
-static int pcap_regulator_list_voltage(struct regulator_dev *rdev,
-                                                        unsigned int index)
-{
-        struct pcap_regulator *vreg = &vreg_table[rdev_get_id(rdev)];
-
-        return vreg->voltage_table[index] * 1000;
-}
-
 static struct regulator_ops pcap_regulator_ops = {
-        .list_voltage   = pcap_regulator_list_voltage,
+        .list_voltage   = regulator_list_voltage_table,
         .set_voltage_sel = pcap_regulator_set_voltage_sel,
         .get_voltage_sel = pcap_regulator_get_voltage_sel,
         .enable         = pcap_regulator_enable,
@@ -236,6 +224,7 @@ static struct regulator_ops pcap_regulator_ops = {
                 .name           = #_vreg,                       \
                 .id             = _vreg,                        \
                 .n_voltages     = ARRAY_SIZE(_vreg##_table),    \
+                .volt_table     = _vreg##_table,                \
                 .ops            = &pcap_regulator_ops,          \
                 .type           = REGULATOR_VOLTAGE,            \
                 .owner          = THIS_MODULE,                  \
diff --git a/drivers/regulator/pcf50633-regulator.c b/drivers/regulator/pcf50633-regulator.c
index 3c9d14c0017b..092e5cb848a1 100644
--- a/drivers/regulator/pcf50633-regulator.c
+++ b/drivers/regulator/pcf50633-regulator.c
@@ -100,13 +100,12 @@ static unsigned int ldo_voltage_value(u8 bits)
         return 900 + (bits * 100);
 }
 
-static int pcf50633_regulator_set_voltage(struct regulator_dev *rdev,
-                                          int min_uV, int max_uV,
-                                          unsigned *selector)
+static int pcf50633_regulator_map_voltage(struct regulator_dev *rdev,
+                                          int min_uV, int max_uV)
 {
         struct pcf50633 *pcf;
         int regulator_id, millivolts;
-        u8 volt_bits, regnr;
+        u8 volt_bits;
 
         pcf = rdev_get_drvdata(rdev);
 
@@ -116,15 +115,11 @@ static int pcf50633_regulator_set_voltage(struct regulator_dev *rdev,
 
         millivolts = min_uV / 1000;
 
-        regnr = rdev->desc->vsel_reg;
-
         switch (regulator_id) {
         case PCF50633_REGULATOR_AUTO:
                 volt_bits = auto_voltage_bits(millivolts);
                 break;
         case PCF50633_REGULATOR_DOWN1:
-                volt_bits = down_voltage_bits(millivolts);
-                break;
         case PCF50633_REGULATOR_DOWN2:
                 volt_bits = down_voltage_bits(millivolts);
                 break;
@@ -142,9 +137,7 @@ static int pcf50633_regulator_set_voltage(struct regulator_dev *rdev,
                 return -EINVAL;
         }
 
-        *selector = volt_bits;
-
-        return pcf50633_reg_write(pcf, regnr, volt_bits);
+        return volt_bits;
 }
 
 static int pcf50633_regulator_list_voltage(struct regulator_dev *rdev,
@@ -159,8 +152,6 @@ static int pcf50633_regulator_list_voltage(struct regulator_dev *rdev,
                 millivolts = auto_voltage_value(index);
                 break;
         case PCF50633_REGULATOR_DOWN1:
-                millivolts = down_voltage_value(index);
-                break;
         case PCF50633_REGULATOR_DOWN2:
                 millivolts = down_voltage_value(index);
                 break;
@@ -182,9 +173,10 @@ static int pcf50633_regulator_list_voltage(struct regulator_dev *rdev,
 }
 
 static struct regulator_ops pcf50633_regulator_ops = {
-        .set_voltage = pcf50633_regulator_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .list_voltage = pcf50633_regulator_list_voltage,
+        .map_voltage = pcf50633_regulator_map_voltage,
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
         .is_enabled = regulator_is_enabled_regmap,
diff --git a/drivers/regulator/rc5t583-regulator.c b/drivers/regulator/rc5t583-regulator.c
index 1d34e64a1307..8bf4e8c9de9a 100644
--- a/drivers/regulator/rc5t583-regulator.c
+++ b/drivers/regulator/rc5t583-regulator.c
@@ -42,7 +42,6 @@ struct rc5t583_regulator_info {
 
         /* Regulator specific turn-on delay  and voltage settling time*/
         int                     enable_uv_per_us;
-        int                     change_uv_per_us;
 
         /* Used by regulator core */
         struct regulator_desc   desc;
@@ -66,25 +65,6 @@ static int rc5t583_regulator_enable_time(struct regulator_dev *rdev)
         return DIV_ROUND_UP(curr_uV, reg->reg_info->enable_uv_per_us);
 }
 
-static int rc5t583_set_voltage_time_sel(struct regulator_dev *rdev,
-                unsigned int old_selector, unsigned int new_selector)
-{
-        struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
-        int old_uV, new_uV;
-        old_uV = regulator_list_voltage_linear(rdev, old_selector);
-
-        if (old_uV < 0)
-                return old_uV;
-
-        new_uV = regulator_list_voltage_linear(rdev, new_selector);
-        if (new_uV < 0)
-                return new_uV;
-
-        return DIV_ROUND_UP(abs(old_uV - new_uV),
-                                reg->reg_info->change_uv_per_us);
-}
-
-
 static struct regulator_ops rc5t583_ops = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
@@ -94,7 +74,7 @@ static struct regulator_ops rc5t583_ops = {
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .list_voltage           = regulator_list_voltage_linear,
         .map_voltage            = regulator_map_voltage_linear,
-        .set_voltage_time_sel   = rc5t583_set_voltage_time_sel,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 };
 
 #define RC5T583_REG(_id, _en_reg, _en_bit, _disc_reg, _disc_bit, \
@@ -104,7 +84,6 @@ static struct regulator_ops rc5t583_ops = {
         .disc_bit       = _disc_bit,                            \
         .deepsleep_reg  = RC5T583_REG_##_id##DAC_DS,            \
         .enable_uv_per_us = _enable_mv * 1000,                  \
-        .change_uv_per_us = 40 * 1000,                          \
         .deepsleep_id   = RC5T583_DS_##_id,                     \
         .desc = {                                               \
                 .name = "rc5t583-regulator-"#_id,               \
@@ -119,6 +98,7 @@ static struct regulator_ops rc5t583_ops = {
                 .enable_mask = BIT(_en_bit),                    \
                 .min_uV = _min_mv * 1000,                       \
                 .uV_step = _step_uV,                            \
+                .ramp_delay = 40 * 1000,                        \
         },                                                      \
 }
 
diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
new file mode 100644
index 000000000000..4669dc9ac74a
--- /dev/null
+++ b/drivers/regulator/s2mps11.c
@@ -0,0 +1,363 @@
+/*
+ * s2mps11.c
+ *
+ * Copyright (c) 2012 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/bug.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/mfd/samsung/core.h>
+#include <linux/mfd/samsung/s2mps11.h>
+
+struct s2mps11_info {
+        struct regulator_dev **rdev;
+
+        int ramp_delay2;
+        int ramp_delay34;
+        int ramp_delay5;
+        int ramp_delay16;
+        int ramp_delay7810;
+        int ramp_delay9;
+
+        bool buck6_ramp;
+        bool buck2_ramp;
+        bool buck3_ramp;
+        bool buck4_ramp;
+};
+
+static int get_ramp_delay(int ramp_delay)
+{
+        unsigned char cnt = 0;
+
+        ramp_delay /= 6;
+
+        while (true) {
+                ramp_delay = ramp_delay >> 1;
+                if (ramp_delay == 0)
+                        break;
+                cnt++;
+        }
+        return cnt;
+}
+
+static struct regulator_ops s2mps11_ldo_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+};
+
+static struct regulator_ops s2mps11_buck_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+};
+
+#define regulator_desc_ldo1(num)        {               \
+        .name           = "LDO"#num,                    \
+        .id             = S2MPS11_LDO##num,             \
+        .ops            = &s2mps11_ldo_ops,             \
+        .type           = REGULATOR_VOLTAGE,            \
+        .owner          = THIS_MODULE,                  \
+        .min_uV         = S2MPS11_LDO_MIN,              \
+        .uV_step        = S2MPS11_LDO_STEP1,            \
+        .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
+        .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
+        .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
+        .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
+        .enable_mask    = S2MPS11_ENABLE_MASK           \
+}
+#define regulator_desc_ldo2(num)        {               \
+        .name           = "LDO"#num,                    \
+        .id             = S2MPS11_LDO##num,             \
+        .ops            = &s2mps11_ldo_ops,             \
+        .type           = REGULATOR_VOLTAGE,            \
+        .owner          = THIS_MODULE,                  \
+        .min_uV         = S2MPS11_LDO_MIN,              \
+        .uV_step        = S2MPS11_LDO_STEP2,            \
+        .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
+        .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
+        .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
+        .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
+        .enable_mask    = S2MPS11_ENABLE_MASK           \
+}
+
+#define regulator_desc_buck1_4(num)     {                       \
+        .name           = "BUCK"#num,                           \
+        .id             = S2MPS11_BUCK##num,                    \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN1,                    \
+        .uV_step        = S2MPS11_BUCK_STEP1,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B1CTRL2 + (num - 1) * 2,  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B1CTRL1 + (num - 1) * 2,  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck5    {                               \
+        .name           = "BUCK5",                              \
+        .id             = S2MPS11_BUCK5,                        \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN1,                    \
+        .uV_step        = S2MPS11_BUCK_STEP1,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B5CTRL2,                  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B5CTRL1,                  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck6_8(num)     {                       \
+        .name           = "BUCK"#num,                           \
+        .id             = S2MPS11_BUCK##num,                    \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN1,                    \
+        .uV_step        = S2MPS11_BUCK_STEP1,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B6CTRL2 + (num - 6) * 2,  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B6CTRL1 + (num - 6) * 2,  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck9    {                               \
+        .name           = "BUCK9",                              \
+        .id             = S2MPS11_BUCK9,                        \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN3,                    \
+        .uV_step        = S2MPS11_BUCK_STEP3,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B9CTRL2,                  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B9CTRL1,                  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck10   {                               \
+        .name           = "BUCK10",                             \
+        .id             = S2MPS11_BUCK10,                       \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN2,                    \
+        .uV_step        = S2MPS11_BUCK_STEP2,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B9CTRL2,                  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B9CTRL1,                  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+static struct regulator_desc regulators[] = {
+        regulator_desc_ldo2(1),
+        regulator_desc_ldo1(2),
+        regulator_desc_ldo1(3),
+        regulator_desc_ldo1(4),
+        regulator_desc_ldo1(5),
+        regulator_desc_ldo2(6),
+        regulator_desc_ldo1(7),
+        regulator_desc_ldo1(8),
+        regulator_desc_ldo1(9),
+        regulator_desc_ldo1(10),
+        regulator_desc_ldo2(11),
+        regulator_desc_ldo1(12),
+        regulator_desc_ldo1(13),
+        regulator_desc_ldo1(14),
+        regulator_desc_ldo1(15),
+        regulator_desc_ldo1(16),
+        regulator_desc_ldo1(17),
+        regulator_desc_ldo1(18),
+        regulator_desc_ldo1(19),
+        regulator_desc_ldo1(20),
+        regulator_desc_ldo1(21),
+        regulator_desc_ldo2(22),
+        regulator_desc_ldo2(23),
+        regulator_desc_ldo1(24),
+        regulator_desc_ldo1(25),
+        regulator_desc_ldo1(26),
+        regulator_desc_ldo2(27),
+        regulator_desc_ldo1(28),
+        regulator_desc_ldo1(29),
+        regulator_desc_ldo1(30),
+        regulator_desc_ldo1(31),
+        regulator_desc_ldo1(32),
+        regulator_desc_ldo1(33),
+        regulator_desc_ldo1(34),
+        regulator_desc_ldo1(35),
+        regulator_desc_ldo1(36),
+        regulator_desc_ldo1(37),
+        regulator_desc_ldo1(38),
+        regulator_desc_buck1_4(1),
+        regulator_desc_buck1_4(2),
+        regulator_desc_buck1_4(3),
+        regulator_desc_buck1_4(4),
+        regulator_desc_buck5,
+        regulator_desc_buck6_8(6),
+        regulator_desc_buck6_8(7),
+        regulator_desc_buck6_8(8),
+        regulator_desc_buck9,
+        regulator_desc_buck10,
+};
+
+static __devinit int s2mps11_pmic_probe(struct platform_device *pdev)
+{
+        struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        struct sec_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct regulator_config config = { };
+        struct regulator_dev **rdev;
+        struct s2mps11_info *s2mps11;
+        int i, ret, size;
+        unsigned char ramp_enable, ramp_reg = 0;
+
+        if (!pdata) {
+                dev_err(pdev->dev.parent, "Platform data not supplied\n");
+                return -ENODEV;
+        }
+
+        s2mps11 = devm_kzalloc(&pdev->dev, sizeof(struct s2mps11_info),
+                                GFP_KERNEL);
+        if (!s2mps11)
+                return -ENOMEM;
+
+        size = sizeof(struct regulator_dev *) * S2MPS11_REGULATOR_MAX;
+        s2mps11->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
+        if (!s2mps11->rdev) {
+                return -ENOMEM;
+        }
+
+        rdev = s2mps11->rdev;
+        platform_set_drvdata(pdev, s2mps11);
+
+        s2mps11->ramp_delay2 = pdata->buck2_ramp_delay;
+        s2mps11->ramp_delay34 = pdata->buck34_ramp_delay;
+        s2mps11->ramp_delay5 = pdata->buck5_ramp_delay;
+        s2mps11->ramp_delay16 = pdata->buck16_ramp_delay;
+        s2mps11->ramp_delay7810 = pdata->buck7810_ramp_delay;
+        s2mps11->ramp_delay9 = pdata->buck9_ramp_delay;
+
+        s2mps11->buck6_ramp = pdata->buck6_ramp_enable;
+        s2mps11->buck2_ramp = pdata->buck2_ramp_enable;
+        s2mps11->buck3_ramp = pdata->buck3_ramp_enable;
+        s2mps11->buck4_ramp = pdata->buck4_ramp_enable;
+
+        ramp_enable = (s2mps11->buck2_ramp << 3) | (s2mps11->buck3_ramp << 2) |
+                (s2mps11->buck4_ramp << 1) | s2mps11->buck6_ramp ;
+
+        if (ramp_enable) {
+                if (s2mps11->buck2_ramp)
+                        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay2) >> 6;
+                if (s2mps11->buck3_ramp || s2mps11->buck4_ramp)
+                        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay34) >> 4;
+                sec_reg_write(iodev, S2MPS11_REG_RAMP, ramp_reg | ramp_enable);
+        }
+
+        ramp_reg &= 0x00;
+        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay5) >> 6;
+        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay16) >> 4;
+        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay7810) >> 2;
+        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay9);
+        sec_reg_write(iodev, S2MPS11_REG_RAMP_BUCK, ramp_reg);
+
+        for (i = 0; i < S2MPS11_REGULATOR_MAX; i++) {
+
+                config.dev = &pdev->dev;
+                config.regmap = iodev->regmap;
+                config.init_data = pdata->regulators[i].initdata;
+                config.driver_data = s2mps11;
+
+                rdev[i] = regulator_register(&regulators[i], &config);
+                if (IS_ERR(rdev[i])) {
+                        ret = PTR_ERR(rdev[i]);
+                        dev_err(&pdev->dev, "regulator init failed for %d\n",
+                                i);
+                        rdev[i] = NULL;
+                        goto err;
+                }
+        }
+
+        return 0;
+err:
+        for (i = 0; i < S2MPS11_REGULATOR_MAX; i++)
+                if (rdev[i])
+                        regulator_unregister(rdev[i]);
+
+        return ret;
+}
+
+static int __devexit s2mps11_pmic_remove(struct platform_device *pdev)
+{
+        struct s2mps11_info *s2mps11 = platform_get_drvdata(pdev);
+        struct regulator_dev **rdev = s2mps11->rdev;
+        int i;
+
+        for (i = 0; i < S2MPS11_REGULATOR_MAX; i++)
+                if (rdev[i])
+                        regulator_unregister(rdev[i]);
+
+        return 0;
+}
+
+static const struct platform_device_id s2mps11_pmic_id[] = {
+        { "s2mps11-pmic", 0},
+        { },
+};
+MODULE_DEVICE_TABLE(platform, s2mps11_pmic_id);
+
+static struct platform_driver s2mps11_pmic_driver = {
+        .driver = {
+                .name = "s2mps11-pmic",
+                .owner = THIS_MODULE,
+        },
+        .probe = s2mps11_pmic_probe,
+        .remove = __devexit_p(s2mps11_pmic_remove),
+        .id_table = s2mps11_pmic_id,
+};
+
+static int __init s2mps11_pmic_init(void)
+{
+        return platform_driver_register(&s2mps11_pmic_driver);
+}
+subsys_initcall(s2mps11_pmic_init);
+
+static void __exit s2mps11_pmic_exit(void)
+{
+        platform_driver_unregister(&s2mps11_pmic_driver);
+}
+module_exit(s2mps11_pmic_exit);
+
+/* Module information */
+MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
+MODULE_DESCRIPTION("SAMSUNG S2MPS11 Regulator Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/s5m8767.c b/drivers/regulator/s5m8767.c
index 9caadb482178..102287fa7ecb 100644
--- a/drivers/regulator/s5m8767.c
+++ b/drivers/regulator/s5m8767.c
@@ -41,6 +41,7 @@ struct s5m8767_info {
         u8 buck3_vol[8];
         u8 buck4_vol[8];
         int buck_gpios[3];
+        int buck_ds[3];
         int buck_gpioindex;
 };
 
@@ -120,27 +121,6 @@ static const struct s5m_voltage_desc *reg_voltage_map[] = {
         [S5M8767_BUCK9] = &buck_voltage_val3,
 };
 
-static int s5m8767_list_voltage(struct regulator_dev *rdev,
-                                unsigned int selector)
-{
-        const struct s5m_voltage_desc *desc;
-        int reg_id = rdev_get_id(rdev);
-        int val;
-
-        if (reg_id >= ARRAY_SIZE(reg_voltage_map) || reg_id < 0)
-                return -EINVAL;
-
-        desc = reg_voltage_map[reg_id];
-        if (desc == NULL)
-                return -EINVAL;
-
-        val = desc->min + desc->step * selector;
-        if (val > desc->max)
-                return -EINVAL;
-
-        return val;
-}
-
 static unsigned int s5m8767_opmode_reg[][4] = {
         /* {OFF, ON, LOWPOWER, SUSPEND} */
         /* LDO1 ... LDO28 */
@@ -283,17 +263,17 @@ static int s5m8767_get_voltage_register(struct regulator_dev *rdev, int *_reg)
                 reg = S5M8767_REG_BUCK1CTRL2;
                 break;
         case S5M8767_BUCK2:
-                reg = S5M8767_REG_BUCK2DVS1;
+                reg = S5M8767_REG_BUCK2DVS2;
                 if (s5m8767->buck2_gpiodvs)
                         reg += s5m8767->buck_gpioindex;
                 break;
         case S5M8767_BUCK3:
-                reg = S5M8767_REG_BUCK3DVS1;
+                reg = S5M8767_REG_BUCK3DVS2;
                 if (s5m8767->buck3_gpiodvs)
                         reg += s5m8767->buck_gpioindex;
                 break;
         case S5M8767_BUCK4:
-                reg = S5M8767_REG_BUCK4DVS1;
+                reg = S5M8767_REG_BUCK4DVS2;
                 if (s5m8767->buck4_gpiodvs)
                         reg += s5m8767->buck_gpioindex;
                 break;
@@ -357,32 +337,34 @@ static int s5m8767_convert_voltage_to_sel(
         return selector;
 }
 
-static inline void s5m8767_set_high(struct s5m8767_info *s5m8767)
+static inline int s5m8767_set_high(struct s5m8767_info *s5m8767)
 {
         int temp_index = s5m8767->buck_gpioindex;
 
         gpio_set_value(s5m8767->buck_gpios[0], (temp_index >> 2) & 0x1);
         gpio_set_value(s5m8767->buck_gpios[1], (temp_index >> 1) & 0x1);
         gpio_set_value(s5m8767->buck_gpios[2], temp_index & 0x1);
+
+        return 0;
 }
 
-static inline void s5m8767_set_low(struct s5m8767_info *s5m8767)
+static inline int s5m8767_set_low(struct s5m8767_info *s5m8767)
 {
         int temp_index = s5m8767->buck_gpioindex;
 
         gpio_set_value(s5m8767->buck_gpios[2], temp_index & 0x1);
         gpio_set_value(s5m8767->buck_gpios[1], (temp_index >> 1) & 0x1);
         gpio_set_value(s5m8767->buck_gpios[0], (temp_index >> 2) & 0x1);
+
+        return 0;
 }
 
-static int s5m8767_set_voltage(struct regulator_dev *rdev,
-                                int min_uV, int max_uV, unsigned *selector)
+static int s5m8767_set_voltage_sel(struct regulator_dev *rdev,
+                                   unsigned selector)
 {
         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
-        const struct s5m_voltage_desc *desc;
         int reg_id = rdev_get_id(rdev);
-        int sel, reg, mask, ret = 0, old_index, index = 0;
-        u8 val;
+        int reg, mask, ret = 0, old_index, index = 0;
         u8 *buck234_vol = NULL;
 
         switch (reg_id) {
@@ -407,15 +389,9 @@ static int s5m8767_set_voltage(struct regulator_dev *rdev,
                 return -EINVAL;
         }
 
-        desc = reg_voltage_map[reg_id];
-
-        sel = s5m8767_convert_voltage_to_sel(desc, min_uV, max_uV);
-        if (sel < 0)
-                return sel;
-
         /* buck234_vol != NULL means to control buck234 voltage via DVS GPIO */
         if (buck234_vol) {
-                while (*buck234_vol != sel) {
+                while (*buck234_vol != selector) {
                         buck234_vol++;
                         index++;
                 }
@@ -423,22 +399,16 @@ static int s5m8767_set_voltage(struct regulator_dev *rdev,
                 s5m8767->buck_gpioindex = index;
 
                 if (index > old_index)
-                        s5m8767_set_high(s5m8767);
+                        return s5m8767_set_high(s5m8767);
                 else
-                        s5m8767_set_low(s5m8767);
+                        return s5m8767_set_low(s5m8767);
         } else {
                 ret = s5m8767_get_voltage_register(rdev, &reg);
                 if (ret)
                         return ret;
 
-                s5m_reg_read(s5m8767->iodev, reg, &val);
-                val = (val & ~mask) | sel;
-
-                ret = s5m_reg_write(s5m8767->iodev, reg, val);
+                return s5m_reg_update(s5m8767->iodev, reg, selector, mask);
         }
-
-        *selector = sel;
-        return ret;
 }
 
 static int s5m8767_set_voltage_time_sel(struct regulator_dev *rdev,
@@ -458,15 +428,21 @@ static int s5m8767_set_voltage_time_sel(struct regulator_dev *rdev,
 }
 
 static struct regulator_ops s5m8767_ops = {
-        .list_voltage           = s5m8767_list_voltage,
+        .list_voltage           = regulator_list_voltage_linear,
         .is_enabled             = s5m8767_reg_is_enabled,
         .enable                 = s5m8767_reg_enable,
         .disable                = s5m8767_reg_disable,
         .get_voltage_sel        = s5m8767_get_voltage_sel,
-        .set_voltage            = s5m8767_set_voltage,
+        .set_voltage_sel        = s5m8767_set_voltage_sel,
         .set_voltage_time_sel   = s5m8767_set_voltage_time_sel,
 };
 
+static struct regulator_ops s5m8767_buck78_ops = {
+        .is_enabled             = s5m8767_reg_is_enabled,
+        .enable                 = s5m8767_reg_enable,
+        .disable                = s5m8767_reg_disable,
+};
+
 #define s5m8767_regulator_desc(_name) {         \
         .name           = #_name,               \
         .id             = S5M8767_##_name,      \
@@ -475,6 +451,14 @@ static struct regulator_ops s5m8767_ops = {
         .owner          = THIS_MODULE,          \
 }
 
+#define s5m8767_regulator_buck78_desc(_name) {  \
+        .name           = #_name,               \
+        .id             = S5M8767_##_name,      \
+        .ops            = &s5m8767_buck78_ops,  \
+        .type           = REGULATOR_VOLTAGE,    \
+        .owner          = THIS_MODULE,          \
+}
+
 static struct regulator_desc regulators[] = {
         s5m8767_regulator_desc(LDO1),
         s5m8767_regulator_desc(LDO2),
@@ -510,8 +494,8 @@ static struct regulator_desc regulators[] = {
         s5m8767_regulator_desc(BUCK4),
         s5m8767_regulator_desc(BUCK5),
         s5m8767_regulator_desc(BUCK6),
-        s5m8767_regulator_desc(BUCK7),
-        s5m8767_regulator_desc(BUCK8),
+        s5m8767_regulator_buck78_desc(BUCK7),
+        s5m8767_regulator_buck78_desc(BUCK8),
         s5m8767_regulator_desc(BUCK9),
 };
 
@@ -522,7 +506,7 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
         struct regulator_config config = { };
         struct regulator_dev **rdev;
         struct s5m8767_info *s5m8767;
-        int i, ret, size;
+        int i, ret, size, buck_init;
 
         if (!pdata) {
                 dev_err(pdev->dev.parent, "Platform data not supplied\n");
@@ -573,12 +557,37 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
         s5m8767->buck_gpios[0] = pdata->buck_gpios[0];
         s5m8767->buck_gpios[1] = pdata->buck_gpios[1];
         s5m8767->buck_gpios[2] = pdata->buck_gpios[2];
+        s5m8767->buck_ds[0] = pdata->buck_ds[0];
+        s5m8767->buck_ds[1] = pdata->buck_ds[1];
+        s5m8767->buck_ds[2] = pdata->buck_ds[2];
+
         s5m8767->ramp_delay = pdata->buck_ramp_delay;
         s5m8767->buck2_ramp = pdata->buck2_ramp_enable;
         s5m8767->buck3_ramp = pdata->buck3_ramp_enable;
         s5m8767->buck4_ramp = pdata->buck4_ramp_enable;
         s5m8767->opmode = pdata->opmode;
 
+        buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2,
+                                                pdata->buck2_init,
+                                                pdata->buck2_init +
+                                                buck_voltage_val2.step);
+
+        s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK2DVS2, buck_init);
+
+        buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2,
+                                                pdata->buck3_init,
+                                                pdata->buck3_init +
+                                                buck_voltage_val2.step);
+
+        s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK3DVS2, buck_init);
+
+        buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2,
+                                                pdata->buck4_init,
+                                                pdata->buck4_init +
+                                                buck_voltage_val2.step);
+
+        s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK4DVS2, buck_init);
+
         for (i = 0; i < 8; i++) {
                 if (s5m8767->buck2_gpiodvs) {
                         s5m8767->buck2_vol[i] =
@@ -608,48 +617,70 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
                 }
         }
 
-        if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs ||
-                pdata->buck4_gpiodvs) {
-                if (gpio_is_valid(pdata->buck_gpios[0]) &&
-                        gpio_is_valid(pdata->buck_gpios[1]) &&
-                        gpio_is_valid(pdata->buck_gpios[2])) {
-                        ret = gpio_request(pdata->buck_gpios[0],
-                                                "S5M8767 SET1");
-                        if (ret == -EBUSY)
-                                dev_warn(&pdev->dev, "Duplicated gpio request for SET1\n");
-
-                        ret = gpio_request(pdata->buck_gpios[1],
-                                           "S5M8767 SET2");
-                        if (ret == -EBUSY)
-                                dev_warn(&pdev->dev, "Duplicated gpio request for SET2\n");
-
-                        ret = gpio_request(pdata->buck_gpios[2],
-                                           "S5M8767 SET3");
-                        if (ret == -EBUSY)
-                                dev_warn(&pdev->dev, "Duplicated gpio request for SET3\n");
-                        /* SET1 GPIO */
-                        gpio_direction_output(pdata->buck_gpios[0],
-                                        (s5m8767->buck_gpioindex >> 2) & 0x1);
-                        /* SET2 GPIO */
-                        gpio_direction_output(pdata->buck_gpios[1],
-                                        (s5m8767->buck_gpioindex >> 1) & 0x1);
-                        /* SET3 GPIO */
-                        gpio_direction_output(pdata->buck_gpios[2],
-                                        (s5m8767->buck_gpioindex >> 0) & 0x1);
-                        ret = 0;
-                } else {
-                        dev_err(&pdev->dev, "GPIO NOT VALID\n");
-                        ret = -EINVAL;
+        if (gpio_is_valid(pdata->buck_gpios[0]) &&
+                gpio_is_valid(pdata->buck_gpios[1]) &&
+                gpio_is_valid(pdata->buck_gpios[2])) {
+                ret = devm_gpio_request(&pdev->dev, pdata->buck_gpios[0],
+                                        "S5M8767 SET1");
+                if (ret)
                         return ret;
-                }
+
+                ret = devm_gpio_request(&pdev->dev, pdata->buck_gpios[1],
+                                        "S5M8767 SET2");
+                if (ret)
+                        return ret;
+
+                ret = devm_gpio_request(&pdev->dev, pdata->buck_gpios[2],
+                                        "S5M8767 SET3");
+                if (ret)
+                        return ret;
+
+                /* SET1 GPIO */
+                gpio_direction_output(pdata->buck_gpios[0],
+                                (s5m8767->buck_gpioindex >> 2) & 0x1);
+                /* SET2 GPIO */
+                gpio_direction_output(pdata->buck_gpios[1],
+                                (s5m8767->buck_gpioindex >> 1) & 0x1);
+                /* SET3 GPIO */
+                gpio_direction_output(pdata->buck_gpios[2],
+                                (s5m8767->buck_gpioindex >> 0) & 0x1);
+        } else {
+                dev_err(&pdev->dev, "GPIO NOT VALID\n");
+                ret = -EINVAL;
+                return ret;
         }
 
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL,
-                        (pdata->buck2_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1);
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL,
-                        (pdata->buck3_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1);
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL,
-                        (pdata->buck4_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1);
+        ret = devm_gpio_request(&pdev->dev, pdata->buck_ds[0], "S5M8767 DS2");
+        if (ret)
+                return ret;
+
+        ret = devm_gpio_request(&pdev->dev, pdata->buck_ds[1], "S5M8767 DS3");
+        if (ret)
+                return ret;
+
+        ret = devm_gpio_request(&pdev->dev, pdata->buck_ds[2], "S5M8767 DS4");
+        if (ret)
+                return ret;
+
+        /* DS2 GPIO */
+        gpio_direction_output(pdata->buck_ds[0], 0x0);
+        /* DS3 GPIO */
+        gpio_direction_output(pdata->buck_ds[1], 0x0);
+        /* DS4 GPIO */
+        gpio_direction_output(pdata->buck_ds[2], 0x0);
+
+        if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs ||
+           pdata->buck4_gpiodvs) {
+                s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL,
+                                (pdata->buck2_gpiodvs) ? (1 << 1) : (0 << 1),
+                                1 << 1);
+                s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL,
+                                (pdata->buck3_gpiodvs) ? (1 << 1) : (0 << 1),
+                                1 << 1);
+                s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL,
+                                (pdata->buck4_gpiodvs) ? (1 << 1) : (0 << 1),
+                                1 << 1);
+        }
 
         /* Initialize GPIO DVS registers */
         for (i = 0; i < 8; i++) {
@@ -668,9 +699,6 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
                                            s5m8767->buck4_vol[i]);
                 }
         }
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL, 0x78, 0xff);
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL, 0x58, 0xff);
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL, 0x78, 0xff);
 
         if (s5m8767->buck2_ramp)
                 s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x08, 0x08);
@@ -684,9 +712,13 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
         if (s5m8767->buck2_ramp || s5m8767->buck3_ramp
                 || s5m8767->buck4_ramp) {
                 switch (s5m8767->ramp_delay) {
-                case 15:
+                case 5:
                         s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
-                                        0xc0, 0xf0);
+                                        0x40, 0xf0);
+                        break;
+                case 10:
+                        s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
+                                        0x90, 0xf0);
                         break;
                 case 25:
                         s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
@@ -711,9 +743,12 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
                 int id = pdata->regulators[i].id;
 
                 desc = reg_voltage_map[id];
-                if (desc)
+                if (desc) {
                         regulators[id].n_voltages =
                                 (desc->max - desc->min) / desc->step + 1;
+                        regulators[id].min_uV = desc->min;
+                        regulators[id].uV_step = desc->step;
+                }
 
                 config.dev = s5m8767->dev;
                 config.init_data = pdata->regulators[i].initdata;
diff --git a/drivers/regulator/tps6105x-regulator.c b/drivers/regulator/tps6105x-regulator.c
index d840d8440a91..1378409efaec 100644
--- a/drivers/regulator/tps6105x-regulator.c
+++ b/drivers/regulator/tps6105x-regulator.c
@@ -20,7 +20,7 @@
 #include <linux/mfd/core.h>
 #include <linux/mfd/tps6105x.h>
 
-static const int tps6105x_voltages[] = {
+static const unsigned int tps6105x_voltages[] = {
         4500000,
         5000000,
         5250000,
@@ -105,22 +105,13 @@ static int tps6105x_regulator_set_voltage_sel(struct regulator_dev *rdev,
         return 0;
 }
 
-static int tps6105x_regulator_list_voltage(struct regulator_dev *rdev,
-                                           unsigned selector)
-{
-        if (selector >= ARRAY_SIZE(tps6105x_voltages))
-                return -EINVAL;
-
-        return tps6105x_voltages[selector];
-}
-
 static struct regulator_ops tps6105x_regulator_ops = {
         .enable         = tps6105x_regulator_enable,
         .disable        = tps6105x_regulator_disable,
         .is_enabled     = tps6105x_regulator_is_enabled,
         .get_voltage_sel = tps6105x_regulator_get_voltage_sel,
         .set_voltage_sel = tps6105x_regulator_set_voltage_sel,
-        .list_voltage   = tps6105x_regulator_list_voltage,
+        .list_voltage   = regulator_list_voltage_table,
 };
 
 static const struct regulator_desc tps6105x_regulator_desc = {
@@ -130,6 +121,7 @@ static const struct regulator_desc tps6105x_regulator_desc = {
         .id             = 0,
         .owner          = THIS_MODULE,
         .n_voltages     = ARRAY_SIZE(tps6105x_voltages),
+        .volt_table     = tps6105x_voltages,
 };
 
 /*
diff --git a/drivers/regulator/tps62360-regulator.c b/drivers/regulator/tps62360-regulator.c
index e534269ed44a..68729a7c8709 100644
--- a/drivers/regulator/tps62360-regulator.c
+++ b/drivers/regulator/tps62360-regulator.c
@@ -65,10 +65,8 @@ struct tps62360_chip {
         struct regulator_desc desc;
         struct regulator_dev *rdev;
         struct regmap *regmap;
-        int chip_id;
         int vsel0_gpio;
         int vsel1_gpio;
-        int voltage_base;
         u8 voltage_reg_mask;
         bool en_internal_pulldn;
         bool en_discharge;
@@ -76,7 +74,6 @@ struct tps62360_chip {
         int lru_index[4];
         int curr_vset_vsel[4];
         int curr_vset_id;
-        int change_uv_per_us;
 };
 
 /*
@@ -175,23 +172,6 @@ static int tps62360_dcdc_set_voltage_sel(struct regulator_dev *dev,
         return 0;
 }
 
-static int tps62360_set_voltage_time_sel(struct regulator_dev *rdev,
-                unsigned int old_selector, unsigned int new_selector)
-{
-        struct tps62360_chip *tps = rdev_get_drvdata(rdev);
-        int old_uV, new_uV;
-
-        old_uV = regulator_list_voltage_linear(rdev, old_selector);
-        if (old_uV < 0)
-                return old_uV;
-
-        new_uV = regulator_list_voltage_linear(rdev, new_selector);
-        if (new_uV < 0)
-                return new_uV;
-
-        return DIV_ROUND_UP(abs(old_uV - new_uV), tps->change_uv_per_us);
-}
-
 static int tps62360_set_mode(struct regulator_dev *rdev, unsigned int mode)
 {
         struct tps62360_chip *tps = rdev_get_drvdata(rdev);
@@ -258,7 +238,7 @@ static struct regulator_ops tps62360_dcdc_ops = {
         .set_voltage_sel        = tps62360_dcdc_set_voltage_sel,
         .list_voltage           = regulator_list_voltage_linear,
         .map_voltage            = regulator_map_voltage_linear,
-        .set_voltage_time_sel   = tps62360_set_voltage_time_sel,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
         .set_mode               = tps62360_set_mode,
         .get_mode               = tps62360_get_mode,
 };
@@ -301,7 +281,7 @@ static int __devinit tps62360_init_dcdc(struct tps62360_chip *tps,
         ramp_ctrl = (ramp_ctrl >> 4) & 0x7;
 
         /* ramp mV/us = 32/(2^ramp_ctrl) */
-        tps->change_uv_per_us = DIV_ROUND_UP(32000, BIT(ramp_ctrl));
+        tps->desc.ramp_delay = DIV_ROUND_UP(32000, BIT(ramp_ctrl));
         return ret;
 }
 
@@ -408,13 +388,13 @@ static int __devinit tps62360_probe(struct i2c_client *client,
         switch (chip_id) {
         case TPS62360:
         case TPS62362:
-                tps->voltage_base = TPS62360_BASE_VOLTAGE;
+                tps->desc.min_uV = TPS62360_BASE_VOLTAGE;
                 tps->voltage_reg_mask = 0x3F;
                 tps->desc.n_voltages = TPS62360_N_VOLTAGES;
                 break;
         case TPS62361:
         case TPS62363:
-                tps->voltage_base = TPS62361_BASE_VOLTAGE;
+                tps->desc.min_uV = TPS62361_BASE_VOLTAGE;
                 tps->voltage_reg_mask = 0x7F;
                 tps->desc.n_voltages = TPS62361_N_VOLTAGES;
                 break;
@@ -427,7 +407,6 @@ static int __devinit tps62360_probe(struct i2c_client *client,
         tps->desc.ops = &tps62360_dcdc_ops;
         tps->desc.type = REGULATOR_VOLTAGE;
         tps->desc.owner = THIS_MODULE;
-        tps->desc.min_uV = tps->voltage_base;
         tps->desc.uV_step = 10000;
 
         tps->regmap = devm_regmap_init_i2c(client, &tps62360_regmap_config);
@@ -449,24 +428,24 @@ static int __devinit tps62360_probe(struct i2c_client *client,
                 int gpio_flags;
                 gpio_flags = (pdata->vsel0_def_state) ?
                                 GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
-                ret = gpio_request_one(tps->vsel0_gpio,
+                ret = devm_gpio_request_one(&client->dev, tps->vsel0_gpio,
                                 gpio_flags, "tps62360-vsel0");
                 if (ret) {
                         dev_err(&client->dev,
                                 "%s(): Could not obtain vsel0 GPIO %d: %d\n",
                                 __func__, tps->vsel0_gpio, ret);
-                        goto err_gpio0;
+                        return ret;
                 }
 
                 gpio_flags = (pdata->vsel1_def_state) ?
                                 GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
-                ret = gpio_request_one(tps->vsel1_gpio,
+                ret = devm_gpio_request_one(&client->dev, tps->vsel1_gpio,
                                 gpio_flags, "tps62360-vsel1");
                 if (ret) {
                         dev_err(&client->dev,
                                 "%s(): Could not obtain vsel1 GPIO %d: %d\n",
                                 __func__, tps->vsel1_gpio, ret);
-                        goto err_gpio1;
+                        return ret;
                 }
                 tps->valid_gpios = true;
 
@@ -484,7 +463,7 @@ static int __devinit tps62360_probe(struct i2c_client *client,
         if (ret < 0) {
                 dev_err(tps->dev, "%s(): Init failed with err = %d\n",
                                 __func__, ret);
-                goto err_init;
+                return ret;
         }
 
         config.dev = &client->dev;
@@ -498,21 +477,11 @@ static int __devinit tps62360_probe(struct i2c_client *client,
                 dev_err(tps->dev,
                         "%s(): regulator register failed with err %s\n",
                         __func__, id->name);
-                ret = PTR_ERR(rdev);
-                goto err_init;
+                return PTR_ERR(rdev);
         }
 
         tps->rdev = rdev;
         return 0;
-
-err_init:
-        if (gpio_is_valid(tps->vsel1_gpio))
-                gpio_free(tps->vsel1_gpio);
-err_gpio1:
-        if (gpio_is_valid(tps->vsel0_gpio))
-                gpio_free(tps->vsel0_gpio);
-err_gpio0:
-        return ret;
 }
 
 /**
@@ -525,12 +494,6 @@ static int __devexit tps62360_remove(struct i2c_client *client)
 {
         struct tps62360_chip *tps = i2c_get_clientdata(client);
 
-        if (gpio_is_valid(tps->vsel1_gpio))
-                gpio_free(tps->vsel1_gpio);
-
-        if (gpio_is_valid(tps->vsel0_gpio))
-                gpio_free(tps->vsel0_gpio);
-
         regulator_unregister(tps->rdev);
         return 0;
 }
diff --git a/drivers/regulator/tps65023-regulator.c b/drivers/regulator/tps65023-regulator.c
index 8f1be8586c72..6998d579d07b 100644
--- a/drivers/regulator/tps65023-regulator.c
+++ b/drivers/regulator/tps65023-regulator.c
@@ -69,10 +69,6 @@
 #define TPS65023_REG_CTRL2_DCDC1        BIT(1)
 #define TPS65023_REG_CTRL2_DCDC3        BIT(0)
 
-/* LDO_CTRL bitfields */
-#define TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_id)    ((ldo_id)*4)
-#define TPS65023_LDO_CTRL_LDOx_MASK(ldo_id)     (0x07 << ((ldo_id)*4))
-
 /* Number of step-down converters available */
 #define TPS65023_NUM_DCDC               3
 /* Number of LDO voltage regulators  available */
@@ -91,48 +87,53 @@
 #define TPS65023_MAX_REG_ID             TPS65023_LDO_2
 
 /* Supported voltage values for regulators */
-static const u16 VCORE_VSEL_table[] = {
-        800, 825, 850, 875,
-        900, 925, 950, 975,
-        1000, 1025, 1050, 1075,
-        1100, 1125, 1150, 1175,
-        1200, 1225, 1250, 1275,
-        1300, 1325, 1350, 1375,
-        1400, 1425, 1450, 1475,
-        1500, 1525, 1550, 1600,
+static const unsigned int VCORE_VSEL_table[] = {
+        800000, 825000, 850000, 875000,
+        900000, 925000, 950000, 975000,
+        1000000, 1025000, 1050000, 1075000,
+        1100000, 1125000, 1150000, 1175000,
+        1200000, 1225000, 1250000, 1275000,
+        1300000, 1325000, 1350000, 1375000,
+        1400000, 1425000, 1450000, 1475000,
+        1500000, 1525000, 1550000, 1600000,
+};
+
+static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = {
+        3300000,
+};
+
+static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = {
+        1800000,
 };
 
 /* Supported voltage values for LDO regulators for tps65020 */
-static const u16 TPS65020_LDO1_VSEL_table[] = {
-        1000, 1050, 1100, 1300,
-        1800, 2500, 3000, 3300,
+static const unsigned int TPS65020_LDO1_VSEL_table[] = {
+        1000000, 1050000, 1100000, 1300000,
+        1800000, 2500000, 3000000, 3300000,
 };
 
-static const u16 TPS65020_LDO2_VSEL_table[] = {
-        1000, 1050, 1100, 1300,
-        1800, 2500, 3000, 3300,
+static const unsigned int TPS65020_LDO2_VSEL_table[] = {
+        1000000, 1050000, 1100000, 1300000,
+        1800000, 2500000, 3000000, 3300000,
 };
 
 /* Supported voltage values for LDO regulators
  * for tps65021 and tps65023 */
-static const u16 TPS65023_LDO1_VSEL_table[] = {
-        1000, 1100, 1300, 1800,
-        2200, 2600, 2800, 3150,
+static const unsigned int TPS65023_LDO1_VSEL_table[] = {
+        1000000, 1100000, 1300000, 1800000,
+        2200000, 2600000, 2800000, 3150000,
 };
 
-static const u16 TPS65023_LDO2_VSEL_table[] = {
-        1050, 1200, 1300, 1800,
-        2500, 2800, 3000, 3300,
+static const unsigned int TPS65023_LDO2_VSEL_table[] = {
+        1050000, 1200000, 1300000, 1800000,
+        2500000, 2800000, 3000000, 3300000,
 };
 
 /* Regulator specific details */
 struct tps_info {
         const char *name;
-        unsigned min_uV;
-        unsigned max_uV;
-        bool fixed;
         u8 table_len;
-        const u16 *table;
+        const unsigned int *table;
 };
 
 /* PMIC details */
@@ -150,7 +151,7 @@ struct tps_driver_data {
         u8 core_regulator;
 };
 
-static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
+static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps_pmic *tps = rdev_get_drvdata(dev);
         int ret;
@@ -164,9 +165,9 @@ static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
                 if (ret != 0)
                         return ret;
                 data &= (tps->info[dcdc]->table_len - 1);
-                return tps->info[dcdc]->table[data] * 1000;
+                return data;
         } else
-                return tps->info[dcdc]->min_uV;
+                return 0;
 }
 
 static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
@@ -193,76 +194,14 @@ out:
         return ret;
 }
 
-static int tps65023_ldo_get_voltage(struct regulator_dev *dev)
-{
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
-        int data, ldo = rdev_get_id(dev);
-        int ret;
-
-        if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
-                return -EINVAL;
-
-        ret = regmap_read(tps->regmap, TPS65023_REG_LDO_CTRL, &data);
-        if (ret != 0)
-                return ret;
-
-        data >>= (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1));
-        data &= (tps->info[ldo]->table_len - 1);
-        return tps->info[ldo]->table[data] * 1000;
-}
-
-static int tps65023_ldo_set_voltage_sel(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
-        int ldo_index = rdev_get_id(dev) - TPS65023_LDO_1;
-
-        return regmap_update_bits(tps->regmap, TPS65023_REG_LDO_CTRL,
-                        TPS65023_LDO_CTRL_LDOx_MASK(ldo_index),
-                        selector << TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_index));
-}
-
-static int tps65023_dcdc_list_voltage(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
-        int dcdc = rdev_get_id(dev);
-
-        if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
-                return -EINVAL;
-
-        if (dcdc == tps->core_regulator) {
-                if (selector >= tps->info[dcdc]->table_len)
-                        return -EINVAL;
-                else
-                        return tps->info[dcdc]->table[selector] * 1000;
-        } else
-                return tps->info[dcdc]->min_uV;
-}
-
-static int tps65023_ldo_list_voltage(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
-        int ldo = rdev_get_id(dev);
-
-        if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
-                return -EINVAL;
-
-        if (selector >= tps->info[ldo]->table_len)
-                return -EINVAL;
-        else
-                return tps->info[ldo]->table[selector] * 1000;
-}
-
 /* Operations permitted on VDCDCx */
 static struct regulator_ops tps65023_dcdc_ops = {
         .is_enabled = regulator_is_enabled_regmap,
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
-        .get_voltage = tps65023_dcdc_get_voltage,
+        .get_voltage_sel = tps65023_dcdc_get_voltage_sel,
         .set_voltage_sel = tps65023_dcdc_set_voltage_sel,
-        .list_voltage = tps65023_dcdc_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 /* Operations permitted on LDOx */
@@ -270,9 +209,9 @@ static struct regulator_ops tps65023_ldo_ops = {
         .is_enabled = regulator_is_enabled_regmap,
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
-        .get_voltage = tps65023_ldo_get_voltage,
-        .set_voltage_sel = tps65023_ldo_set_voltage_sel,
-        .list_voltage = tps65023_ldo_list_voltage,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 static struct regmap_config tps65023_regmap_config = {
@@ -325,19 +264,28 @@ static int __devinit tps_65023_probe(struct i2c_client *client,
                 tps->desc[i].name = info->name;
                 tps->desc[i].id = i;
                 tps->desc[i].n_voltages = info->table_len;
+                tps->desc[i].volt_table = info->table;
                 tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
                                         &tps65023_ldo_ops : &tps65023_dcdc_ops);
                 tps->desc[i].type = REGULATOR_VOLTAGE;
                 tps->desc[i].owner = THIS_MODULE;
 
                 tps->desc[i].enable_reg = TPS65023_REG_REG_CTRL;
-                if (i == TPS65023_LDO_1)
+                switch (i) {
+                case TPS65023_LDO_1:
+                        tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL;
+                        tps->desc[i].vsel_mask = 0x07;
                         tps->desc[i].enable_mask = 1 << 1;
-                else if (i == TPS65023_LDO_2)
+                        break;
+                case TPS65023_LDO_2:
+                        tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL;
+                        tps->desc[i].vsel_mask = 0x70;
                         tps->desc[i].enable_mask = 1 << 2;
-                else /* DCDCx */
+                        break;
+                default: /* DCDCx */
                         tps->desc[i].enable_mask =
                                         1 << (TPS65023_NUM_REGULATOR - i);
+                }
 
                 config.dev = &client->dev;
                 config.init_data = init_data;
@@ -384,35 +332,26 @@ static int __devexit tps_65023_remove(struct i2c_client *client)
 static const struct tps_info tps65020_regs[] = {
         {
                 .name = "VDCDC1",
-                .min_uV = 3300000,
-                .max_uV = 3300000,
-                .fixed  = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
+                .table = DCDC_FIXED_3300000_VSEL_table,
         },
         {
                 .name = "VDCDC2",
-                .min_uV =  1800000,
-                .max_uV = 1800000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
+                .table = DCDC_FIXED_1800000_VSEL_table,
         },
         {
                 .name = "VDCDC3",
-                .min_uV =  800000,
-                .max_uV = 1600000,
                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
                 .table = VCORE_VSEL_table,
         },
-
         {
                 .name = "LDO1",
-                .min_uV = 1000000,
-                .max_uV = 3150000,
                 .table_len = ARRAY_SIZE(TPS65020_LDO1_VSEL_table),
                 .table = TPS65020_LDO1_VSEL_table,
         },
         {
                 .name = "LDO2",
-                .min_uV = 1050000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(TPS65020_LDO2_VSEL_table),
                 .table = TPS65020_LDO2_VSEL_table,
         },
@@ -421,34 +360,26 @@ static const struct tps_info tps65020_regs[] = {
 static const struct tps_info tps65021_regs[] = {
         {
                 .name = "VDCDC1",
-                .min_uV =  3300000,
-                .max_uV = 3300000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
+                .table = DCDC_FIXED_3300000_VSEL_table,
         },
         {
                 .name = "VDCDC2",
-                .min_uV =  1800000,
-                .max_uV = 1800000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
+                .table = DCDC_FIXED_1800000_VSEL_table,
         },
         {
                 .name = "VDCDC3",
-                .min_uV =  800000,
-                .max_uV = 1600000,
                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
                 .table = VCORE_VSEL_table,
         },
         {
                 .name = "LDO1",
-                .min_uV = 1000000,
-                .max_uV = 3150000,
                 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
                 .table = TPS65023_LDO1_VSEL_table,
         },
         {
                 .name = "LDO2",
-                .min_uV = 1050000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
                 .table = TPS65023_LDO2_VSEL_table,
         },
@@ -457,34 +388,26 @@ static const struct tps_info tps65021_regs[] = {
 static const struct tps_info tps65023_regs[] = {
         {
                 .name = "VDCDC1",
-                .min_uV =  800000,
-                .max_uV = 1600000,
                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
                 .table = VCORE_VSEL_table,
         },
         {
                 .name = "VDCDC2",
-                .min_uV =  3300000,
-                .max_uV = 3300000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
+                .table = DCDC_FIXED_3300000_VSEL_table,
         },
         {
                 .name = "VDCDC3",
-                .min_uV =  1800000,
-                .max_uV = 1800000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
+                .table = DCDC_FIXED_1800000_VSEL_table,
         },
         {
                 .name = "LDO1",
-                .min_uV = 1000000,
-                .max_uV = 3150000,
                 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
                 .table = TPS65023_LDO1_VSEL_table,
         },
         {
                 .name = "LDO2",
-                .min_uV = 1050000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
                 .table = TPS65023_LDO2_VSEL_table,
         },
diff --git a/drivers/regulator/tps6507x-regulator.c b/drivers/regulator/tps6507x-regulator.c
index da38be1016aa..07d01ccdf308 100644
--- a/drivers/regulator/tps6507x-regulator.c
+++ b/drivers/regulator/tps6507x-regulator.c
@@ -43,58 +43,40 @@
 /* Number of total regulators available */
 #define TPS6507X_NUM_REGULATOR          (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)
 
-/* Supported voltage values for regulators (in milliVolts) */
-static const u16 VDCDCx_VSEL_table[] = {
-        725, 750, 775, 800,
-        825, 850, 875, 900,
-        925, 950, 975, 1000,
-        1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200,
-        1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400,
-        1425, 1450, 1475, 1500,
-        1550, 1600, 1650, 1700,
-        1750, 1800, 1850, 1900,
-        1950, 2000, 2050, 2100,
-        2150, 2200, 2250, 2300,
-        2350, 2400, 2450, 2500,
-        2550, 2600, 2650, 2700,
-        2750, 2800, 2850, 2900,
-        3000, 3100, 3200, 3300,
+/* Supported voltage values for regulators (in microVolts) */
+static const unsigned int VDCDCx_VSEL_table[] = {
+        725000, 750000, 775000, 800000,
+        825000, 850000, 875000, 900000,
+        925000, 950000, 975000, 1000000,
+        1025000, 1050000, 1075000, 1100000,
+        1125000, 1150000, 1175000, 1200000,
+        1225000, 1250000, 1275000, 1300000,
+        1325000, 1350000, 1375000, 1400000,
+        1425000, 1450000, 1475000, 1500000,
+        1550000, 1600000, 1650000, 1700000,
+        1750000, 1800000, 1850000, 1900000,
+        1950000, 2000000, 2050000, 2100000,
+        2150000, 2200000, 2250000, 2300000,
+        2350000, 2400000, 2450000, 2500000,
+        2550000, 2600000, 2650000, 2700000,
+        2750000, 2800000, 2850000, 2900000,
+        3000000, 3100000, 3200000, 3300000,
 };
 
-static const u16 LDO1_VSEL_table[] = {
-        1000, 1100, 1200, 1250,
-        1300, 1350, 1400, 1500,
-        1600, 1800, 2500, 2750,
-        2800, 3000, 3100, 3300,
+static const unsigned int LDO1_VSEL_table[] = {
+        1000000, 1100000, 1200000, 1250000,
+        1300000, 1350000, 1400000, 1500000,
+        1600000, 1800000, 2500000, 2750000,
+        2800000, 3000000, 3100000, 3300000,
 };
 
-static const u16 LDO2_VSEL_table[] = {
-        725, 750, 775, 800,
-        825, 850, 875, 900,
-        925, 950, 975, 1000,
-        1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200,
-        1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400,
-        1425, 1450, 1475, 1500,
-        1550, 1600, 1650, 1700,
-        1750, 1800, 1850, 1900,
-        1950, 2000, 2050, 2100,
-        2150, 2200, 2250, 2300,
-        2350, 2400, 2450, 2500,
-        2550, 2600, 2650, 2700,
-        2750, 2800, 2850, 2900,
-        3000, 3100, 3200, 3300,
-};
+/* The voltage mapping table for LDO2 is the same as VDCDCx */
+#define LDO2_VSEL_table VDCDCx_VSEL_table
 
 struct tps_info {
         const char *name;
-        unsigned min_uV;
-        unsigned max_uV;
         u8 table_len;
-        const u16 *table;
+        const unsigned int *table;
 
         /* Does DCDC high or the low register defines output voltage? */
         bool defdcdc_default;
@@ -103,36 +85,26 @@ struct tps_info {
 static struct tps_info tps6507x_pmic_regs[] = {
         {
                 .name = "VDCDC1",
-                .min_uV = 725000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
                 .table = VDCDCx_VSEL_table,
         },
         {
                 .name = "VDCDC2",
-                .min_uV = 725000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
                 .table = VDCDCx_VSEL_table,
         },
         {
                 .name = "VDCDC3",
-                .min_uV = 725000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
                 .table = VDCDCx_VSEL_table,
         },
         {
                 .name = "LDO1",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(LDO1_VSEL_table),
                 .table = LDO1_VSEL_table,
         },
         {
                 .name = "LDO2",
-                .min_uV = 725000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(LDO2_VSEL_table),
                 .table = LDO2_VSEL_table,
         },
@@ -375,28 +347,13 @@ static int tps6507x_pmic_set_voltage_sel(struct regulator_dev *dev,
         return tps6507x_pmic_reg_write(tps, reg, data);
 }
 
-static int tps6507x_pmic_list_voltage(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
-        int rid = rdev_get_id(dev);
-
-        if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2)
-                return -EINVAL;
-
-        if (selector >= tps->info[rid]->table_len)
-                return -EINVAL;
-        else
-                return tps->info[rid]->table[selector] * 1000;
-}
-
 static struct regulator_ops tps6507x_pmic_ops = {
         .is_enabled = tps6507x_pmic_is_enabled,
         .enable = tps6507x_pmic_enable,
         .disable = tps6507x_pmic_disable,
         .get_voltage_sel = tps6507x_pmic_get_voltage_sel,
         .set_voltage_sel = tps6507x_pmic_set_voltage_sel,
-        .list_voltage = tps6507x_pmic_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 static __devinit int tps6507x_pmic_probe(struct platform_device *pdev)
@@ -449,6 +406,7 @@ static __devinit int tps6507x_pmic_probe(struct platform_device *pdev)
                 tps->desc[i].name = info->name;
                 tps->desc[i].id = i;
                 tps->desc[i].n_voltages = info->table_len;
+                tps->desc[i].volt_table = info->table;
                 tps->desc[i].ops = &tps6507x_pmic_ops;
                 tps->desc[i].type = REGULATOR_VOLTAGE;
                 tps->desc[i].owner = THIS_MODULE;
diff --git a/drivers/regulator/tps65217-regulator.c b/drivers/regulator/tps65217-regulator.c
index 9d371d2cbcae..6caa222af77a 100644
--- a/drivers/regulator/tps65217-regulator.c
+++ b/drivers/regulator/tps65217-regulator.c
@@ -26,7 +26,7 @@
 #include <linux/regulator/machine.h>
 #include <linux/mfd/tps65217.h>
 
-#define TPS65217_REGULATOR(_name, _id, _ops, _n)        \
+#define TPS65217_REGULATOR(_name, _id, _ops, _n, _vr, _vm, _em, _t) \
         {                                               \
                 .name           = _name,                \
                 .id             = _id,                  \
@@ -34,23 +34,23 @@
                 .n_voltages     = _n,                   \
                 .type           = REGULATOR_VOLTAGE,    \
                 .owner          = THIS_MODULE,          \
+                .vsel_reg       = _vr,                  \
+                .vsel_mask      = _vm,                  \
+                .enable_reg     = TPS65217_REG_ENABLE,  \
+                .enable_mask    = _em,                  \
+                .volt_table     = _t,                   \
         }                                               \
 
-#define TPS65217_INFO(_nm, _min, _max, _f1, _f2, _t, _n, _em, _vr, _vm) \
+#define TPS65217_INFO(_nm, _min, _max, _f1, _f2)        \
         {                                               \
                 .name           = _nm,                  \
                 .min_uV         = _min,                 \
                 .max_uV         = _max,                 \
                 .vsel_to_uv     = _f1,                  \
                 .uv_to_vsel     = _f2,                  \
-                .table          = _t,                   \
-                .table_len      = _n,                   \
-                .enable_mask    = _em,                  \
-                .set_vout_reg   = _vr,                  \
-                .set_vout_mask  = _vm,                  \
         }
 
-static const int LDO1_VSEL_table[] = {
+static const unsigned int LDO1_VSEL_table[] = {
         1000000, 1100000, 1200000, 1250000,
         1300000, 1350000, 1400000, 1500000,
         1600000, 1800000, 2500000, 2750000,
@@ -78,7 +78,7 @@ static int tps65217_vsel_to_uv1(unsigned int vsel)
 
 static int tps65217_uv_to_vsel1(int uV, unsigned int *vsel)
 {
-        if ((uV < 0) && (uV > 3300000))
+        if (uV < 0 || uV > 3300000)
                 return -EINVAL;
 
         if (uV <= 1500000)
@@ -112,7 +112,7 @@ static int tps65217_vsel_to_uv2(unsigned int vsel)
 
 static int tps65217_uv_to_vsel2(int uV, unsigned int *vsel)
 {
-        if ((uV < 0) && (uV > 3300000))
+        if (uV < 0 || uV > 3300000)
                 return -EINVAL;
 
         if (uV <= 1900000)
@@ -127,46 +127,20 @@ static int tps65217_uv_to_vsel2(int uV, unsigned int *vsel)
 
 static struct tps_info tps65217_pmic_regs[] = {
         TPS65217_INFO("DCDC1", 900000, 1800000, tps65217_vsel_to_uv1,
-                        tps65217_uv_to_vsel1, NULL, 64, TPS65217_ENABLE_DC1_EN,
-                        TPS65217_REG_DEFDCDC1, TPS65217_DEFDCDCX_DCDC_MASK),
+                        tps65217_uv_to_vsel1),
         TPS65217_INFO("DCDC2", 900000, 3300000, tps65217_vsel_to_uv1,
-                        tps65217_uv_to_vsel1, NULL, 64, TPS65217_ENABLE_DC2_EN,
-                        TPS65217_REG_DEFDCDC2, TPS65217_DEFDCDCX_DCDC_MASK),
+                        tps65217_uv_to_vsel1),
         TPS65217_INFO("DCDC3", 900000, 1500000, tps65217_vsel_to_uv1,
-                        tps65217_uv_to_vsel1, NULL, 64, TPS65217_ENABLE_DC3_EN,
-                        TPS65217_REG_DEFDCDC3, TPS65217_DEFDCDCX_DCDC_MASK),
-        TPS65217_INFO("LDO1", 1000000, 3300000, NULL, NULL, LDO1_VSEL_table,
-                        16, TPS65217_ENABLE_LDO1_EN, TPS65217_REG_DEFLDO1,
-                        TPS65217_DEFLDO1_LDO1_MASK),
+                        tps65217_uv_to_vsel1),
+        TPS65217_INFO("LDO1", 1000000, 3300000, NULL, NULL),
         TPS65217_INFO("LDO2", 900000, 3300000, tps65217_vsel_to_uv1,
-                        tps65217_uv_to_vsel1, NULL, 64, TPS65217_ENABLE_LDO2_EN,
-                        TPS65217_REG_DEFLDO2, TPS65217_DEFLDO2_LDO2_MASK),
+                        tps65217_uv_to_vsel1),
         TPS65217_INFO("LDO3", 1800000, 3300000, tps65217_vsel_to_uv2,
-                        tps65217_uv_to_vsel2, NULL, 32,
-                        TPS65217_ENABLE_LS1_EN | TPS65217_DEFLDO3_LDO3_EN,
-                        TPS65217_REG_DEFLS1, TPS65217_DEFLDO3_LDO3_MASK),
+                        tps65217_uv_to_vsel2),
         TPS65217_INFO("LDO4", 1800000, 3300000, tps65217_vsel_to_uv2,
-                        tps65217_uv_to_vsel2, NULL, 32,
-                        TPS65217_ENABLE_LS2_EN | TPS65217_DEFLDO4_LDO4_EN,
-                        TPS65217_REG_DEFLS2, TPS65217_DEFLDO4_LDO4_MASK),
+                        tps65217_uv_to_vsel2),
 };
 
-static int tps65217_pmic_is_enabled(struct regulator_dev *dev)
-{
-        int ret;
-        struct tps65217 *tps = rdev_get_drvdata(dev);
-        unsigned int data, rid = rdev_get_id(dev);
-
-        if (rid < TPS65217_DCDC_1 || rid > TPS65217_LDO_4)
-                return -EINVAL;
-
-        ret = tps65217_reg_read(tps, TPS65217_REG_ENABLE, &data);
-        if (ret)
-                return ret;
-
-        return (data & tps->info[rid]->enable_mask) ? 1 : 0;
-}
-
 static int tps65217_pmic_enable(struct regulator_dev *dev)
 {
         struct tps65217 *tps = rdev_get_drvdata(dev);
@@ -177,9 +151,8 @@ static int tps65217_pmic_enable(struct regulator_dev *dev)
 
         /* Enable the regulator and password protection is level 1 */
         return tps65217_set_bits(tps, TPS65217_REG_ENABLE,
-                                tps->info[rid]->enable_mask,
-                                tps->info[rid]->enable_mask,
-                                TPS65217_PROTECT_L1);
+                                 dev->desc->enable_mask, dev->desc->enable_mask,
+                                 TPS65217_PROTECT_L1);
 }
 
 static int tps65217_pmic_disable(struct regulator_dev *dev)
@@ -192,25 +165,7 @@ static int tps65217_pmic_disable(struct regulator_dev *dev)
 
         /* Disable the regulator and password protection is level 1 */
         return tps65217_clear_bits(tps, TPS65217_REG_ENABLE,
-                        tps->info[rid]->enable_mask, TPS65217_PROTECT_L1);
-}
-
-static int tps65217_pmic_get_voltage_sel(struct regulator_dev *dev)
-{
-        int ret;
-        struct tps65217 *tps = rdev_get_drvdata(dev);
-        unsigned int selector, rid = rdev_get_id(dev);
-
-        if (rid < TPS65217_DCDC_1 || rid > TPS65217_LDO_4)
-                return -EINVAL;
-
-        ret = tps65217_reg_read(tps, tps->info[rid]->set_vout_reg, &selector);
-        if (ret)
-                return ret;
-
-        selector &= tps->info[rid]->set_vout_mask;
-
-        return selector;
+                                   dev->desc->enable_mask, TPS65217_PROTECT_L1);
 }
 
 static int tps65217_pmic_set_voltage_sel(struct regulator_dev *dev,
@@ -221,8 +176,7 @@ static int tps65217_pmic_set_voltage_sel(struct regulator_dev *dev,
         unsigned int rid = rdev_get_id(dev);
 
         /* Set the voltage based on vsel value and write protect level is 2 */
-        ret = tps65217_set_bits(tps, tps->info[rid]->set_vout_reg,
-                                tps->info[rid]->set_vout_mask,
+        ret = tps65217_set_bits(tps, dev->desc->vsel_reg, dev->desc->vsel_mask,
                                 selector, TPS65217_PROTECT_L2);
 
         /* Set GO bit for DCDCx to initiate voltage transistion */
@@ -252,10 +206,10 @@ static int tps65217_pmic_map_voltage(struct regulator_dev *dev,
         if (rid < TPS65217_DCDC_1 || rid > TPS65217_LDO_4)
                 return -EINVAL;
 
-        if (min_uV < tps->info[rid]->min_uV || min_uV > tps->info[rid]->max_uV)
-                return -EINVAL;
+        if (min_uV < tps->info[rid]->min_uV)
+                min_uV = tps->info[rid]->min_uV;
 
-        if (max_uV < tps->info[rid]->min_uV || max_uV > tps->info[rid]->max_uV)
+        if (max_uV < tps->info[rid]->min_uV || min_uV > tps->info[rid]->max_uV)
                 return -EINVAL;
 
         ret = tps->info[rid]->uv_to_vsel(min_uV, &sel);
@@ -274,21 +228,18 @@ static int tps65217_pmic_list_voltage(struct regulator_dev *dev,
         if (rid < TPS65217_DCDC_1 || rid > TPS65217_LDO_4)
                 return -EINVAL;
 
-        if (selector >= tps->info[rid]->table_len)
+        if (selector >= dev->desc->n_voltages)
                 return -EINVAL;
 
-        if (tps->info[rid]->table)
-                return tps->info[rid]->table[selector];
-
         return tps->info[rid]->vsel_to_uv(selector);
 }
 
 /* Operations permitted on DCDCx, LDO2, LDO3 and LDO4 */
 static struct regulator_ops tps65217_pmic_ops = {
-        .is_enabled             = tps65217_pmic_is_enabled,
+        .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = tps65217_pmic_enable,
         .disable                = tps65217_pmic_disable,
-        .get_voltage_sel        = tps65217_pmic_get_voltage_sel,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = tps65217_pmic_set_voltage_sel,
         .list_voltage           = tps65217_pmic_list_voltage,
         .map_voltage            = tps65217_pmic_map_voltage,
@@ -296,22 +247,38 @@ static struct regulator_ops tps65217_pmic_ops = {
 
 /* Operations permitted on LDO1 */
 static struct regulator_ops tps65217_pmic_ldo1_ops = {
-        .is_enabled             = tps65217_pmic_is_enabled,
+        .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = tps65217_pmic_enable,
         .disable                = tps65217_pmic_disable,
-        .get_voltage_sel        = tps65217_pmic_get_voltage_sel,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = tps65217_pmic_set_voltage_sel,
-        .list_voltage           = tps65217_pmic_list_voltage,
+        .list_voltage           = regulator_list_voltage_table,
 };
 
 static const struct regulator_desc regulators[] = {
-        TPS65217_REGULATOR("DCDC1", TPS65217_DCDC_1, tps65217_pmic_ops, 64),
-        TPS65217_REGULATOR("DCDC2", TPS65217_DCDC_2, tps65217_pmic_ops, 64),
-        TPS65217_REGULATOR("DCDC3", TPS65217_DCDC_3, tps65217_pmic_ops, 64),
-        TPS65217_REGULATOR("LDO1", TPS65217_LDO_1, tps65217_pmic_ldo1_ops, 16),
-        TPS65217_REGULATOR("LDO2", TPS65217_LDO_2, tps65217_pmic_ops, 64),
-        TPS65217_REGULATOR("LDO3", TPS65217_LDO_3, tps65217_pmic_ops, 32),
-        TPS65217_REGULATOR("LDO4", TPS65217_LDO_4, tps65217_pmic_ops, 32),
+        TPS65217_REGULATOR("DCDC1", TPS65217_DCDC_1, tps65217_pmic_ops, 64,
+                           TPS65217_REG_DEFDCDC1, TPS65217_DEFDCDCX_DCDC_MASK,
+                           TPS65217_ENABLE_DC1_EN, NULL),
+        TPS65217_REGULATOR("DCDC2", TPS65217_DCDC_2, tps65217_pmic_ops, 64,
+                           TPS65217_REG_DEFDCDC2, TPS65217_DEFDCDCX_DCDC_MASK,
+                           TPS65217_ENABLE_DC2_EN, NULL),
+        TPS65217_REGULATOR("DCDC3", TPS65217_DCDC_3, tps65217_pmic_ops, 64,
+                           TPS65217_REG_DEFDCDC3, TPS65217_DEFDCDCX_DCDC_MASK,
+                           TPS65217_ENABLE_DC3_EN, NULL),
+        TPS65217_REGULATOR("LDO1", TPS65217_LDO_1, tps65217_pmic_ldo1_ops, 16,
+                           TPS65217_REG_DEFLDO1, TPS65217_DEFLDO1_LDO1_MASK,
+                           TPS65217_ENABLE_LDO1_EN, LDO1_VSEL_table),
+        TPS65217_REGULATOR("LDO2", TPS65217_LDO_2, tps65217_pmic_ops, 64,
+                           TPS65217_REG_DEFLDO2, TPS65217_DEFLDO2_LDO2_MASK,
+                           TPS65217_ENABLE_LDO2_EN, NULL),
+        TPS65217_REGULATOR("LDO3", TPS65217_LDO_3, tps65217_pmic_ops, 32,
+                           TPS65217_REG_DEFLS1, TPS65217_DEFLDO3_LDO3_MASK,
+                           TPS65217_ENABLE_LS1_EN | TPS65217_DEFLDO3_LDO3_EN,
+                           NULL),
+        TPS65217_REGULATOR("LDO4", TPS65217_LDO_4, tps65217_pmic_ops, 32,
+                           TPS65217_REG_DEFLS2, TPS65217_DEFLDO4_LDO4_MASK,
+                           TPS65217_ENABLE_LS2_EN | TPS65217_DEFLDO4_LDO4_EN,
+                           NULL),
 };
 
 static int __devinit tps65217_regulator_probe(struct platform_device *pdev)
@@ -326,6 +293,7 @@ static int __devinit tps65217_regulator_probe(struct platform_device *pdev)
         tps->info[pdev->id] = info;
 
         config.dev = &pdev->dev;
+        config.of_node = pdev->dev.of_node;
         config.init_data = pdev->dev.platform_data;
         config.driver_data = tps;
 
diff --git a/drivers/regulator/tps6524x-regulator.c b/drivers/regulator/tps6524x-regulator.c
index 1b299aacf22f..947ece933d90 100644
--- a/drivers/regulator/tps6524x-regulator.c
+++ b/drivers/regulator/tps6524x-regulator.c
@@ -110,9 +110,6 @@
 #define N_SWITCH                2
 #define N_REGULATORS            (N_DCDC + N_LDO + N_SWITCH)
 
-#define FIXED_ILIMSEL           BIT(0)
-#define FIXED_VOLTAGE           BIT(1)
-
 #define CMD_READ(reg)           ((reg) << 6)
 #define CMD_WRITE(reg)          (BIT(5) | (reg) << 6)
 #define STAT_CLK                BIT(3)
@@ -129,12 +126,9 @@ struct field {
 struct supply_info {
         const char      *name;
         int             n_voltages;
-        const int       *voltages;
-        int             fixed_voltage;
+        const unsigned int *voltages;
         int             n_ilimsels;
-        const int       *ilimsels;
-        int             fixed_ilimsel;
-        int             flags;
+        const unsigned int *ilimsels;
         struct field    enable, voltage, ilimsel;
 };
 
@@ -307,7 +301,7 @@ static int write_field(struct tps6524x *hw, const struct field *field,
                                     val << field->shift);
 }
 
-static const int dcdc1_voltages[] = {
+static const unsigned int dcdc1_voltages[] = {
          800000,  825000,  850000,  875000,
          900000,  925000,  950000,  975000,
         1000000, 1025000, 1050000, 1075000,
@@ -318,7 +312,7 @@ static const int dcdc1_voltages[] = {
         1500000, 1525000, 1550000, 1575000,
 };
 
-static const int dcdc2_voltages[] = {
+static const unsigned int dcdc2_voltages[] = {
         1400000, 1450000, 1500000, 1550000,
         1600000, 1650000, 1700000, 1750000,
         1800000, 1850000, 1900000, 1950000,
@@ -329,7 +323,7 @@ static const int dcdc2_voltages[] = {
         2800000, 2850000, 2900000, 2950000,
 };
 
-static const int dcdc3_voltages[] = {
+static const unsigned int dcdc3_voltages[] = {
         2400000, 2450000, 2500000, 2550000, 2600000,
         2650000, 2700000, 2750000, 2800000, 2850000,
         2900000, 2950000, 3000000, 3050000, 3100000,
@@ -337,38 +331,54 @@ static const int dcdc3_voltages[] = {
         3400000, 3450000, 3500000, 3550000, 3600000,
 };
 
-static const int ldo1_voltages[] = {
+static const unsigned int ldo1_voltages[] = {
         4300000, 4350000, 4400000, 4450000,
         4500000, 4550000, 4600000, 4650000,
         4700000, 4750000, 4800000, 4850000,
         4900000, 4950000, 5000000, 5050000,
 };
 
-static const int ldo2_voltages[] = {
+static const unsigned int ldo2_voltages[] = {
         1100000, 1150000, 1200000, 1250000,
         1300000, 1700000, 1750000, 1800000,
         1850000, 1900000, 3150000, 3200000,
         3250000, 3300000, 3350000, 3400000,
 };
 
-static const int ldo_ilimsel[] = {
+static const unsigned int fixed_5000000_voltage[] = {
+        5000000
+};
+
+static const unsigned int ldo_ilimsel[] = {
         400000, 1500000
 };
 
-static const int usb_ilimsel[] = {
+static const unsigned int usb_ilimsel[] = {
         200000, 400000, 800000, 1000000
 };
 
+static const unsigned int fixed_2400000_ilimsel[] = {
+        2400000
+};
+
+static const unsigned int fixed_1200000_ilimsel[] = {
+        1200000
+};
+
+static const unsigned int fixed_400000_ilimsel[] = {
+        400000
+};
+
 #define __MK_FIELD(_reg, _mask, _shift) \
         { .reg = (_reg), .mask = (_mask), .shift = (_shift), }
 
 static const struct supply_info supply_info[N_REGULATORS] = {
         {
                 .name           = "DCDC1",
-                .flags          = FIXED_ILIMSEL,
                 .n_voltages     = ARRAY_SIZE(dcdc1_voltages),
                 .voltages       = dcdc1_voltages,
-                .fixed_ilimsel  = 2400000,
+                .n_ilimsels     = ARRAY_SIZE(fixed_2400000_ilimsel),
+                .ilimsels       = fixed_2400000_ilimsel,
                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
                                              DCDCDCDC1_EN_SHIFT),
                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
@@ -376,10 +386,10 @@ static const struct supply_info supply_info[N_REGULATORS] = {
         },
         {
                 .name           = "DCDC2",
-                .flags          = FIXED_ILIMSEL,
                 .n_voltages     = ARRAY_SIZE(dcdc2_voltages),
                 .voltages       = dcdc2_voltages,
-                .fixed_ilimsel  = 1200000,
+                .n_ilimsels     = ARRAY_SIZE(fixed_1200000_ilimsel),
+                .ilimsels       = fixed_1200000_ilimsel,
                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
                                              DCDCDCDC2_EN_SHIFT),
                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
@@ -387,10 +397,10 @@ static const struct supply_info supply_info[N_REGULATORS] = {
         },
         {
                 .name           = "DCDC3",
-                .flags          = FIXED_ILIMSEL,
                 .n_voltages     = ARRAY_SIZE(dcdc3_voltages),
                 .voltages       = dcdc3_voltages,
-                .fixed_ilimsel  = 1200000,
+                .n_ilimsels     = ARRAY_SIZE(fixed_1200000_ilimsel),
+                .ilimsels       = fixed_1200000_ilimsel,
                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
                                         DCDCDCDC3_EN_SHIFT),
                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
@@ -424,8 +434,8 @@ static const struct supply_info supply_info[N_REGULATORS] = {
         },
         {
                 .name           = "USB",
-                .flags          = FIXED_VOLTAGE,
-                .fixed_voltage  = 5000000,
+                .n_voltages     = ARRAY_SIZE(fixed_5000000_voltage),
+                .voltages       = fixed_5000000_voltage,
                 .n_ilimsels     = ARRAY_SIZE(usb_ilimsel),
                 .ilimsels       = usb_ilimsel,
                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
@@ -435,29 +445,15 @@ static const struct supply_info supply_info[N_REGULATORS] = {
         },
         {
                 .name           = "LCD",
-                .flags          = FIXED_VOLTAGE | FIXED_ILIMSEL,
-                .fixed_voltage  = 5000000,
-                .fixed_ilimsel  =  400000,
+                .n_voltages     = ARRAY_SIZE(fixed_5000000_voltage),
+                .voltages       = fixed_5000000_voltage,
+                .n_ilimsels     = ARRAY_SIZE(fixed_400000_ilimsel),
+                .ilimsels       = fixed_400000_ilimsel,
                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
                                              BLOCK_LCD_SHIFT),
         },
 };
 
-static int list_voltage(struct regulator_dev *rdev, unsigned selector)
-{
-        const struct supply_info *info;
-        struct tps6524x *hw;
-
-        hw      = rdev_get_drvdata(rdev);
-        info    = &supply_info[rdev_get_id(rdev)];
-
-        if (info->flags & FIXED_VOLTAGE)
-                return selector ? -EINVAL : info->fixed_voltage;
-
-        return ((selector < info->n_voltages) ?
-                info->voltages[selector] : -EINVAL);
-}
-
 static int set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
 {
         const struct supply_info *info;
@@ -466,7 +462,7 @@ static int set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
         hw      = rdev_get_drvdata(rdev);
         info    = &supply_info[rdev_get_id(rdev)];
 
-        if (info->flags & FIXED_VOLTAGE)
+        if (rdev->desc->n_voltages == 1)
                 return -EINVAL;
 
         return write_field(hw, &info->voltage, selector);
@@ -481,7 +477,7 @@ static int get_voltage_sel(struct regulator_dev *rdev)
         hw      = rdev_get_drvdata(rdev);
         info    = &supply_info[rdev_get_id(rdev)];
 
-        if (info->flags & FIXED_VOLTAGE)
+        if (rdev->desc->n_voltages == 1)
                 return 0;
 
         ret = read_field(hw, &info->voltage);
@@ -503,7 +499,7 @@ static int set_current_limit(struct regulator_dev *rdev, int min_uA,
         hw      = rdev_get_drvdata(rdev);
         info    = &supply_info[rdev_get_id(rdev)];
 
-        if (info->flags & FIXED_ILIMSEL)
+        if (info->n_ilimsels == 1)
                 return -EINVAL;
 
         for (i = 0; i < info->n_ilimsels; i++)
@@ -526,8 +522,8 @@ static int get_current_limit(struct regulator_dev *rdev)
         hw      = rdev_get_drvdata(rdev);
         info    = &supply_info[rdev_get_id(rdev)];
 
-        if (info->flags & FIXED_ILIMSEL)
-                return info->fixed_ilimsel;
+        if (info->n_ilimsels == 1)
+                return info->ilimsels[0];
 
         ret = read_field(hw, &info->ilimsel);
         if (ret < 0)
@@ -577,7 +573,7 @@ static struct regulator_ops regulator_ops = {
         .disable                = disable_supply,
         .get_voltage_sel        = get_voltage_sel,
         .set_voltage_sel        = set_voltage_sel,
-        .list_voltage           = list_voltage,
+        .list_voltage           = regulator_list_voltage_table,
         .set_current_limit      = set_current_limit,
         .get_current_limit      = get_current_limit,
 };
@@ -629,13 +625,11 @@ static int __devinit pmic_probe(struct spi_device *spi)
                 hw->desc[i].name        = info->name;
                 hw->desc[i].id          = i;
                 hw->desc[i].n_voltages  = info->n_voltages;
+                hw->desc[i].volt_table  = info->voltages;
                 hw->desc[i].ops         = &regulator_ops;
                 hw->desc[i].type        = REGULATOR_VOLTAGE;
                 hw->desc[i].owner       = THIS_MODULE;
 
-                if (info->flags & FIXED_VOLTAGE)
-                        hw->desc[i].n_voltages = 1;
-
                 config.dev = dev;
                 config.init_data = init_data;
                 config.driver_data = hw;
diff --git a/drivers/regulator/tps6586x-regulator.c b/drivers/regulator/tps6586x-regulator.c
index c0a214575380..e6da90ab5153 100644
--- a/drivers/regulator/tps6586x-regulator.c
+++ b/drivers/regulator/tps6586x-regulator.c
@@ -63,8 +63,6 @@ struct tps6586x_regulator {
         int enable_bit[2];
         int enable_reg[2];
 
-        int *voltages;
-
         /* for DVM regulators */
         int go_reg;
         int go_bit;
@@ -72,22 +70,9 @@ struct tps6586x_regulator {
 
 static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
 {
-        return rdev_get_dev(rdev)->parent->parent;
+        return rdev_get_dev(rdev)->parent;
 }
 
-static int tps6586x_list_voltage(struct regulator_dev *rdev, unsigned selector)
-{
-        struct tps6586x_regulator *info = rdev_get_drvdata(rdev);
-        int rid = rdev_get_id(rdev);
-
-        /* LDO0 has minimal voltage 1.2V rather than 1.25V */
-        if ((rid == TPS6586X_ID_LDO_0) && (selector == 0))
-                return (info->voltages[0] - 50) * 1000;
-
-        return info->voltages[selector] * 1000;
-}
-
-
 static int tps6586x_set_voltage_sel(struct regulator_dev *rdev,
                                     unsigned selector)
 {
@@ -168,7 +153,7 @@ static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev)
 }
 
 static struct regulator_ops tps6586x_regulator_ops = {
-        .list_voltage = tps6586x_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .get_voltage_sel = tps6586x_get_voltage_sel,
         .set_voltage_sel = tps6586x_set_voltage_sel,
 
@@ -177,39 +162,45 @@ static struct regulator_ops tps6586x_regulator_ops = {
         .disable = tps6586x_regulator_disable,
 };
 
-static int tps6586x_ldo_voltages[] = {
-        1250, 1500, 1800, 2500, 2700, 2850, 3100, 3300,
+static const unsigned int tps6586x_ldo0_voltages[] = {
+        1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
+};
+
+static const unsigned int tps6586x_ldo4_voltages[] = {
+        1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
+        1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
+        2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
+        2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
 };
 
-static int tps6586x_ldo4_voltages[] = {
-        1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
-        1900, 1925, 1950, 1975, 2000, 2025, 2050, 2075,
-        2100, 2125, 2150, 2175, 2200, 2225, 2250, 2275,
-        2300, 2325, 2350, 2375, 2400, 2425, 2450, 2475,
+static const unsigned int tps6586x_ldo_voltages[] = {
+        1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
 };
 
-static int tps6586x_sm2_voltages[] = {
-        3000, 3050, 3100, 3150, 3200, 3250, 3300, 3350,
-        3400, 3450, 3500, 3550, 3600, 3650, 3700, 3750,
-        3800, 3850, 3900, 3950, 4000, 4050, 4100, 4150,
-        4200, 4250, 4300, 4350, 4400, 4450, 4500, 4550,
+static const unsigned int tps6586x_sm2_voltages[] = {
+        3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
+        3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
+        3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
+        4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
 };
 
-static int tps6586x_dvm_voltages[] = {
-         725,  750,  775,  800,  825,  850,  875,  900,
-         925,  950,  975, 1000, 1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
+static const unsigned int tps6586x_dvm_voltages[] = {
+         725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
+         925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
+        1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
+        1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
 };
 
-#define TPS6586X_REGULATOR(_id, vdata, vreg, shift, nbits,              \
+#define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits,   \
                            ereg0, ebit0, ereg1, ebit1)                  \
         .desc   = {                                                     \
+                .supply_name = _pin_name,                               \
                 .name   = "REG-" #_id,                                  \
                 .ops    = &tps6586x_regulator_ops,                      \
                 .type   = REGULATOR_VOLTAGE,                            \
                 .id     = TPS6586X_ID_##_id,                            \
                 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),  \
+                .volt_table = tps6586x_##vdata##_voltages,              \
                 .owner  = THIS_MODULE,                                  \
         },                                                              \
         .volt_reg       = TPS6586X_##vreg,                              \
@@ -218,44 +209,45 @@ static int tps6586x_dvm_voltages[] = {
         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
         .enable_bit[0]  = (ebit0),                                      \
         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
-        .enable_bit[1]  = (ebit1),                                      \
-        .voltages       = tps6586x_##vdata##_voltages,
+        .enable_bit[1]  = (ebit1),
 
 #define TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
         .go_reg = TPS6586X_##goreg,                                     \
         .go_bit = (gobit),
 
-#define TPS6586X_LDO(_id, vdata, vreg, shift, nbits,                    \
+#define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
                      ereg0, ebit0, ereg1, ebit1)                        \
 {                                                                       \
-        TPS6586X_REGULATOR(_id, vdata, vreg, shift, nbits,              \
+        TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
                            ereg0, ebit0, ereg1, ebit1)                  \
 }
 
-#define TPS6586X_DVM(_id, vdata, vreg, shift, nbits,                    \
+#define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits,            \
                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
 {                                                                       \
-        TPS6586X_REGULATOR(_id, vdata, vreg, shift, nbits,              \
+        TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
                            ereg0, ebit0, ereg1, ebit1)                  \
         TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
 }
 
 static struct tps6586x_regulator tps6586x_regulator[] = {
-        TPS6586X_LDO(LDO_0, ldo, SUPPLYV1, 5, 3, ENC, 0, END, 0),
-        TPS6586X_LDO(LDO_3, ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
-        TPS6586X_LDO(LDO_5, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
-        TPS6586X_LDO(LDO_6, ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
-        TPS6586X_LDO(LDO_7, ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
-        TPS6586X_LDO(LDO_8, ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
-        TPS6586X_LDO(LDO_9, ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
-        TPS6586X_LDO(LDO_RTC, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
-        TPS6586X_LDO(LDO_1, dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
-        TPS6586X_LDO(SM_2, sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
-
-        TPS6586X_DVM(LDO_2, dvm, LDO2BV1, 0, 5, ENA, 3, ENB, 3, VCC2, 6),
-        TPS6586X_DVM(LDO_4, ldo4, LDO4V1, 0, 5, ENC, 3, END, 3, VCC1, 6),
-        TPS6586X_DVM(SM_0, dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
-        TPS6586X_DVM(SM_1, dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
+        TPS6586X_LDO(LDO_0, "vinldo01", ldo0, SUPPLYV1, 5, 3, ENC, 0, END, 0),
+        TPS6586X_LDO(LDO_3, "vinldo23", ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
+        TPS6586X_LDO(LDO_5, NULL, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
+        TPS6586X_LDO(LDO_6, "vinldo678", ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
+        TPS6586X_LDO(LDO_7, "vinldo678", ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
+        TPS6586X_LDO(LDO_8, "vinldo678", ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
+        TPS6586X_LDO(LDO_9, "vinldo9", ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
+        TPS6586X_LDO(LDO_RTC, NULL, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
+        TPS6586X_LDO(LDO_1, "vinldo01", dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
+        TPS6586X_LDO(SM_2, "sm2", sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
+
+        TPS6586X_DVM(LDO_2, "vinldo23", dvm, LDO2BV1, 0, 5, ENA, 3,
+                                        ENB, 3, VCC2, 6),
+        TPS6586X_DVM(LDO_4, "vinldo4", ldo4, LDO4V1, 0, 5, ENC, 3,
+                                        END, 3, VCC1, 6),
+        TPS6586X_DVM(SM_0, "sm0", dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
+        TPS6586X_DVM(SM_1, "sm1", dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
 };
 
 /*
@@ -362,7 +354,7 @@ static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
         if (err)
                 return err;
 
-        config.dev = &pdev->dev;
+        config.dev = pdev->dev.parent;
         config.of_node = pdev->dev.of_node;
         config.init_data = pdev->dev.platform_data;
         config.driver_data = ri;
diff --git a/drivers/regulator/tps65910-regulator.c b/drivers/regulator/tps65910-regulator.c
index 6bf864b4bdf6..793adda560c3 100644
--- a/drivers/regulator/tps65910-regulator.c
+++ b/drivers/regulator/tps65910-regulator.c
@@ -31,160 +31,147 @@
                         TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3 |          \
                         TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP)
 
-/* supported VIO voltages in millivolts */
-static const u16 VIO_VSEL_table[] = {
-        1500, 1800, 2500, 3300,
+/* supported VIO voltages in microvolts */
+static const unsigned int VIO_VSEL_table[] = {
+        1500000, 1800000, 2500000, 3300000,
 };
 
 /* VSEL tables for TPS65910 specific LDOs and dcdc's */
 
-/* supported VDD3 voltages in millivolts */
-static const u16 VDD3_VSEL_table[] = {
-        5000,
+/* supported VDD3 voltages in microvolts */
+static const unsigned int VDD3_VSEL_table[] = {
+        5000000,
 };
 
-/* supported VDIG1 voltages in millivolts */
-static const u16 VDIG1_VSEL_table[] = {
-        1200, 1500, 1800, 2700,
+/* supported VDIG1 voltages in microvolts */
+static const unsigned int VDIG1_VSEL_table[] = {
+        1200000, 1500000, 1800000, 2700000,
 };
 
-/* supported VDIG2 voltages in millivolts */
-static const u16 VDIG2_VSEL_table[] = {
-        1000, 1100, 1200, 1800,
+/* supported VDIG2 voltages in microvolts */
+static const unsigned int VDIG2_VSEL_table[] = {
+        1000000, 1100000, 1200000, 1800000,
 };
 
-/* supported VPLL voltages in millivolts */
-static const u16 VPLL_VSEL_table[] = {
-        1000, 1100, 1800, 2500,
+/* supported VPLL voltages in microvolts */
+static const unsigned int VPLL_VSEL_table[] = {
+        1000000, 1100000, 1800000, 2500000,
 };
 
-/* supported VDAC voltages in millivolts */
-static const u16 VDAC_VSEL_table[] = {
-        1800, 2600, 2800, 2850,
+/* supported VDAC voltages in microvolts */
+static const unsigned int VDAC_VSEL_table[] = {
+        1800000, 2600000, 2800000, 2850000,
 };
 
-/* supported VAUX1 voltages in millivolts */
-static const u16 VAUX1_VSEL_table[] = {
-        1800, 2500, 2800, 2850,
+/* supported VAUX1 voltages in microvolts */
+static const unsigned int VAUX1_VSEL_table[] = {
+        1800000, 2500000, 2800000, 2850000,
 };
 
-/* supported VAUX2 voltages in millivolts */
-static const u16 VAUX2_VSEL_table[] = {
-        1800, 2800, 2900, 3300,
+/* supported VAUX2 voltages in microvolts */
+static const unsigned int VAUX2_VSEL_table[] = {
+        1800000, 2800000, 2900000, 3300000,
 };
 
-/* supported VAUX33 voltages in millivolts */
-static const u16 VAUX33_VSEL_table[] = {
-        1800, 2000, 2800, 3300,
+/* supported VAUX33 voltages in microvolts */
+static const unsigned int VAUX33_VSEL_table[] = {
+        1800000, 2000000, 2800000, 3300000,
 };
 
-/* supported VMMC voltages in millivolts */
-static const u16 VMMC_VSEL_table[] = {
-        1800, 2800, 3000, 3300,
+/* supported VMMC voltages in microvolts */
+static const unsigned int VMMC_VSEL_table[] = {
+        1800000, 2800000, 3000000, 3300000,
 };
 
 struct tps_info {
         const char *name;
-        unsigned min_uV;
-        unsigned max_uV;
+        const char *vin_name;
         u8 n_voltages;
-        const u16 *voltage_table;
+        const unsigned int *voltage_table;
         int enable_time_us;
 };
 
 static struct tps_info tps65910_regs[] = {
         {
                 .name = "vrtc",
+                .vin_name = "vcc7",
                 .enable_time_us = 2200,
         },
         {
                 .name = "vio",
-                .min_uV = 1500000,
-                .max_uV = 3300000,
+                .vin_name = "vccio",
                 .n_voltages = ARRAY_SIZE(VIO_VSEL_table),
                 .voltage_table = VIO_VSEL_table,
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd1",
-                .min_uV = 600000,
-                .max_uV = 4500000,
+                .vin_name = "vcc1",
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd2",
-                .min_uV = 600000,
-                .max_uV = 4500000,
+                .vin_name = "vcc2",
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd3",
-                .min_uV = 5000000,
-                .max_uV = 5000000,
                 .n_voltages = ARRAY_SIZE(VDD3_VSEL_table),
                 .voltage_table = VDD3_VSEL_table,
                 .enable_time_us = 200,
         },
         {
                 .name = "vdig1",
-                .min_uV = 1200000,
-                .max_uV = 2700000,
+                .vin_name = "vcc6",
                 .n_voltages = ARRAY_SIZE(VDIG1_VSEL_table),
                 .voltage_table = VDIG1_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vdig2",
-                .min_uV = 1000000,
-                .max_uV = 1800000,
+                .vin_name = "vcc6",
                 .n_voltages = ARRAY_SIZE(VDIG2_VSEL_table),
                 .voltage_table = VDIG2_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vpll",
-                .min_uV = 1000000,
-                .max_uV = 2500000,
+                .vin_name = "vcc5",
                 .n_voltages = ARRAY_SIZE(VPLL_VSEL_table),
                 .voltage_table = VPLL_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vdac",
-                .min_uV = 1800000,
-                .max_uV = 2850000,
+                .vin_name = "vcc5",
                 .n_voltages = ARRAY_SIZE(VDAC_VSEL_table),
                 .voltage_table = VDAC_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vaux1",
-                .min_uV = 1800000,
-                .max_uV = 2850000,
+                .vin_name = "vcc4",
                 .n_voltages = ARRAY_SIZE(VAUX1_VSEL_table),
                 .voltage_table = VAUX1_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vaux2",
-                .min_uV = 1800000,
-                .max_uV = 3300000,
+                .vin_name = "vcc4",
                 .n_voltages = ARRAY_SIZE(VAUX2_VSEL_table),
                 .voltage_table = VAUX2_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vaux33",
-                .min_uV = 1800000,
-                .max_uV = 3300000,
+                .vin_name = "vcc3",
                 .n_voltages = ARRAY_SIZE(VAUX33_VSEL_table),
                 .voltage_table = VAUX33_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vmmc",
-                .min_uV = 1800000,
-                .max_uV = 3300000,
+                .vin_name = "vcc3",
                 .n_voltages = ARRAY_SIZE(VMMC_VSEL_table),
                 .voltage_table = VMMC_VSEL_table,
                 .enable_time_us = 100,
@@ -194,91 +181,79 @@ static struct tps_info tps65910_regs[] = {
 static struct tps_info tps65911_regs[] = {
         {
                 .name = "vrtc",
+                .vin_name = "vcc7",
                 .enable_time_us = 2200,
         },
         {
                 .name = "vio",
-                .min_uV = 1500000,
-                .max_uV = 3300000,
+                .vin_name = "vccio",
                 .n_voltages = ARRAY_SIZE(VIO_VSEL_table),
                 .voltage_table = VIO_VSEL_table,
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd1",
-                .min_uV = 600000,
-                .max_uV = 4500000,
-                .n_voltages = 73,
+                .vin_name = "vcc1",
+                .n_voltages = 0x4C,
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd2",
-                .min_uV = 600000,
-                .max_uV = 4500000,
-                .n_voltages = 73,
+                .vin_name = "vcc2",
+                .n_voltages = 0x4C,
                 .enable_time_us = 350,
         },
         {
                 .name = "vddctrl",
-                .min_uV = 600000,
-                .max_uV = 1400000,
-                .n_voltages = 65,
+                .n_voltages = 0x44,
                 .enable_time_us = 900,
         },
         {
                 .name = "ldo1",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 47,
+                .vin_name = "vcc6",
+                .n_voltages = 0x33,
                 .enable_time_us = 420,
         },
         {
                 .name = "ldo2",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 47,
+                .vin_name = "vcc6",
+                .n_voltages = 0x33,
                 .enable_time_us = 420,
         },
         {
                 .name = "ldo3",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc5",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo4",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 47,
+                .vin_name = "vcc5",
+                .n_voltages = 0x33,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo5",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc4",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo6",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc3",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo7",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc3",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo8",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc3",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
 };
@@ -321,7 +296,6 @@ struct tps65910_reg {
         struct tps65910 *mfd;
         struct regulator_dev **rdev;
         struct tps_info **info;
-        struct mutex mutex;
         int num_regulators;
         int mode;
         int  (*get_ctrl_reg)(int);
@@ -329,71 +303,6 @@ struct tps65910_reg {
         unsigned int board_ext_control[TPS65910_NUM_REGS];
 };
 
-static inline int tps65910_read(struct tps65910_reg *pmic, u8 reg)
-{
-        unsigned int val;
-        int err;
-
-        err = tps65910_reg_read(pmic->mfd, reg, &val);
-        if (err)
-                return err;
-
-        return val;
-}
-
-static int tps65910_modify_bits(struct tps65910_reg *pmic, u8 reg,
-                                        u8 set_mask, u8 clear_mask)
-{
-        int err, data;
-
-        mutex_lock(&pmic->mutex);
-
-        data = tps65910_read(pmic, reg);
-        if (data < 0) {
-                dev_err(pmic->mfd->dev, "Read from reg 0x%x failed\n", reg);
-                err = data;
-                goto out;
-        }
-
-        data &= ~clear_mask;
-        data |= set_mask;
-        err = tps65910_reg_write(pmic->mfd, reg, data);
-        if (err)
-                dev_err(pmic->mfd->dev, "Write for reg 0x%x failed\n", reg);
-
-out:
-        mutex_unlock(&pmic->mutex);
-        return err;
-}
-
-static int tps65910_reg_read_locked(struct tps65910_reg *pmic, u8 reg)
-{
-        int data;
-
-        mutex_lock(&pmic->mutex);
-
-        data = tps65910_read(pmic, reg);
-        if (data < 0)
-                dev_err(pmic->mfd->dev, "Read from reg 0x%x failed\n", reg);
-
-        mutex_unlock(&pmic->mutex);
-        return data;
-}
-
-static int tps65910_reg_write_locked(struct tps65910_reg *pmic, u8 reg, u8 val)
-{
-        int err;
-
-        mutex_lock(&pmic->mutex);
-
-        err = tps65910_reg_write(pmic->mfd, reg, val);
-        if (err < 0)
-                dev_err(pmic->mfd->dev, "Write for reg 0x%x failed\n", reg);
-
-        mutex_unlock(&pmic->mutex);
-        return err;
-}
-
 static int tps65910_get_ctrl_register(int id)
 {
         switch (id) {
@@ -462,13 +371,6 @@ static int tps65911_get_ctrl_register(int id)
         }
 }
 
-static int tps65910_enable_time(struct regulator_dev *dev)
-{
-        struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev);
-        return pmic->info[id]->enable_time_us;
-}
-
 static int tps65910_set_mode(struct regulator_dev *dev, unsigned int mode)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
@@ -481,8 +383,9 @@ static int tps65910_set_mode(struct regulator_dev *dev, unsigned int mode)
 
         switch (mode) {
         case REGULATOR_MODE_NORMAL:
-                return tps65910_modify_bits(pmic, reg, LDO_ST_ON_BIT,
-                                                        LDO_ST_MODE_BIT);
+                return tps65910_reg_update_bits(pmic->mfd, reg,
+                                                LDO_ST_MODE_BIT | LDO_ST_ON_BIT,
+                                                LDO_ST_ON_BIT);
         case REGULATOR_MODE_IDLE:
                 value = LDO_ST_ON_BIT | LDO_ST_MODE_BIT;
                 return tps65910_reg_set_bits(mfd, reg, value);
@@ -496,15 +399,15 @@ static int tps65910_set_mode(struct regulator_dev *dev, unsigned int mode)
 static unsigned int tps65910_get_mode(struct regulator_dev *dev)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int reg, value, id = rdev_get_id(dev);
+        int ret, reg, value, id = rdev_get_id(dev);
 
         reg = pmic->get_ctrl_reg(id);
         if (reg < 0)
                 return reg;
 
-        value = tps65910_reg_read_locked(pmic, reg);
-        if (value < 0)
-                return value;
+        ret = tps65910_reg_read(pmic->mfd, reg, &value);
+        if (ret < 0)
+                return ret;
 
         if (!(value & LDO_ST_ON_BIT))
                 return REGULATOR_MODE_STANDBY;
@@ -517,33 +420,51 @@ static unsigned int tps65910_get_mode(struct regulator_dev *dev)
 static int tps65910_get_voltage_dcdc_sel(struct regulator_dev *dev)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev);
+        int ret, id = rdev_get_id(dev);
         int opvsel = 0, srvsel = 0, vselmax = 0, mult = 0, sr = 0;
 
         switch (id) {
         case TPS65910_REG_VDD1:
-                opvsel = tps65910_reg_read_locked(pmic, TPS65910_VDD1_OP);
-                mult = tps65910_reg_read_locked(pmic, TPS65910_VDD1);
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD1_OP, &opvsel);
+                if (ret < 0)
+                        return ret;
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD1, &mult);
+                if (ret < 0)
+                        return ret;
                 mult = (mult & VDD1_VGAIN_SEL_MASK) >> VDD1_VGAIN_SEL_SHIFT;
-                srvsel = tps65910_reg_read_locked(pmic, TPS65910_VDD1_SR);
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD1_SR, &srvsel);
+                if (ret < 0)
+                        return ret;
                 sr = opvsel & VDD1_OP_CMD_MASK;
                 opvsel &= VDD1_OP_SEL_MASK;
                 srvsel &= VDD1_SR_SEL_MASK;
                 vselmax = 75;
                 break;
         case TPS65910_REG_VDD2:
-                opvsel = tps65910_reg_read_locked(pmic, TPS65910_VDD2_OP);
-                mult = tps65910_reg_read_locked(pmic, TPS65910_VDD2);
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD2_OP, &opvsel);
+                if (ret < 0)
+                        return ret;
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD2, &mult);
+                if (ret < 0)
+                        return ret;
                 mult = (mult & VDD2_VGAIN_SEL_MASK) >> VDD2_VGAIN_SEL_SHIFT;
-                srvsel = tps65910_reg_read_locked(pmic, TPS65910_VDD2_SR);
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD2_SR, &srvsel);
+                if (ret < 0)
+                        return ret;
                 sr = opvsel & VDD2_OP_CMD_MASK;
                 opvsel &= VDD2_OP_SEL_MASK;
                 srvsel &= VDD2_SR_SEL_MASK;
                 vselmax = 75;
                 break;
         case TPS65911_REG_VDDCTRL:
-                opvsel = tps65910_reg_read_locked(pmic, TPS65911_VDDCTRL_OP);
-                srvsel = tps65910_reg_read_locked(pmic, TPS65911_VDDCTRL_SR);
+                ret = tps65910_reg_read(pmic->mfd, TPS65911_VDDCTRL_OP,
+                                        &opvsel);
+                if (ret < 0)
+                        return ret;
+                ret = tps65910_reg_read(pmic->mfd, TPS65911_VDDCTRL_SR,
+                                        &srvsel);
+                if (ret < 0)
+                        return ret;
                 sr = opvsel & VDDCTRL_OP_CMD_MASK;
                 opvsel &= VDDCTRL_OP_SEL_MASK;
                 srvsel &= VDDCTRL_SR_SEL_MASK;
@@ -577,15 +498,15 @@ static int tps65910_get_voltage_dcdc_sel(struct regulator_dev *dev)
 static int tps65910_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int reg, value, id = rdev_get_id(dev);
+        int ret, reg, value, id = rdev_get_id(dev);
 
         reg = pmic->get_ctrl_reg(id);
         if (reg < 0)
                 return reg;
 
-        value = tps65910_reg_read_locked(pmic, reg);
-        if (value < 0)
-                return value;
+        ret = tps65910_reg_read(pmic->mfd, reg, &value);
+        if (ret < 0)
+                return ret;
 
         switch (id) {
         case TPS65910_REG_VIO:
@@ -609,18 +530,20 @@ static int tps65910_get_voltage_sel(struct regulator_dev *dev)
 
 static int tps65910_get_voltage_vdd3(struct regulator_dev *dev)
 {
-        return 5 * 1000 * 1000;
+        return dev->desc->volt_table[0];
 }
 
 static int tps65911_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev);
-        u8 value, reg;
+        int ret, id = rdev_get_id(dev);
+        unsigned int value, reg;
 
         reg = pmic->get_ctrl_reg(id);
 
-        value = tps65910_reg_read_locked(pmic, reg);
+        ret = tps65910_reg_read(pmic->mfd, reg, &value);
+        if (ret < 0)
+                return ret;
 
         switch (id) {
         case TPS65911_REG_LDO1:
@@ -662,10 +585,10 @@ static int tps65910_set_voltage_dcdc_sel(struct regulator_dev *dev,
                         dcdc_mult--;
                 vsel = (selector % VDD1_2_NUM_VOLT_FINE) + 3;
 
-                tps65910_modify_bits(pmic, TPS65910_VDD1,
-                                (dcdc_mult << VDD1_VGAIN_SEL_SHIFT),
-                                                VDD1_VGAIN_SEL_MASK);
-                tps65910_reg_write_locked(pmic, TPS65910_VDD1_OP, vsel);
+                tps65910_reg_update_bits(pmic->mfd, TPS65910_VDD1,
+                                         VDD1_VGAIN_SEL_MASK,
+                                         dcdc_mult << VDD1_VGAIN_SEL_SHIFT);
+                tps65910_reg_write(pmic->mfd, TPS65910_VDD1_OP, vsel);
                 break;
         case TPS65910_REG_VDD2:
                 dcdc_mult = (selector / VDD1_2_NUM_VOLT_FINE) + 1;
@@ -673,14 +596,14 @@ static int tps65910_set_voltage_dcdc_sel(struct regulator_dev *dev,
                         dcdc_mult--;
                 vsel = (selector % VDD1_2_NUM_VOLT_FINE) + 3;
 
-                tps65910_modify_bits(pmic, TPS65910_VDD2,
-                                (dcdc_mult << VDD2_VGAIN_SEL_SHIFT),
-                                                VDD1_VGAIN_SEL_MASK);
-                tps65910_reg_write_locked(pmic, TPS65910_VDD2_OP, vsel);
+                tps65910_reg_update_bits(pmic->mfd, TPS65910_VDD2,
+                                         VDD1_VGAIN_SEL_MASK,
+                                         dcdc_mult << VDD2_VGAIN_SEL_SHIFT);
+                tps65910_reg_write(pmic->mfd, TPS65910_VDD2_OP, vsel);
                 break;
         case TPS65911_REG_VDDCTRL:
                 vsel = selector + 3;
-                tps65910_reg_write_locked(pmic, TPS65911_VDDCTRL_OP, vsel);
+                tps65910_reg_write(pmic->mfd, TPS65911_VDDCTRL_OP, vsel);
         }
 
         return 0;
@@ -706,8 +629,8 @@ static int tps65910_set_voltage_sel(struct regulator_dev *dev,
         case TPS65910_REG_VAUX2:
         case TPS65910_REG_VAUX33:
         case TPS65910_REG_VMMC:
-                return tps65910_modify_bits(pmic, reg,
-                                (selector << LDO_SEL_SHIFT), LDO_SEL_MASK);
+                return tps65910_reg_update_bits(pmic->mfd, reg, LDO_SEL_MASK,
+                                                selector << LDO_SEL_SHIFT);
         }
 
         return -EINVAL;
@@ -727,18 +650,18 @@ static int tps65911_set_voltage_sel(struct regulator_dev *dev,
         case TPS65911_REG_LDO1:
         case TPS65911_REG_LDO2:
         case TPS65911_REG_LDO4:
-                return tps65910_modify_bits(pmic, reg,
-                                (selector << LDO_SEL_SHIFT), LDO1_SEL_MASK);
+                return tps65910_reg_update_bits(pmic->mfd, reg, LDO1_SEL_MASK,
+                                                selector << LDO_SEL_SHIFT);
         case TPS65911_REG_LDO3:
         case TPS65911_REG_LDO5:
         case TPS65911_REG_LDO6:
         case TPS65911_REG_LDO7:
         case TPS65911_REG_LDO8:
-                return tps65910_modify_bits(pmic, reg,
-                                (selector << LDO_SEL_SHIFT), LDO3_SEL_MASK);
+                return tps65910_reg_update_bits(pmic->mfd, reg, LDO3_SEL_MASK,
+                                                selector << LDO_SEL_SHIFT);
         case TPS65910_REG_VIO:
-                return tps65910_modify_bits(pmic, reg,
-                                (selector << LDO_SEL_SHIFT), LDO_SEL_MASK);
+                return tps65910_reg_update_bits(pmic->mfd, reg, LDO_SEL_MASK,
+                                                selector << LDO_SEL_SHIFT);
         }
 
         return -EINVAL;
@@ -768,23 +691,6 @@ static int tps65910_list_voltage_dcdc(struct regulator_dev *dev,
         return  volt * 100 * mult;
 }
 
-static int tps65910_list_voltage(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev), voltage;
-
-        if (id < TPS65910_REG_VIO || id > TPS65910_REG_VMMC)
-                return -EINVAL;
-
-        if (selector >= pmic->info[id]->n_voltages)
-                return -EINVAL;
-        else
-                voltage = pmic->info[id]->voltage_table[selector] * 1000;
-
-        return voltage;
-}
-
 static int tps65911_list_voltage(struct regulator_dev *dev, unsigned selector)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
@@ -816,7 +722,7 @@ static int tps65911_list_voltage(struct regulator_dev *dev, unsigned selector)
                 step_mv = 100;
                 break;
         case TPS65910_REG_VIO:
-                return pmic->info[id]->voltage_table[selector] * 1000;
+                return pmic->info[id]->voltage_table[selector];
         default:
                 return -EINVAL;
         }
@@ -824,42 +730,16 @@ static int tps65911_list_voltage(struct regulator_dev *dev, unsigned selector)
         return (LDO_MIN_VOLT + selector * step_mv) * 1000;
 }
 
-static int tps65910_set_voltage_dcdc_time_sel(struct regulator_dev *dev,
-                unsigned int old_selector, unsigned int new_selector)
-{
-        int id = rdev_get_id(dev);
-        int old_volt, new_volt;
-
-        old_volt = tps65910_list_voltage_dcdc(dev, old_selector);
-        if (old_volt < 0)
-                return old_volt;
-
-        new_volt = tps65910_list_voltage_dcdc(dev, new_selector);
-        if (new_volt < 0)
-                return new_volt;
-
-        /* VDD1 and VDD2 are 12.5mV/us, VDDCTRL is 100mV/20us */
-        switch (id) {
-        case TPS65910_REG_VDD1:
-        case TPS65910_REG_VDD2:
-                return DIV_ROUND_UP(abs(old_volt - new_volt), 12500);
-        case TPS65911_REG_VDDCTRL:
-                return DIV_ROUND_UP(abs(old_volt - new_volt), 5000);
-        }
-        return -EINVAL;
-}
-
 /* Regulator ops (except VRTC) */
 static struct regulator_ops tps65910_ops_dcdc = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
-        .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
         .get_voltage_sel        = tps65910_get_voltage_dcdc_sel,
         .set_voltage_sel        = tps65910_set_voltage_dcdc_sel,
-        .set_voltage_time_sel   = tps65910_set_voltage_dcdc_time_sel,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
         .list_voltage           = tps65910_list_voltage_dcdc,
 };
 
@@ -867,30 +747,27 @@ static struct regulator_ops tps65910_ops_vdd3 = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
-        .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
         .get_voltage            = tps65910_get_voltage_vdd3,
-        .list_voltage           = tps65910_list_voltage,
+        .list_voltage           = regulator_list_voltage_table,
 };
 
 static struct regulator_ops tps65910_ops = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
-        .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
         .get_voltage_sel        = tps65910_get_voltage_sel,
         .set_voltage_sel        = tps65910_set_voltage_sel,
-        .list_voltage           = tps65910_list_voltage,
+        .list_voltage           = regulator_list_voltage_table,
 };
 
 static struct regulator_ops tps65911_ops = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
-        .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
         .get_voltage_sel        = tps65911_get_voltage_sel,
@@ -996,19 +873,27 @@ static int tps65910_set_ext_sleep_config(struct tps65910_reg *pmic,
                                 (tps65910_chip_id(mfd) == TPS65911))) {
                 int op_reg_add = pmic->get_ctrl_reg(id) + 1;
                 int sr_reg_add = pmic->get_ctrl_reg(id) + 2;
-                int opvsel = tps65910_reg_read_locked(pmic, op_reg_add);
-                int srvsel = tps65910_reg_read_locked(pmic, sr_reg_add);
+                int opvsel, srvsel;
+
+                ret = tps65910_reg_read(pmic->mfd, op_reg_add, &opvsel);
+                if (ret < 0)
+                        return ret;
+                ret = tps65910_reg_read(pmic->mfd, sr_reg_add, &srvsel);
+                if (ret < 0)
+                        return ret;
+
                 if (opvsel & VDD1_OP_CMD_MASK) {
                         u8 reg_val = srvsel & VDD1_OP_SEL_MASK;
-                        ret = tps65910_reg_write_locked(pmic, op_reg_add,
-                                                        reg_val);
+
+                        ret = tps65910_reg_write(pmic->mfd, op_reg_add,
+                                                 reg_val);
                         if (ret < 0) {
                                 dev_err(mfd->dev,
                                         "Error in configuring op register\n");
                                 return ret;
                         }
                 }
-                ret = tps65910_reg_write_locked(pmic, sr_reg_add, 0);
+                ret = tps65910_reg_write(pmic->mfd, sr_reg_add, 0);
                 if (ret < 0) {
                         dev_err(mfd->dev, "Error in settting sr register\n");
                         return ret;
@@ -1126,6 +1011,7 @@ static struct tps65910_board *tps65910_parse_dt_reg_data(
                                 "ti,regulator-ext-sleep-control", &prop);
                 if (!ret)
                         pmic_plat_data->regulator_ext_sleep_control[idx] = prop;
+
         }
 
         return pmic_plat_data;
@@ -1136,7 +1022,7 @@ static inline struct tps65910_board *tps65910_parse_dt_reg_data(
                         struct of_regulator_match **tps65910_reg_matches)
 {
         *tps65910_reg_matches = NULL;
-        return 0;
+        return NULL;
 }
 #endif
 
@@ -1168,7 +1054,6 @@ static __devinit int tps65910_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
-        mutex_init(&pmic->mutex);
         pmic->mfd = tps65910;
         platform_set_drvdata(pdev, pmic);
 
@@ -1229,23 +1114,31 @@ static __devinit int tps65910_probe(struct platform_device *pdev)
                 pmic->info[i] = info;
 
                 pmic->desc[i].name = info->name;
+                pmic->desc[i].supply_name = info->vin_name;
                 pmic->desc[i].id = i;
                 pmic->desc[i].n_voltages = info->n_voltages;
+                pmic->desc[i].enable_time = info->enable_time_us;
 
                 if (i == TPS65910_REG_VDD1 || i == TPS65910_REG_VDD2) {
                         pmic->desc[i].ops = &tps65910_ops_dcdc;
                         pmic->desc[i].n_voltages = VDD1_2_NUM_VOLT_FINE *
                                                         VDD1_2_NUM_VOLT_COARSE;
+                        pmic->desc[i].ramp_delay = 12500;
                 } else if (i == TPS65910_REG_VDD3) {
-                        if (tps65910_chip_id(tps65910) == TPS65910)
+                        if (tps65910_chip_id(tps65910) == TPS65910) {
                                 pmic->desc[i].ops = &tps65910_ops_vdd3;
-                        else
+                                pmic->desc[i].volt_table = info->voltage_table;
+                        } else {
                                 pmic->desc[i].ops = &tps65910_ops_dcdc;
+                                pmic->desc[i].ramp_delay = 5000;
+                        }
                 } else {
-                        if (tps65910_chip_id(tps65910) == TPS65910)
+                        if (tps65910_chip_id(tps65910) == TPS65910) {
                                 pmic->desc[i].ops = &tps65910_ops;
-                        else
+                                pmic->desc[i].volt_table = info->voltage_table;
+                        } else {
                                 pmic->desc[i].ops = &tps65911_ops;
+                        }
                 }
 
                 err = tps65910_set_ext_sleep_config(pmic, i,
diff --git a/drivers/regulator/twl-regulator.c b/drivers/regulator/twl-regulator.c
index c7390711d954..242fe90dc565 100644
--- a/drivers/regulator/twl-regulator.c
+++ b/drivers/regulator/twl-regulator.c
@@ -43,9 +43,6 @@ struct twlreg_info {
         u8                      table_len;
         const u16               *table;
 
-        /* regulator specific turn-on delay */
-        u16                     delay;
-
         /* State REMAP default configuration */
         u8                      remap;
 
@@ -223,20 +220,6 @@ static int twl6030reg_enable(struct regulator_dev *rdev)
         return ret;
 }
 
-static int twl4030reg_enable_time(struct regulator_dev *rdev)
-{
-        struct twlreg_info      *info = rdev_get_drvdata(rdev);
-
-        return info->delay;
-}
-
-static int twl6030reg_enable_time(struct regulator_dev *rdev)
-{
-        struct twlreg_info      *info = rdev_get_drvdata(rdev);
-
-        return info->delay;
-}
-
 static int twl4030reg_disable(struct regulator_dev *rdev)
 {
         struct twlreg_info      *info = rdev_get_drvdata(rdev);
@@ -508,7 +491,6 @@ static struct regulator_ops twl4030ldo_ops = {
         .enable         = twl4030reg_enable,
         .disable        = twl4030reg_disable,
         .is_enabled     = twl4030reg_is_enabled,
-        .enable_time    = twl4030reg_enable_time,
 
         .set_mode       = twl4030reg_set_mode,
 
@@ -577,59 +559,53 @@ static struct regulator_ops twl6030coresmps_ops = {
         .get_voltage    = twl6030coresmps_get_voltage,
 };
 
-static int twl6030ldo_list_voltage(struct regulator_dev *rdev, unsigned index)
+static int twl6030ldo_list_voltage(struct regulator_dev *rdev, unsigned sel)
 {
-        struct twlreg_info      *info = rdev_get_drvdata(rdev);
+        struct twlreg_info *info = rdev_get_drvdata(rdev);
 
-        return ((info->min_mV + (index * 100)) * 1000);
+        switch (sel) {
+        case 0:
+                return 0;
+        case 1 ... 24:
+                /* Linear mapping from 00000001 to 00011000:
+                 * Absolute voltage value = 1.0 V + 0.1 V × (sel – 00000001)
+                 */
+                return (info->min_mV + 100 * (sel - 1)) * 1000;
+        case 25 ... 30:
+                return -EINVAL;
+        case 31:
+                return 2750000;
+        default:
+                return -EINVAL;
+        }
 }
 
 static int
-twl6030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
-                       unsigned *selector)
+twl6030ldo_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
 {
         struct twlreg_info      *info = rdev_get_drvdata(rdev);
-        int                     vsel;
-
-        if ((min_uV/1000 < info->min_mV) || (max_uV/1000 > info->max_mV))
-                return -EDOM;
-
-        /*
-         * Use the below formula to calculate vsel
-         * mV = 1000mv + 100mv * (vsel - 1)
-         */
-        vsel = (min_uV/1000 - 1000)/100 + 1;
-        *selector = vsel;
-        return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE, vsel);
 
+        return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE,
+                            selector);
 }
 
-static int twl6030ldo_get_voltage(struct regulator_dev *rdev)
+static int twl6030ldo_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct twlreg_info      *info = rdev_get_drvdata(rdev);
-        int             vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER,
-                                                                VREG_VOLTAGE);
-
-        if (vsel < 0)
-                return vsel;
+        int vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE);
 
-        /*
-         * Use the below formula to calculate vsel
-         * mV = 1000mv + 100mv * (vsel - 1)
-         */
-        return (1000 + (100 * (vsel - 1))) * 1000;
+        return vsel;
 }
 
 static struct regulator_ops twl6030ldo_ops = {
         .list_voltage   = twl6030ldo_list_voltage,
 
-        .set_voltage    = twl6030ldo_set_voltage,
-        .get_voltage    = twl6030ldo_get_voltage,
+        .set_voltage_sel = twl6030ldo_set_voltage_sel,
+        .get_voltage_sel = twl6030ldo_get_voltage_sel,
 
         .enable         = twl6030reg_enable,
         .disable        = twl6030reg_disable,
         .is_enabled     = twl6030reg_is_enabled,
-        .enable_time    = twl6030reg_enable_time,
 
         .set_mode       = twl6030reg_set_mode,
 
@@ -663,7 +639,6 @@ static struct regulator_ops twl4030fixed_ops = {
         .enable         = twl4030reg_enable,
         .disable        = twl4030reg_disable,
         .is_enabled     = twl4030reg_is_enabled,
-        .enable_time    = twl4030reg_enable_time,
 
         .set_mode       = twl4030reg_set_mode,
 
@@ -678,7 +653,6 @@ static struct regulator_ops twl6030fixed_ops = {
         .enable         = twl6030reg_enable,
         .disable        = twl6030reg_disable,
         .is_enabled     = twl6030reg_is_enabled,
-        .enable_time    = twl6030reg_enable_time,
 
         .set_mode       = twl6030reg_set_mode,
 
@@ -689,7 +663,6 @@ static struct regulator_ops twl6030_fixed_resource = {
         .enable         = twl6030reg_enable,
         .disable        = twl6030reg_disable,
         .is_enabled     = twl6030reg_is_enabled,
-        .enable_time    = twl6030reg_enable_time,
         .get_status     = twl6030reg_get_status,
 };
 
@@ -886,7 +859,6 @@ static struct regulator_ops twlsmps_ops = {
         .enable                 = twl6030reg_enable,
         .disable                = twl6030reg_disable,
         .is_enabled             = twl6030reg_is_enabled,
-        .enable_time            = twl6030reg_enable_time,
 
         .set_mode               = twl6030reg_set_mode,
 
@@ -909,7 +881,6 @@ static struct twlreg_info TWL4030_INFO_##label = { \
         .id = num, \
         .table_len = ARRAY_SIZE(label##_VSEL_table), \
         .table = label##_VSEL_table, \
-        .delay = turnon_delay, \
         .remap = remap_conf, \
         .desc = { \
                 .name = #label, \
@@ -918,6 +889,7 @@ static struct twlreg_info TWL4030_INFO_##label = { \
                 .ops = &twl4030ldo_ops, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
+                .enable_time = turnon_delay, \
                 }, \
         }
 
@@ -925,7 +897,6 @@ static struct twlreg_info TWL4030_INFO_##label = { \
 static struct twlreg_info TWL4030_INFO_##label = { \
         .base = offset, \
         .id = num, \
-        .delay = turnon_delay, \
         .remap = remap_conf, \
         .desc = { \
                 .name = #label, \
@@ -933,6 +904,7 @@ static struct twlreg_info TWL4030_INFO_##label = { \
                 .ops = &twl4030smps_ops, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
+                .enable_time = turnon_delay, \
                 }, \
         }
 
@@ -955,7 +927,7 @@ static struct twlreg_info TWL6030_INFO_##label = { \
         .desc = { \
                 .name = #label, \
                 .id = TWL6030_REG_##label, \
-                .n_voltages = (max_mVolts - min_mVolts)/100 + 1, \
+                .n_voltages = 32, \
                 .ops = &twl6030ldo_ops, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
@@ -970,7 +942,7 @@ static struct twlreg_info TWL6025_INFO_##label = { \
         .desc = { \
                 .name = #label, \
                 .id = TWL6025_REG_##label, \
-                .n_voltages = ((max_mVolts - min_mVolts)/100) + 1, \
+                .n_voltages = 32, \
                 .ops = &twl6030ldo_ops, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
@@ -983,7 +955,6 @@ static struct twlreg_info TWLFIXED_INFO_##label = { \
         .base = offset, \
         .id = num, \
         .min_mV = mVolts, \
-        .delay = turnon_delay, \
         .remap = remap_conf, \
         .desc = { \
                 .name = #label, \
@@ -992,19 +963,20 @@ static struct twlreg_info TWLFIXED_INFO_##label = { \
                 .ops = &operations, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
+                .enable_time = turnon_delay, \
                 }, \
         }
 
 #define TWL6030_FIXED_RESOURCE(label, offset, turnon_delay) \
 static struct twlreg_info TWLRES_INFO_##label = { \
         .base = offset, \
-        .delay = turnon_delay, \
         .desc = { \
                 .name = #label, \
                 .id = TWL6030_REG_##label, \
                 .ops = &twl6030_fixed_resource, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
+                .enable_time = turnon_delay, \
                 }, \
         }
 
@@ -1109,7 +1081,6 @@ static u8 twl_get_smps_mult(void)
 #define TWL6030_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6030, label)
 #define TWL6025_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6025, label)
 #define TWLFIXED_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLFIXED, label)
-#define TWLRES_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLRES, label)
 #define TWLSMPS_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLSMPS, label)
 
 static const struct of_device_id twl_of_match[] __devinitconst = {
@@ -1157,7 +1128,6 @@ static const struct of_device_id twl_of_match[] __devinitconst = {
         TWLFIXED_OF_MATCH("ti,twl6030-vusb", VUSB),
         TWLFIXED_OF_MATCH("ti,twl6030-v1v8", V1V8),
         TWLFIXED_OF_MATCH("ti,twl6030-v2v1", V2V1),
-        TWLRES_OF_MATCH("ti,twl6030-clk32kg", CLK32KG),
         TWLSMPS_OF_MATCH("ti,twl6025-smps3", SMPS3),
         TWLSMPS_OF_MATCH("ti,twl6025-smps4", SMPS4),
         TWLSMPS_OF_MATCH("ti,twl6025-vio", VIO),
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
index 099da11e989f..7413885be01b 100644
--- a/drivers/regulator/wm831x-dcdc.c
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -215,8 +215,8 @@ static int wm831x_buckv_list_voltage(struct regulator_dev *rdev,
         return -EINVAL;
 }
 
-static int wm831x_buckv_select_min_voltage(struct regulator_dev *rdev,
-                                           int min_uV, int max_uV)
+static int wm831x_buckv_map_voltage(struct regulator_dev *rdev,
+                                   int min_uV, int max_uV)
 {
         u16 vsel;
 
@@ -251,20 +251,14 @@ static int wm831x_buckv_set_dvs(struct regulator_dev *rdev, int state)
         return 0;
 }
 
-static int wm831x_buckv_set_voltage(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV, unsigned *selector)
+static int wm831x_buckv_set_voltage_sel(struct regulator_dev *rdev,
+                                        unsigned vsel)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = dcdc->wm831x;
         int on_reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
         int dvs_reg = dcdc->base + WM831X_DCDC_DVS_CONTROL;
-        int vsel, ret;
-
-        vsel = wm831x_buckv_select_min_voltage(rdev, min_uV, max_uV);
-        if (vsel < 0)
-                return vsel;
-
-        *selector = vsel;
+        int ret;
 
         /* If this value is already set then do a GPIO update if we can */
         if (dcdc->dvs_gpio && dcdc->on_vsel == vsel)
@@ -315,7 +309,7 @@ static int wm831x_buckv_set_suspend_voltage(struct regulator_dev *rdev,
         u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
         int vsel;
 
-        vsel = wm831x_buckv_select_min_voltage(rdev, uV, uV);
+        vsel = wm831x_buckv_map_voltage(rdev, uV, uV);
         if (vsel < 0)
                 return vsel;
 
@@ -373,9 +367,10 @@ static int wm831x_buckv_get_current_limit(struct regulator_dev *rdev)
 }
 
 static struct regulator_ops wm831x_buckv_ops = {
-        .set_voltage = wm831x_buckv_set_voltage,
+        .set_voltage_sel = wm831x_buckv_set_voltage_sel,
         .get_voltage_sel = wm831x_buckv_get_voltage_sel,
         .list_voltage = wm831x_buckv_list_voltage,
+        .map_voltage = wm831x_buckv_map_voltage,
         .set_suspend_voltage = wm831x_buckv_set_suspend_voltage,
         .set_current_limit = wm831x_buckv_set_current_limit,
         .get_current_limit = wm831x_buckv_get_current_limit,
@@ -599,60 +594,25 @@ static struct platform_driver wm831x_buckv_driver = {
  * BUCKP specifics
  */
 
-static int wm831x_buckp_list_voltage(struct regulator_dev *rdev,
-                                      unsigned selector)
-{
-        if (selector <= WM831X_BUCKP_MAX_SELECTOR)
-                return 850000 + (selector * 25000);
-        else
-                return -EINVAL;
-}
-
-static int wm831x_buckp_set_voltage_int(struct regulator_dev *rdev, int reg,
-                                        int min_uV, int max_uV, int *selector)
+static int wm831x_buckp_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = dcdc->wm831x;
-        u16 vsel;
-
-        if (min_uV <= 34000000)
-                vsel = (min_uV - 850000) / 25000;
-        else
-                return -EINVAL;
-
-        if (wm831x_buckp_list_voltage(rdev, vsel) > max_uV)
-                return -EINVAL;
-
-        *selector = vsel;
-
-        return wm831x_set_bits(wm831x, reg, WM831X_DC3_ON_VSEL_MASK, vsel);
-}
-
-static int wm831x_buckp_set_voltage(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV,
-                                    unsigned *selector)
-{
-        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
-        u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
-
-        return wm831x_buckp_set_voltage_int(rdev, reg, min_uV, max_uV,
-                                            selector);
-}
-
-static int wm831x_buckp_set_suspend_voltage(struct regulator_dev *rdev,
-                                            int uV)
-{
-        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
-        unsigned selector;
+        int sel;
+
+        sel = regulator_map_voltage_linear(rdev, uV, uV);
+        if (sel < 0)
+                return sel;
 
-        return wm831x_buckp_set_voltage_int(rdev, reg, uV, uV, &selector);
+        return wm831x_set_bits(wm831x, reg, WM831X_DC3_ON_VSEL_MASK, sel);
 }
 
 static struct regulator_ops wm831x_buckp_ops = {
-        .set_voltage = wm831x_buckp_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
-        .list_voltage = wm831x_buckp_list_voltage,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
         .set_suspend_voltage = wm831x_buckp_set_suspend_voltage,
 
         .is_enabled = regulator_is_enabled_regmap,
@@ -715,6 +675,8 @@ static __devinit int wm831x_buckp_probe(struct platform_device *pdev)
         dcdc->desc.vsel_mask = WM831X_DC3_ON_VSEL_MASK;
         dcdc->desc.enable_reg = WM831X_DCDC_ENABLE;
         dcdc->desc.enable_mask = 1 << id;
+        dcdc->desc.min_uV = 850000;
+        dcdc->desc.uV_step = 25000;
 
         config.dev = pdev->dev.parent;
         if (pdata)
diff --git a/drivers/regulator/wm831x-ldo.c b/drivers/regulator/wm831x-ldo.c
index a9a28d8ac185..5cb70ca1e98d 100644
--- a/drivers/regulator/wm831x-ldo.c
+++ b/drivers/regulator/wm831x-ldo.c
@@ -78,13 +78,10 @@ static int wm831x_gp_ldo_list_voltage(struct regulator_dev *rdev,
         return -EINVAL;
 }
 
-static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev *rdev, int reg,
-                                         int min_uV, int max_uV,
-                                         unsigned *selector)
+static int wm831x_gp_ldo_map_voltage(struct regulator_dev *rdev,
+                                     int min_uV, int max_uV)
 {
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        struct wm831x *wm831x = ldo->wm831x;
-        int vsel, ret;
+        int volt, vsel;
 
         if (min_uV < 900000)
                 vsel = 0;
@@ -94,36 +91,25 @@ static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev *rdev, int reg,
                 vsel = ((min_uV - 1700000) / 100000)
                         + WM831X_GP_LDO_SELECTOR_LOW + 1;
 
-        ret = wm831x_gp_ldo_list_voltage(rdev, vsel);
-        if (ret < 0)
-                return ret;
-        if (ret < min_uV || ret > max_uV)
+        volt = wm831x_gp_ldo_list_voltage(rdev, vsel);
+        if (volt < min_uV || volt > max_uV)
                 return -EINVAL;
 
-        *selector = vsel;
-
-        return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, vsel);
-}
-
-static int wm831x_gp_ldo_set_voltage(struct regulator_dev *rdev,
-                                     int min_uV, int max_uV,
-                                     unsigned *selector)
-{
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_LDO_ON_CONTROL;
-
-        return wm831x_gp_ldo_set_voltage_int(rdev, reg, min_uV, max_uV,
-                                             selector);
+        return vsel;
 }
 
 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
                                              int uV)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
-        unsigned int selector;
+        struct wm831x *wm831x = ldo->wm831x;
+        int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
 
-        return wm831x_gp_ldo_set_voltage_int(rdev, reg, uV, uV, &selector);
+        sel = wm831x_gp_ldo_map_voltage(rdev, uV, uV);
+        if (sel < 0)
+                return sel;
+
+        return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel);
 }
 
 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
@@ -243,8 +229,9 @@ static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
 
 static struct regulator_ops wm831x_gp_ldo_ops = {
         .list_voltage = wm831x_gp_ldo_list_voltage,
+        .map_voltage = wm831x_gp_ldo_map_voltage,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
-        .set_voltage = wm831x_gp_ldo_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
         .get_mode = wm831x_gp_ldo_get_mode,
         .set_mode = wm831x_gp_ldo_set_mode,
@@ -384,13 +371,10 @@ static int wm831x_aldo_list_voltage(struct regulator_dev *rdev,
         return -EINVAL;
 }
 
-static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
-                                       int min_uV, int max_uV,
-                                       unsigned *selector)
+static int wm831x_aldo_map_voltage(struct regulator_dev *rdev,
+                                   int min_uV, int max_uV)
 {
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        struct wm831x *wm831x = ldo->wm831x;
-        int vsel, ret;
+        int volt, vsel;
 
         if (min_uV < 1000000)
                 vsel = 0;
@@ -400,35 +384,26 @@ static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
                 vsel = ((min_uV - 1700000) / 100000)
                         + WM831X_ALDO_SELECTOR_LOW + 1;
 
-        ret = wm831x_aldo_list_voltage(rdev, vsel);
-        if (ret < 0)
-                return ret;
-        if (ret < min_uV || ret > max_uV)
+        volt = wm831x_aldo_list_voltage(rdev, vsel);
+        if (volt < min_uV || volt > max_uV)
                 return -EINVAL;
 
-        *selector = vsel;
-
-        return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, vsel);
-}
-
-static int wm831x_aldo_set_voltage(struct regulator_dev *rdev,
-                                   int min_uV, int max_uV, unsigned *selector)
-{
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_LDO_ON_CONTROL;
+        return vsel;
 
-        return wm831x_aldo_set_voltage_int(rdev, reg, min_uV, max_uV,
-                                           selector);
 }
 
 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
                                              int uV)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
-        unsigned int selector;
+        struct wm831x *wm831x = ldo->wm831x;
+        int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
+
+        sel = wm831x_aldo_map_voltage(rdev, uV, uV);
+        if (sel < 0)
+                return sel;
 
-        return wm831x_aldo_set_voltage_int(rdev, reg, uV, uV, &selector);
+        return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
 }
 
 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
@@ -506,8 +481,9 @@ static int wm831x_aldo_get_status(struct regulator_dev *rdev)
 
 static struct regulator_ops wm831x_aldo_ops = {
         .list_voltage = wm831x_aldo_list_voltage,
+        .map_voltage = wm831x_aldo_map_voltage,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
-        .set_voltage = wm831x_aldo_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
         .get_mode = wm831x_aldo_get_mode,
         .set_mode = wm831x_aldo_set_mode,
@@ -628,47 +604,18 @@ static struct platform_driver wm831x_aldo_driver = {
 
 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
 
-static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev *rdev,
-                                            int reg,
-                                            int min_uV, int max_uV,
-                                            unsigned *selector)
-{
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        struct wm831x *wm831x = ldo->wm831x;
-        int vsel, ret;
-
-        vsel = (min_uV - 800000) / 50000;
-
-        ret = regulator_list_voltage_linear(rdev, vsel);
-        if (ret < 0)
-                return ret;
-        if (ret < min_uV || ret > max_uV)
-                return -EINVAL;
-
-        *selector = vsel;
-
-        return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, vsel);
-}
-
-static int wm831x_alive_ldo_set_voltage(struct regulator_dev *rdev,
-                                        int min_uV, int max_uV,
-                                        unsigned *selector)
-{
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
-
-        return wm831x_alive_ldo_set_voltage_int(rdev, reg, min_uV, max_uV,
-                                                selector);
-}
-
 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
                                              int uV)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
-        unsigned selector;
+        struct wm831x *wm831x = ldo->wm831x;
+        int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
+
+        sel = regulator_map_voltage_linear(rdev, uV, uV);
+        if (sel < 0)
+                return sel;
 
-        return wm831x_alive_ldo_set_voltage_int(rdev, reg, uV, uV, &selector);
+        return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel);
 }
 
 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
@@ -690,8 +637,9 @@ static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
 
 static struct regulator_ops wm831x_alive_ldo_ops = {
         .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
-        .set_voltage = wm831x_alive_ldo_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
         .get_status = wm831x_alive_ldo_get_status,
 
@@ -753,6 +701,7 @@ static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
         ldo->desc.enable_mask = 1 << id;
         ldo->desc.min_uV = 800000;
         ldo->desc.uV_step = 50000;
+        ldo->desc.enable_time = 1000;
 
         config.dev = pdev->dev.parent;
         if (pdata)
diff --git a/drivers/regulator/wm8350-regulator.c b/drivers/regulator/wm8350-regulator.c
index 94e550dc70b6..7f0fa22ef2aa 100644
--- a/drivers/regulator/wm8350-regulator.c
+++ b/drivers/regulator/wm8350-regulator.c
@@ -108,33 +108,6 @@ static int get_isink_val(int min_uA, int max_uA, u16 *setting)
         return -EINVAL;
 }
 
-static inline int wm8350_ldo_val_to_mvolts(unsigned int val)
-{
-        if (val < 16)
-                return (val * 50) + 900;
-        else
-                return ((val - 16) * 100) + 1800;
-
-}
-
-static inline unsigned int wm8350_ldo_mvolts_to_val(int mV)
-{
-        if (mV < 1800)
-                return (mV - 900) / 50;
-        else
-                return ((mV - 1800) / 100) + 16;
-}
-
-static inline int wm8350_dcdc_val_to_mvolts(unsigned int val)
-{
-        return (val * 25) + 850;
-}
-
-static inline unsigned int wm8350_dcdc_mvolts_to_val(int mV)
-{
-        return (mV - 850) / 25;
-}
-
 static int wm8350_isink_set_current(struct regulator_dev *rdev, int min_uA,
         int max_uA)
 {
@@ -359,104 +332,13 @@ int wm8350_isink_set_flash(struct wm8350 *wm8350, int isink, u16 mode,
 }
 EXPORT_SYMBOL_GPL(wm8350_isink_set_flash);
 
-static int wm8350_dcdc_set_voltage(struct regulator_dev *rdev, int min_uV,
-                                   int max_uV, unsigned *selector)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, dcdc = rdev_get_id(rdev), mV,
-                min_mV = min_uV / 1000, max_mV = max_uV / 1000;
-        u16 val;
-
-        if (min_mV < 850 || min_mV > 4025)
-                return -EINVAL;
-        if (max_mV < 850 || max_mV > 4025)
-                return -EINVAL;
-
-        /* step size is 25mV */
-        mV = (min_mV - 826) / 25;
-        if (wm8350_dcdc_val_to_mvolts(mV) > max_mV)
-                return -EINVAL;
-        BUG_ON(wm8350_dcdc_val_to_mvolts(mV) < min_mV);
-
-        switch (dcdc) {
-        case WM8350_DCDC_1:
-                volt_reg = WM8350_DCDC1_CONTROL;
-                break;
-        case WM8350_DCDC_3:
-                volt_reg = WM8350_DCDC3_CONTROL;
-                break;
-        case WM8350_DCDC_4:
-                volt_reg = WM8350_DCDC4_CONTROL;
-                break;
-        case WM8350_DCDC_6:
-                volt_reg = WM8350_DCDC6_CONTROL;
-                break;
-        case WM8350_DCDC_2:
-        case WM8350_DCDC_5:
-        default:
-                return -EINVAL;
-        }
-
-        *selector = mV;
-
-        /* all DCDCs have same mV bits */
-        val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_DC1_VSEL_MASK;
-        wm8350_reg_write(wm8350, volt_reg, val | mV);
-        return 0;
-}
-
-static int wm8350_dcdc_get_voltage_sel(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, dcdc = rdev_get_id(rdev);
-
-        switch (dcdc) {
-        case WM8350_DCDC_1:
-                volt_reg = WM8350_DCDC1_CONTROL;
-                break;
-        case WM8350_DCDC_3:
-                volt_reg = WM8350_DCDC3_CONTROL;
-                break;
-        case WM8350_DCDC_4:
-                volt_reg = WM8350_DCDC4_CONTROL;
-                break;
-        case WM8350_DCDC_6:
-                volt_reg = WM8350_DCDC6_CONTROL;
-                break;
-        case WM8350_DCDC_2:
-        case WM8350_DCDC_5:
-        default:
-                return -EINVAL;
-        }
-
-        /* all DCDCs have same mV bits */
-        return wm8350_reg_read(wm8350, volt_reg) & WM8350_DC1_VSEL_MASK;
-}
-
-static int wm8350_dcdc_list_voltage(struct regulator_dev *rdev,
-                                    unsigned selector)
-{
-        if (selector > WM8350_DCDC_MAX_VSEL)
-                return -EINVAL;
-        return wm8350_dcdc_val_to_mvolts(selector) * 1000;
-}
-
 static int wm8350_dcdc_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 {
         struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, mV = uV / 1000, dcdc = rdev_get_id(rdev);
+        int sel, volt_reg, dcdc = rdev_get_id(rdev);
         u16 val;
 
-        dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, dcdc, mV);
-
-        if (mV && (mV < 850 || mV > 4025)) {
-                dev_err(wm8350->dev,
-                        "DCDC%d suspend voltage %d mV out of range\n",
-                        dcdc, mV);
-                return -EINVAL;
-        }
-        if (mV == 0)
-                mV = 850;
+        dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, dcdc, uV / 1000);
 
         switch (dcdc) {
         case WM8350_DCDC_1:
@@ -477,10 +359,13 @@ static int wm8350_dcdc_set_suspend_voltage(struct regulator_dev *rdev, int uV)
                 return -EINVAL;
         }
 
+        sel = regulator_map_voltage_linear(rdev, uV, uV);
+        if (sel < 0)
+                return -EINVAL;
+
         /* all DCDCs have same mV bits */
         val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_DC1_VSEL_MASK;
-        wm8350_reg_write(wm8350, volt_reg,
-                         val | wm8350_dcdc_mvolts_to_val(mV));
+        wm8350_reg_write(wm8350, volt_reg, val | sel);
         return 0;
 }
 
@@ -657,19 +542,49 @@ static int wm8350_dcdc_set_suspend_mode(struct regulator_dev *rdev,
         return 0;
 }
 
+static int wm8350_ldo_list_voltage(struct regulator_dev *rdev,
+                                    unsigned selector)
+{
+        if (selector > WM8350_LDO1_VSEL_MASK)
+                return -EINVAL;
+
+        if (selector < 16)
+                return (selector * 50000) + 900000;
+        else
+                return ((selector - 16) * 100000) + 1800000;
+}
+
+static int wm8350_ldo_map_voltage(struct regulator_dev *rdev, int min_uV,
+                                  int max_uV)
+{
+        int volt, sel;
+        int min_mV = min_uV / 1000;
+        int max_mV = max_uV / 1000;
+
+        if (min_mV < 900 || min_mV > 3300)
+                return -EINVAL;
+        if (max_mV < 900 || max_mV > 3300)
+                return -EINVAL;
+
+        if (min_mV < 1800) /* step size is 50mV < 1800mV */
+                sel = DIV_ROUND_UP(min_uV - 900, 50);
+        else /* step size is 100mV > 1800mV */
+                sel = DIV_ROUND_UP(min_uV - 1800, 100) + 16;
+
+        volt = wm8350_ldo_list_voltage(rdev, sel);
+        if (volt < min_uV || volt > max_uV)
+                return -EINVAL;
+
+        return sel;
+}
+
 static int wm8350_ldo_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 {
         struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, mV = uV / 1000, ldo = rdev_get_id(rdev);
+        int sel, volt_reg, ldo = rdev_get_id(rdev);
         u16 val;
 
-        dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, ldo, mV);
-
-        if (mV < 900 || mV > 3300) {
-                dev_err(wm8350->dev, "LDO%d voltage %d mV out of range\n",
-                        ldo, mV);
-                return -EINVAL;
-        }
+        dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, ldo, uV / 1000);
 
         switch (ldo) {
         case WM8350_LDO_1:
@@ -688,10 +603,13 @@ static int wm8350_ldo_set_suspend_voltage(struct regulator_dev *rdev, int uV)
                 return -EINVAL;
         }
 
+        sel = wm8350_ldo_map_voltage(rdev, uV, uV);
+        if (sel < 0)
+                return -EINVAL;
+
         /* all LDOs have same mV bits */
         val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_VSEL_MASK;
-        wm8350_reg_write(wm8350, volt_reg,
-                         val | wm8350_ldo_mvolts_to_val(mV));
+        wm8350_reg_write(wm8350, volt_reg, val | sel);
         return 0;
 }
 
@@ -753,92 +671,6 @@ static int wm8350_ldo_set_suspend_disable(struct regulator_dev *rdev)
         return 0;
 }
 
-static int wm8350_ldo_set_voltage(struct regulator_dev *rdev, int min_uV,
-                                  int max_uV, unsigned *selector)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, ldo = rdev_get_id(rdev), mV, min_mV = min_uV / 1000,
-                max_mV = max_uV / 1000;
-        u16 val;
-
-        if (min_mV < 900 || min_mV > 3300)
-                return -EINVAL;
-        if (max_mV < 900 || max_mV > 3300)
-                return -EINVAL;
-
-        if (min_mV < 1800) {
-                /* step size is 50mV < 1800mV */
-                mV = (min_mV - 851) / 50;
-                if (wm8350_ldo_val_to_mvolts(mV) > max_mV)
-                        return -EINVAL;
-                BUG_ON(wm8350_ldo_val_to_mvolts(mV) < min_mV);
-        } else {
-                /* step size is 100mV > 1800mV */
-                mV = ((min_mV - 1701) / 100) + 16;
-                if (wm8350_ldo_val_to_mvolts(mV) > max_mV)
-                        return -EINVAL;
-                BUG_ON(wm8350_ldo_val_to_mvolts(mV) < min_mV);
-        }
-
-        switch (ldo) {
-        case WM8350_LDO_1:
-                volt_reg = WM8350_LDO1_CONTROL;
-                break;
-        case WM8350_LDO_2:
-                volt_reg = WM8350_LDO2_CONTROL;
-                break;
-        case WM8350_LDO_3:
-                volt_reg = WM8350_LDO3_CONTROL;
-                break;
-        case WM8350_LDO_4:
-                volt_reg = WM8350_LDO4_CONTROL;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        *selector = mV;
-
-        /* all LDOs have same mV bits */
-        val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_VSEL_MASK;
-        wm8350_reg_write(wm8350, volt_reg, val | mV);
-        return 0;
-}
-
-static int wm8350_ldo_get_voltage_sel(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, ldo = rdev_get_id(rdev);
-
-        switch (ldo) {
-        case WM8350_LDO_1:
-                volt_reg = WM8350_LDO1_CONTROL;
-                break;
-        case WM8350_LDO_2:
-                volt_reg = WM8350_LDO2_CONTROL;
-                break;
-        case WM8350_LDO_3:
-                volt_reg = WM8350_LDO3_CONTROL;
-                break;
-        case WM8350_LDO_4:
-                volt_reg = WM8350_LDO4_CONTROL;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        /* all LDOs have same mV bits */
-        return wm8350_reg_read(wm8350, volt_reg) & WM8350_LDO1_VSEL_MASK;
-}
-
-static int wm8350_ldo_list_voltage(struct regulator_dev *rdev,
-                                    unsigned selector)
-{
-        if (selector > WM8350_LDO1_VSEL_MASK)
-                return -EINVAL;
-        return wm8350_ldo_val_to_mvolts(selector) * 1000;
-}
-
 int wm8350_dcdc_set_slot(struct wm8350 *wm8350, int dcdc, u16 start,
                          u16 stop, u16 fault)
 {
@@ -959,63 +791,6 @@ int wm8350_dcdc25_set_mode(struct wm8350 *wm8350, int dcdc, u16 mode,
 }
 EXPORT_SYMBOL_GPL(wm8350_dcdc25_set_mode);
 
-static int wm8350_dcdc_enable(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int dcdc = rdev_get_id(rdev);
-        u16 shift;
-
-        if (dcdc < WM8350_DCDC_1 || dcdc > WM8350_DCDC_6)
-                return -EINVAL;
-
-        shift = dcdc - WM8350_DCDC_1;
-        wm8350_set_bits(wm8350, WM8350_DCDC_LDO_REQUESTED, 1 << shift);
-        return 0;
-}
-
-static int wm8350_dcdc_disable(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int dcdc = rdev_get_id(rdev);
-        u16 shift;
-
-        if (dcdc < WM8350_DCDC_1 || dcdc > WM8350_DCDC_6)
-                return -EINVAL;
-
-        shift = dcdc - WM8350_DCDC_1;
-        wm8350_clear_bits(wm8350, WM8350_DCDC_LDO_REQUESTED, 1 << shift);
-
-        return 0;
-}
-
-static int wm8350_ldo_enable(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int ldo = rdev_get_id(rdev);
-        u16 shift;
-
-        if (ldo < WM8350_LDO_1 || ldo > WM8350_LDO_4)
-                return -EINVAL;
-
-        shift = (ldo - WM8350_LDO_1) + 8;
-        wm8350_set_bits(wm8350, WM8350_DCDC_LDO_REQUESTED, 1 << shift);
-        return 0;
-}
-
-static int wm8350_ldo_disable(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int ldo = rdev_get_id(rdev);
-        u16 shift;
-
-        if (ldo < WM8350_LDO_1 || ldo > WM8350_LDO_4)
-                return -EINVAL;
-
-        shift = (ldo - WM8350_LDO_1) + 8;
-        wm8350_clear_bits(wm8350, WM8350_DCDC_LDO_REQUESTED, 1 << shift);
-        return 0;
-}
-
 static int force_continuous_enable(struct wm8350 *wm8350, int dcdc, int enable)
 {
         int reg = 0, ret;
@@ -1197,42 +972,17 @@ static unsigned int wm8350_dcdc_get_optimum_mode(struct regulator_dev *rdev,
         return mode;
 }
 
-static int wm8350_dcdc_is_enabled(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int dcdc = rdev_get_id(rdev), shift;
-
-        if (dcdc < WM8350_DCDC_1 || dcdc > WM8350_DCDC_6)
-                return -EINVAL;
-
-        shift = dcdc - WM8350_DCDC_1;
-        return wm8350_reg_read(wm8350, WM8350_DCDC_LDO_REQUESTED)
-            & (1 << shift);
-}
-
-static int wm8350_ldo_is_enabled(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int ldo = rdev_get_id(rdev), shift;
-
-        if (ldo < WM8350_LDO_1 || ldo > WM8350_LDO_4)
-                return -EINVAL;
-
-        shift = (ldo - WM8350_LDO_1) + 8;
-        return wm8350_reg_read(wm8350, WM8350_DCDC_LDO_REQUESTED)
-            & (1 << shift);
-}
-
 static struct regulator_ops wm8350_dcdc_ops = {
-        .set_voltage = wm8350_dcdc_set_voltage,
-        .get_voltage_sel = wm8350_dcdc_get_voltage_sel,
-        .list_voltage = wm8350_dcdc_list_voltage,
-        .enable = wm8350_dcdc_enable,
-        .disable = wm8350_dcdc_disable,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
         .get_mode = wm8350_dcdc_get_mode,
         .set_mode = wm8350_dcdc_set_mode,
         .get_optimum_mode = wm8350_dcdc_get_optimum_mode,
-        .is_enabled = wm8350_dcdc_is_enabled,
         .set_suspend_voltage = wm8350_dcdc_set_suspend_voltage,
         .set_suspend_enable = wm8350_dcdc_set_suspend_enable,
         .set_suspend_disable = wm8350_dcdc_set_suspend_disable,
@@ -1240,20 +990,21 @@ static struct regulator_ops wm8350_dcdc_ops = {
 };
 
 static struct regulator_ops wm8350_dcdc2_5_ops = {
-        .enable = wm8350_dcdc_enable,
-        .disable = wm8350_dcdc_disable,
-        .is_enabled = wm8350_dcdc_is_enabled,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
         .set_suspend_enable = wm8350_dcdc25_set_suspend_enable,
         .set_suspend_disable = wm8350_dcdc25_set_suspend_disable,
 };
 
 static struct regulator_ops wm8350_ldo_ops = {
-        .set_voltage = wm8350_ldo_set_voltage,
-        .get_voltage_sel = wm8350_ldo_get_voltage_sel,
+        .map_voltage = wm8350_ldo_map_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .list_voltage = wm8350_ldo_list_voltage,
-        .enable = wm8350_ldo_enable,
-        .disable = wm8350_ldo_disable,
-        .is_enabled = wm8350_ldo_is_enabled,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
         .get_mode = wm8350_ldo_get_mode,
         .set_suspend_voltage = wm8350_ldo_set_suspend_voltage,
         .set_suspend_enable = wm8350_ldo_set_suspend_enable,
@@ -1277,6 +1028,12 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_DC1,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
+                .min_uV = 850000,
+                .uV_step = 25000,
+                .vsel_reg = WM8350_DCDC1_CONTROL,
+                .vsel_mask = WM8350_DC1_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC1_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1285,6 +1042,8 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .ops = &wm8350_dcdc2_5_ops,
                 .irq = WM8350_IRQ_UV_DC2,
                 .type = REGULATOR_VOLTAGE,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC2_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1294,6 +1053,12 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_DC3,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
+                .min_uV = 850000,
+                .uV_step = 25000,
+                .vsel_reg = WM8350_DCDC3_CONTROL,
+                .vsel_mask = WM8350_DC3_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC3_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1303,6 +1068,12 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_DC4,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
+                .min_uV = 850000,
+                .uV_step = 25000,
+                .vsel_reg = WM8350_DCDC4_CONTROL,
+                .vsel_mask = WM8350_DC4_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC4_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1311,6 +1082,8 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .ops = &wm8350_dcdc2_5_ops,
                 .irq = WM8350_IRQ_UV_DC5,
                 .type = REGULATOR_VOLTAGE,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC5_ENA,
                 .owner = THIS_MODULE,
          },
         {
@@ -1320,6 +1093,12 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_DC6,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
+                .min_uV = 850000,
+                .uV_step = 25000,
+                .vsel_reg = WM8350_DCDC6_CONTROL,
+                .vsel_mask = WM8350_DC6_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC6_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1329,6 +1108,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_LDO1,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_LDO1_VSEL_MASK + 1,
+                .vsel_reg = WM8350_LDO1_CONTROL,
+                .vsel_mask = WM8350_LDO1_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_LDO1_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1338,6 +1121,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_LDO2,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_LDO2_VSEL_MASK + 1,
+                .vsel_reg = WM8350_LDO2_CONTROL,
+                .vsel_mask = WM8350_LDO2_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_LDO2_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1347,6 +1134,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_LDO3,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_LDO3_VSEL_MASK + 1,
+                .vsel_reg = WM8350_LDO3_CONTROL,
+                .vsel_mask = WM8350_LDO3_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_LDO3_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1356,6 +1147,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_LDO4,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_LDO4_VSEL_MASK + 1,
+                .vsel_reg = WM8350_LDO4_CONTROL,
+                .vsel_mask = WM8350_LDO4_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_LDO4_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1429,6 +1224,7 @@ static int wm8350_regulator_probe(struct platform_device *pdev)
         config.dev = &pdev->dev;
         config.init_data = pdev->dev.platform_data;
         config.driver_data = dev_get_drvdata(&pdev->dev);
+        config.regmap = wm8350->regmap;
 
         /* register regulator */
         rdev = regulator_register(&wm8350_reg[pdev->id], &config);
diff --git a/drivers/regulator/wm8400-regulator.c b/drivers/regulator/wm8400-regulator.c
index 69a2b7ce5e4a..9035dd053611 100644
--- a/drivers/regulator/wm8400-regulator.c
+++ b/drivers/regulator/wm8400-regulator.c
@@ -28,34 +28,26 @@ static int wm8400_ldo_list_voltage(struct regulator_dev *dev,
         if (selector < 15)
                 return 900000 + (selector * 50000);
         else
-                return 1600000 + ((selector - 14) * 100000);
+                return 1700000 + ((selector - 15) * 100000);
 }
 
 static int wm8400_ldo_map_voltage(struct regulator_dev *dev,
                                   int min_uV, int max_uV)
 {
         u16 val;
+        int volt;
 
         if (min_uV < 900000 || min_uV > 3300000)
                 return -EINVAL;
 
-        if (min_uV < 1700000) {
-                /* Steps of 50mV from 900mV;  */
+        if (min_uV < 1700000) /* Steps of 50mV from 900mV;  */
                 val = DIV_ROUND_UP(min_uV - 900000, 50000);
+        else /* Steps of 100mV from 1700mV */
+                val = DIV_ROUND_UP(min_uV - 1700000, 100000) + 15;
 
-                if ((val * 50000) + 900000 > max_uV)
-                        return -EINVAL;
-                BUG_ON((val * 50000) + 900000 < min_uV);
-        } else {
-                /* Steps of 100mV from 1700mV */
-                val = DIV_ROUND_UP(min_uV - 1700000, 100000);
-
-                if ((val * 100000) + 1700000 > max_uV)
-                        return -EINVAL;
-                BUG_ON((val * 100000) + 1700000 < min_uV);
-
-                val += 0xf;
-        }
+        volt = wm8400_ldo_list_voltage(dev, val);
+        if (volt < min_uV || volt > max_uV)
+                return -EINVAL;
 
         return val;
 }
@@ -152,6 +144,7 @@ static struct regulator_ops wm8400_dcdc_ops = {
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
         .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .get_mode = wm8400_dcdc_get_mode,
diff --git a/drivers/regulator/wm8994-regulator.c b/drivers/regulator/wm8994-regulator.c
index 9a994316e63c..86bb48db149e 100644
--- a/drivers/regulator/wm8994-regulator.c
+++ b/drivers/regulator/wm8994-regulator.c
@@ -26,8 +26,6 @@
 #include <linux/mfd/wm8994/pdata.h>
 
 struct wm8994_ldo {
-        int enable;
-        bool is_enabled;
         struct regulator_dev *regulator;
         struct wm8994 *wm8994;
 };
@@ -35,64 +33,9 @@ struct wm8994_ldo {
 #define WM8994_LDO1_MAX_SELECTOR 0x7
 #define WM8994_LDO2_MAX_SELECTOR 0x3
 
-static int wm8994_ldo_enable(struct regulator_dev *rdev)
-{
-        struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
-
-        /* If we have no soft control assume that the LDO is always enabled. */
-        if (!ldo->enable)
-                return 0;
-
-        gpio_set_value_cansleep(ldo->enable, 1);
-        ldo->is_enabled = true;
-
-        return 0;
-}
-
-static int wm8994_ldo_disable(struct regulator_dev *rdev)
-{
-        struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
-
-        /* If we have no soft control assume that the LDO is always enabled. */
-        if (!ldo->enable)
-                return -EINVAL;
-
-        gpio_set_value_cansleep(ldo->enable, 0);
-        ldo->is_enabled = false;
-
-        return 0;
-}
-
-static int wm8994_ldo_is_enabled(struct regulator_dev *rdev)
-{
-        struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
-
-        return ldo->is_enabled;
-}
-
-static int wm8994_ldo_enable_time(struct regulator_dev *rdev)
-{
-        /* 3ms is fairly conservative but this shouldn't be too performance
-         * critical; can be tweaked per-system if required. */
-        return 3000;
-}
-
-static int wm8994_ldo1_list_voltage(struct regulator_dev *rdev,
-                                    unsigned int selector)
-{
-        if (selector > WM8994_LDO1_MAX_SELECTOR)
-                return -EINVAL;
-
-        return (selector * 100000) + 2400000;
-}
-
 static struct regulator_ops wm8994_ldo1_ops = {
-        .enable = wm8994_ldo_enable,
-        .disable = wm8994_ldo_disable,
-        .is_enabled = wm8994_ldo_is_enabled,
-        .enable_time = wm8994_ldo_enable_time,
-
-        .list_voltage = wm8994_ldo1_list_voltage,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 };
@@ -124,11 +67,6 @@ static int wm8994_ldo2_list_voltage(struct regulator_dev *rdev,
 }
 
 static struct regulator_ops wm8994_ldo2_ops = {
-        .enable = wm8994_ldo_enable,
-        .disable = wm8994_ldo_disable,
-        .is_enabled = wm8994_ldo_is_enabled,
-        .enable_time = wm8994_ldo_enable_time,
-
         .list_voltage = wm8994_ldo2_list_voltage,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = regulator_set_voltage_sel_regmap,
@@ -143,6 +81,9 @@ static const struct regulator_desc wm8994_ldo_desc[] = {
                 .vsel_reg = WM8994_LDO_1,
                 .vsel_mask = WM8994_LDO1_VSEL_MASK,
                 .ops = &wm8994_ldo1_ops,
+                .min_uV = 2400000,
+                .uV_step = 100000,
+                .enable_time = 3000,
                 .owner = THIS_MODULE,
         },
         {
@@ -153,6 +94,7 @@ static const struct regulator_desc wm8994_ldo_desc[] = {
                 .vsel_reg = WM8994_LDO_2,
                 .vsel_mask = WM8994_LDO2_VSEL_MASK,
                 .ops = &wm8994_ldo2_ops,
+                .enable_time = 3000,
                 .owner = THIS_MODULE,
         },
 };
@@ -176,39 +118,26 @@ static __devinit int wm8994_ldo_probe(struct platform_device *pdev)
 
         ldo->wm8994 = wm8994;
 
-        if (pdata->ldo[id].enable && gpio_is_valid(pdata->ldo[id].enable)) {
-                ldo->enable = pdata->ldo[id].enable;
-
-                ret = gpio_request_one(ldo->enable, 0, "WM8994 LDO enable");
-                if (ret < 0) {
-                        dev_err(&pdev->dev, "Failed to get enable GPIO: %d\n",
-                                ret);
-                        goto err;
-                }
-        } else
-                ldo->is_enabled = true;
-
         config.dev = wm8994->dev;
         config.driver_data = ldo;
         config.regmap = wm8994->regmap;
-        if (pdata)
+        if (pdata) {
                 config.init_data = pdata->ldo[id].init_data;
+                config.ena_gpio = pdata->ldo[id].enable;
+        }
 
         ldo->regulator = regulator_register(&wm8994_ldo_desc[id], &config);
         if (IS_ERR(ldo->regulator)) {
                 ret = PTR_ERR(ldo->regulator);
                 dev_err(wm8994->dev, "Failed to register LDO%d: %d\n",
                         id + 1, ret);
-                goto err_gpio;
+                goto err;
         }
 
         platform_set_drvdata(pdev, ldo);
 
         return 0;
 
-err_gpio:
-        if (gpio_is_valid(ldo->enable))
-                gpio_free(ldo->enable);
 err:
         return ret;
 }
@@ -220,8 +149,6 @@ static __devexit int wm8994_ldo_remove(struct platform_device *pdev)
         platform_set_drvdata(pdev, NULL);
 
         regulator_unregister(ldo->regulator);
-        if (gpio_is_valid(ldo->enable))
-                gpio_free(ldo->enable);
 
         return 0;
 }
diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig
index 24d880e78ec6..f8d818abf98c 100644
--- a/drivers/remoteproc/Kconfig
+++ b/drivers/remoteproc/Kconfig
@@ -4,9 +4,11 @@ menu "Remoteproc drivers (EXPERIMENTAL)"
 config REMOTEPROC
         tristate
         depends on EXPERIMENTAL
+        select FW_CONFIG
 
 config OMAP_REMOTEPROC
         tristate "OMAP remoteproc support"
+        depends on EXPERIMENTAL
         depends on ARCH_OMAP4
         depends on OMAP_IOMMU
         select REMOTEPROC
diff --git a/drivers/rpmsg/virtio_rpmsg_bus.c b/drivers/rpmsg/virtio_rpmsg_bus.c
index 75506ec2840e..f56c8ba3a861 100644
--- a/drivers/rpmsg/virtio_rpmsg_bus.c
+++ b/drivers/rpmsg/virtio_rpmsg_bus.c
@@ -188,6 +188,26 @@ static int rpmsg_uevent(struct device *dev, struct kobj_uevent_env *env)
                                         rpdev->id.name);
 }
 
+/**
+ * __ept_release() - deallocate an rpmsg endpoint
+ * @kref: the ept's reference count
+ *
+ * This function deallocates an ept, and is invoked when its @kref refcount
+ * drops to zero.
+ *
+ * Never invoke this function directly!
+ */
+static void __ept_release(struct kref *kref)
+{
+        struct rpmsg_endpoint *ept = container_of(kref, struct rpmsg_endpoint,
+                                                  refcount);
+        /*
+         * At this point no one holds a reference to ept anymore,
+         * so we can directly free it
+         */
+        kfree(ept);
+}
+
 /* for more info, see below documentation of rpmsg_create_ept() */
 static struct rpmsg_endpoint *__rpmsg_create_ept(struct virtproc_info *vrp,
                 struct rpmsg_channel *rpdev, rpmsg_rx_cb_t cb,
@@ -206,6 +226,9 @@ static struct rpmsg_endpoint *__rpmsg_create_ept(struct virtproc_info *vrp,
                 return NULL;
         }
 
+        kref_init(&ept->refcount);
+        mutex_init(&ept->cb_lock);
+
         ept->rpdev = rpdev;
         ept->cb = cb;
         ept->priv = priv;
@@ -238,7 +261,7 @@ rem_idr:
         idr_remove(&vrp->endpoints, request);
 free_ept:
         mutex_unlock(&vrp->endpoints_lock);
-        kfree(ept);
+        kref_put(&ept->refcount, __ept_release);
         return NULL;
 }
 
@@ -302,11 +325,17 @@ EXPORT_SYMBOL(rpmsg_create_ept);
 static void
 __rpmsg_destroy_ept(struct virtproc_info *vrp, struct rpmsg_endpoint *ept)
 {
+        /* make sure new inbound messages can't find this ept anymore */
         mutex_lock(&vrp->endpoints_lock);
         idr_remove(&vrp->endpoints, ept->addr);
         mutex_unlock(&vrp->endpoints_lock);
 
-        kfree(ept);
+        /* make sure in-flight inbound messages won't invoke cb anymore */
+        mutex_lock(&ept->cb_lock);
+        ept->cb = NULL;
+        mutex_unlock(&ept->cb_lock);
+
+        kref_put(&ept->refcount, __ept_release);
 }
 
 /**
@@ -790,12 +819,28 @@ static void rpmsg_recv_done(struct virtqueue *rvq)
 
         /* use the dst addr to fetch the callback of the appropriate user */
         mutex_lock(&vrp->endpoints_lock);
+
         ept = idr_find(&vrp->endpoints, msg->dst);
+
+        /* let's make sure no one deallocates ept while we use it */
+        if (ept)
+                kref_get(&ept->refcount);
+
         mutex_unlock(&vrp->endpoints_lock);
 
-        if (ept && ept->cb)
-                ept->cb(ept->rpdev, msg->data, msg->len, ept->priv, msg->src);
-        else
+        if (ept) {
+                /* make sure ept->cb doesn't go away while we use it */
+                mutex_lock(&ept->cb_lock);
+
+                if (ept->cb)
+                        ept->cb(ept->rpdev, msg->data, msg->len, ept->priv,
+                                msg->src);
+
+                mutex_unlock(&ept->cb_lock);
+
+                /* farewell, ept, we don't need you anymore */
+                kref_put(&ept->refcount, __ept_release);
+        } else
                 dev_warn(dev, "msg received with no recepient\n");
 
         /* publish the real size of the buffer */
@@ -1040,7 +1085,7 @@ static int __init rpmsg_init(void)
 
         return ret;
 }
-module_init(rpmsg_init);
+subsys_initcall(rpmsg_init);
 
 static void __exit rpmsg_fini(void)
 {
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
index 4bcf9ca2818a..370889d0489b 100644
--- a/drivers/rtc/rtc-ab8500.c
+++ b/drivers/rtc/rtc-ab8500.c
@@ -17,6 +17,7 @@
 #include <linux/mfd/abx500.h>
 #include <linux/mfd/abx500/ab8500.h>
 #include <linux/delay.h>
+#include <linux/of.h>
 
 #define AB8500_RTC_SOFF_STAT_REG        0x00
 #define AB8500_RTC_CC_CONF_REG          0x01
@@ -422,7 +423,7 @@ static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
         }
 
         err = request_threaded_irq(irq, NULL, rtc_alarm_handler,
-                IRQF_NO_SUSPEND, "ab8500-rtc", rtc);
+                IRQF_NO_SUSPEND | IRQF_ONESHOT, "ab8500-rtc", rtc);
         if (err < 0) {
                 rtc_device_unregister(rtc);
                 return err;
@@ -430,7 +431,6 @@ static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, rtc);
 
-
         err = ab8500_sysfs_rtc_register(&pdev->dev);
         if (err) {
                 dev_err(&pdev->dev, "sysfs RTC failed to register\n");
@@ -454,10 +454,16 @@ static int __devexit ab8500_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
+static const struct of_device_id ab8500_rtc_match[] = {
+        { .compatible = "stericsson,ab8500-rtc", },
+        {}
+};
+
 static struct platform_driver ab8500_rtc_driver = {
         .driver = {
                 .name = "ab8500-rtc",
                 .owner = THIS_MODULE,
+                .of_match_table = ab8500_rtc_match,
         },
         .probe  = ab8500_rtc_probe,
         .remove = __devexit_p(ab8500_rtc_remove),
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 4267789ca995..132333d75408 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -568,6 +568,7 @@ static irqreturn_t cmos_interrupt(int irq, void *p)
                 hpet_mask_rtc_irq_bit(RTC_AIE);
 
                 CMOS_READ(RTC_INTR_FLAGS);
+                pm_wakeup_event(cmos_rtc.dev, 0);
         }
         spin_unlock(&rtc_lock);
 
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 5e1d64ee5228..e3e50d69baf8 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -202,10 +202,11 @@ static irqreturn_t mxc_rtc_interrupt(int irq, void *dev_id)
         struct platform_device *pdev = dev_id;
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
+        unsigned long flags;
         u32 status;
         u32 events = 0;
 
-        spin_lock_irq(&pdata->rtc->irq_lock);
+        spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
         status = readw(ioaddr + RTC_RTCISR) & readw(ioaddr + RTC_RTCIENR);
         /* clear interrupt sources */
         writew(status, ioaddr + RTC_RTCISR);
@@ -224,7 +225,7 @@ static irqreturn_t mxc_rtc_interrupt(int irq, void *dev_id)
                 events |= (RTC_PF | RTC_IRQF);
 
         rtc_update_irq(pdata->rtc, 1, events);
-        spin_unlock_irq(&pdata->rtc->irq_lock);
+        spin_unlock_irqrestore(&pdata->rtc->irq_lock, flags);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/rtc/rtc-spear.c b/drivers/rtc/rtc-spear.c
index 1f76320e545b..e2785479113c 100644
--- a/drivers/rtc/rtc-spear.c
+++ b/drivers/rtc/rtc-spear.c
@@ -458,12 +458,12 @@ static int __devexit spear_rtc_remove(struct platform_device *pdev)
         clk_disable(config->clk);
         clk_put(config->clk);
         iounmap(config->ioaddr);
-        kfree(config);
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (res)
                 release_mem_region(res->start, resource_size(res));
         platform_set_drvdata(pdev, NULL);
         rtc_device_unregister(config->rtc);
+        kfree(config);
 
         return 0;
 }
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index 258abeabf624..c5d06fe83bba 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -510,7 +510,7 @@ static int __devinit twl_rtc_probe(struct platform_device *pdev)
         }
 
         ret = request_threaded_irq(irq, NULL, twl_rtc_interrupt,
-                                   IRQF_TRIGGER_RISING,
+                                   IRQF_TRIGGER_RISING | IRQF_ONESHOT,
                                    dev_name(&rtc->dev), rtc);
         if (ret < 0) {
                 dev_err(&pdev->dev, "IRQ is not free.\n");
diff --git a/drivers/scsi/aic94xx/aic94xx_task.c b/drivers/scsi/aic94xx/aic94xx_task.c
index 532d212b6b2c..393e7ce8e95a 100644
--- a/drivers/scsi/aic94xx/aic94xx_task.c
+++ b/drivers/scsi/aic94xx/aic94xx_task.c
@@ -201,7 +201,7 @@ static void asd_get_response_tasklet(struct asd_ascb *ascb,
 
                 if (SAS_STATUS_BUF_SIZE >= sizeof(*resp)) {
                         resp->frame_len = le16_to_cpu(*(__le16 *)(r+6));
-                        memcpy(&resp->ending_fis[0], r+16, 24);
+                        memcpy(&resp->ending_fis[0], r+16, ATA_RESP_FIS_SIZE);
                         ts->buf_valid_size = sizeof(*resp);
                 }
         }
diff --git a/drivers/scsi/bnx2i/bnx2i.h b/drivers/scsi/bnx2i/bnx2i.h
index 0c53c28dc3d3..7e77cf620291 100644
--- a/drivers/scsi/bnx2i/bnx2i.h
+++ b/drivers/scsi/bnx2i/bnx2i.h
@@ -350,6 +350,7 @@ struct bnx2i_hba {
         struct pci_dev *pcidev;
         struct net_device *netdev;
         void __iomem *regview;
+        resource_size_t reg_base;
 
         u32 age;
         unsigned long cnic_dev_type;
diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
index ece47e502282..86a12b48e477 100644
--- a/drivers/scsi/bnx2i/bnx2i_hwi.c
+++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
@@ -2724,7 +2724,6 @@ int bnx2i_map_ep_dbell_regs(struct bnx2i_endpoint *ep)
                 goto arm_cq;
         }
 
-        reg_base = ep->hba->netdev->base_addr;
         if ((test_bit(BNX2I_NX2_DEV_5709, &ep->hba->cnic_dev_type)) &&
             (ep->hba->mail_queue_access == BNX2I_MQ_BIN_MODE)) {
                 config2 = REG_RD(ep->hba, BNX2_MQ_CONFIG2);
@@ -2740,7 +2739,7 @@ int bnx2i_map_ep_dbell_regs(struct bnx2i_endpoint *ep)
                 /* 5709 device in normal node and 5706/5708 devices */
                 reg_off = CTX_OFFSET + (MB_KERNEL_CTX_SIZE * cid_num);
 
-        ep->qp.ctx_base = ioremap_nocache(reg_base + reg_off,
+        ep->qp.ctx_base = ioremap_nocache(ep->hba->reg_base + reg_off,
                                           MB_KERNEL_CTX_SIZE);
         if (!ep->qp.ctx_base)
                 return -ENOMEM;
diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
index f8d516b53161..621538b8b544 100644
--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
+++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
@@ -811,13 +811,13 @@ struct bnx2i_hba *bnx2i_alloc_hba(struct cnic_dev *cnic)
         bnx2i_identify_device(hba);
         bnx2i_setup_host_queue_size(hba, shost);
 
+        hba->reg_base = pci_resource_start(hba->pcidev, 0);
         if (test_bit(BNX2I_NX2_DEV_5709, &hba->cnic_dev_type)) {
-                hba->regview = ioremap_nocache(hba->netdev->base_addr,
-                                               BNX2_MQ_CONFIG2);
+                hba->regview = pci_iomap(hba->pcidev, 0, BNX2_MQ_CONFIG2);
                 if (!hba->regview)
                         goto ioreg_map_err;
         } else if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type)) {
-                hba->regview = ioremap_nocache(hba->netdev->base_addr, 4096);
+                hba->regview = pci_iomap(hba->pcidev, 0, 4096);
                 if (!hba->regview)
                         goto ioreg_map_err;
         }
@@ -884,7 +884,7 @@ cid_que_err:
         bnx2i_free_mp_bdt(hba);
 mp_bdt_mem_err:
         if (hba->regview) {
-                iounmap(hba->regview);
+                pci_iounmap(hba->pcidev, hba->regview);
                 hba->regview = NULL;
         }
 ioreg_map_err:
@@ -910,7 +910,7 @@ void bnx2i_free_hba(struct bnx2i_hba *hba)
         pci_dev_put(hba->pcidev);
 
         if (hba->regview) {
-                iounmap(hba->regview);
+                pci_iounmap(hba->pcidev, hba->regview);
                 hba->regview = NULL;
         }
         bnx2i_free_mp_bdt(hba);
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index 441d88ad99a7..d109cc3a17b6 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -139,12 +139,12 @@ static void sas_ata_task_done(struct sas_task *task)
         if (stat->stat == SAS_PROTO_RESPONSE || stat->stat == SAM_STAT_GOOD ||
             ((stat->stat == SAM_STAT_CHECK_CONDITION &&
               dev->sata_dev.command_set == ATAPI_COMMAND_SET))) {
-                ata_tf_from_fis(resp->ending_fis, &dev->sata_dev.tf);
+                memcpy(dev->sata_dev.fis, resp->ending_fis, ATA_RESP_FIS_SIZE);
 
                 if (!link->sactive) {
-                        qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command);
+                        qc->err_mask |= ac_err_mask(dev->sata_dev.fis[2]);
                 } else {
-                        link->eh_info.err_mask |= ac_err_mask(dev->sata_dev.tf.command);
+                        link->eh_info.err_mask |= ac_err_mask(dev->sata_dev.fis[2]);
                         if (unlikely(link->eh_info.err_mask))
                                 qc->flags |= ATA_QCFLAG_FAILED;
                 }
@@ -161,8 +161,8 @@ static void sas_ata_task_done(struct sas_task *task)
                                 qc->flags |= ATA_QCFLAG_FAILED;
                         }
 
-                        dev->sata_dev.tf.feature = 0x04; /* status err */
-                        dev->sata_dev.tf.command = ATA_ERR;
+                        dev->sata_dev.fis[3] = 0x04; /* status err */
+                        dev->sata_dev.fis[2] = ATA_ERR;
                 }
         }
 
@@ -269,7 +269,7 @@ static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd *qc)
 {
         struct domain_device *dev = qc->ap->private_data;
 
-        memcpy(&qc->result_tf, &dev->sata_dev.tf, sizeof(qc->result_tf));
+        ata_tf_from_fis(dev->sata_dev.fis, &qc->result_tf);
         return true;
 }
 
diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c
index 6986552b47e6..5b30132960c7 100644
--- a/drivers/scsi/qla2xxx/qla_target.c
+++ b/drivers/scsi/qla2xxx/qla_target.c
@@ -2643,19 +2643,9 @@ static void qlt_do_work(struct work_struct *work)
         spin_lock_irqsave(&ha->hardware_lock, flags);
         sess = ha->tgt.tgt_ops->find_sess_by_s_id(vha,
             atio->u.isp24.fcp_hdr.s_id);
-        if (sess) {
-                if (unlikely(sess->tearing_down)) {
-                        sess = NULL;
-                        spin_unlock_irqrestore(&ha->hardware_lock, flags);
-                        goto out_term;
-                } else {
-                        /*
-                         * Do the extra kref_get() before dropping
-                         * qla_hw_data->hardware_lock.
-                         */
-                        kref_get(&sess->se_sess->sess_kref);
-                }
-        }
+        /* Do kref_get() before dropping qla_hw_data->hardware_lock. */
+        if (sess)
+                kref_get(&sess->se_sess->sess_kref);
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         if (unlikely(!sess)) {
@@ -3960,7 +3950,7 @@ void qlt_async_event(uint16_t code, struct scsi_qla_host *vha,
 {
         struct qla_hw_data *ha = vha->hw;
         struct qla_tgt *tgt = ha->tgt.qla_tgt;
-        int reason_code;
+        int login_code;
 
         ql_dbg(ql_dbg_tgt, vha, 0xe039,
             "scsi(%ld): ha state %d init_done %d oper_mode %d topo %d\n",
@@ -4003,9 +3993,9 @@ void qlt_async_event(uint16_t code, struct scsi_qla_host *vha,
         {
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03b,
                     "qla_target(%d): Async LOOP_UP occured "
-                    "(m[1]=%x, m[2]=%x, m[3]=%x, m[4]=%x)", vha->vp_idx,
-                    le16_to_cpu(mailbox[1]), le16_to_cpu(mailbox[2]),
-                    le16_to_cpu(mailbox[3]), le16_to_cpu(mailbox[4]));
+                    "(m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha->vp_idx,
+                    le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
+                    le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
                 if (tgt->link_reinit_iocb_pending) {
                         qlt_send_notify_ack(vha, (void *)&tgt->link_reinit_iocb,
                             0, 0, 0, 0, 0, 0);
@@ -4020,23 +4010,24 @@ void qlt_async_event(uint16_t code, struct scsi_qla_host *vha,
         case MBA_RSCN_UPDATE:
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03c,
                     "qla_target(%d): Async event %#x occured "
-                    "(m[1]=%x, m[2]=%x, m[3]=%x, m[4]=%x)", vha->vp_idx, code,
-                    le16_to_cpu(mailbox[1]), le16_to_cpu(mailbox[2]),
-                    le16_to_cpu(mailbox[3]), le16_to_cpu(mailbox[4]));
+                    "(m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha->vp_idx, code,
+                    le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
+                    le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
                 break;
 
         case MBA_PORT_UPDATE:
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03d,
                     "qla_target(%d): Port update async event %#x "
-                    "occured: updating the ports database (m[1]=%x, m[2]=%x, "
-                    "m[3]=%x, m[4]=%x)", vha->vp_idx, code,
-                    le16_to_cpu(mailbox[1]), le16_to_cpu(mailbox[2]),
-                    le16_to_cpu(mailbox[3]), le16_to_cpu(mailbox[4]));
-                reason_code = le16_to_cpu(mailbox[2]);
-                if (reason_code == 0x4)
+                    "occured: updating the ports database (m[0]=%x, m[1]=%x, "
+                    "m[2]=%x, m[3]=%x)", vha->vp_idx, code,
+                    le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
+                    le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
+
+                login_code = le16_to_cpu(mailbox[2]);
+                if (login_code == 0x4)
                         ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03e,
                             "Async MB 2: Got PLOGI Complete\n");
-                else if (reason_code == 0x7)
+                else if (login_code == 0x7)
                         ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03f,
                             "Async MB 2: Port Logged Out\n");
                 break;
@@ -4044,9 +4035,9 @@ void qlt_async_event(uint16_t code, struct scsi_qla_host *vha,
         default:
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf040,
                     "qla_target(%d): Async event %#x occured: "
-                    "ignore (m[1]=%x, m[2]=%x, m[3]=%x, m[4]=%x)", vha->vp_idx,
-                    code, le16_to_cpu(mailbox[1]), le16_to_cpu(mailbox[2]),
-                    le16_to_cpu(mailbox[3]), le16_to_cpu(mailbox[4]));
+                    "ignore (m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha->vp_idx,
+                    code, le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
+                    le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
                 break;
         }
 
diff --git a/drivers/scsi/qla2xxx/qla_target.h b/drivers/scsi/qla2xxx/qla_target.h
index 9f9ef1644fd9..170af1571214 100644
--- a/drivers/scsi/qla2xxx/qla_target.h
+++ b/drivers/scsi/qla2xxx/qla_target.h
@@ -639,7 +639,7 @@ struct qla_tgt_func_tmpl {
 
         int (*handle_cmd)(struct scsi_qla_host *, struct qla_tgt_cmd *,
                         unsigned char *, uint32_t, int, int, int);
-        int (*handle_data)(struct qla_tgt_cmd *);
+        void (*handle_data)(struct qla_tgt_cmd *);
         int (*handle_tmr)(struct qla_tgt_mgmt_cmd *, uint32_t, uint8_t,
                         uint32_t);
         void (*free_cmd)(struct qla_tgt_cmd *);
@@ -813,7 +813,6 @@ struct qla_tgt_sess {
         unsigned int conf_compl_supported:1;
         unsigned int deleted:1;
         unsigned int local:1;
-        unsigned int tearing_down:1;
 
         struct se_session *se_sess;
         struct scsi_qla_host *vha;
diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.c b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
index 6e64314dbbb3..4752f65a9272 100644
--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c
+++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
@@ -38,8 +38,6 @@
 #include <linux/string.h>
 #include <linux/configfs.h>
 #include <linux/ctype.h>
-#include <linux/string.h>
-#include <linux/ctype.h>
 #include <asm/unaligned.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
@@ -466,8 +464,7 @@ static int tcm_qla2xxx_shutdown_session(struct se_session *se_sess)
         vha = sess->vha;
 
         spin_lock_irqsave(&vha->hw->hardware_lock, flags);
-        sess->tearing_down = 1;
-        target_splice_sess_cmd_list(se_sess);
+        target_sess_cmd_list_set_waiting(se_sess);
         spin_unlock_irqrestore(&vha->hw->hardware_lock, flags);
 
         return 1;
@@ -600,28 +597,15 @@ static int tcm_qla2xxx_handle_cmd(scsi_qla_host_t *vha, struct qla_tgt_cmd *cmd,
                 return -EINVAL;
         }
 
-        target_submit_cmd(se_cmd, se_sess, cdb, &cmd->sense_buffer[0],
+        return target_submit_cmd(se_cmd, se_sess, cdb, &cmd->sense_buffer[0],
                                 cmd->unpacked_lun, data_length, fcp_task_attr,
                                 data_dir, flags);
-        return 0;
 }
 
-static void tcm_qla2xxx_do_rsp(struct work_struct *work)
+static void tcm_qla2xxx_handle_data_work(struct work_struct *work)
 {
         struct qla_tgt_cmd *cmd = container_of(work, struct qla_tgt_cmd, work);
-        /*
-         * Dispatch ->queue_status from workqueue process context
-         */
-        transport_generic_request_failure(&cmd->se_cmd);
-}
 
-/*
- * Called from qla_target.c:qlt_do_ctio_completion()
- */
-static int tcm_qla2xxx_handle_data(struct qla_tgt_cmd *cmd)
-{
-        struct se_cmd *se_cmd = &cmd->se_cmd;
-        unsigned long flags;
         /*
          * Ensure that the complete FCP WRITE payload has been received.
          * Otherwise return an exception via CHECK_CONDITION status.
@@ -631,24 +615,26 @@ static int tcm_qla2xxx_handle_data(struct qla_tgt_cmd *cmd)
                  * Check if se_cmd has already been aborted via LUN_RESET, and
                  * waiting upon completion in tcm_qla2xxx_write_pending_status()
                  */
-                spin_lock_irqsave(&se_cmd->t_state_lock, flags);
-                if (se_cmd->transport_state & CMD_T_ABORTED) {
-                        spin_unlock_irqrestore(&se_cmd->t_state_lock, flags);
-                        complete(&se_cmd->t_transport_stop_comp);
-                        return 0;
+                if (cmd->se_cmd.transport_state & CMD_T_ABORTED) {
+                        complete(&cmd->se_cmd.t_transport_stop_comp);
+                        return;
                 }
-                spin_unlock_irqrestore(&se_cmd->t_state_lock, flags);
 
-                se_cmd->scsi_sense_reason = TCM_CHECK_CONDITION_ABORT_CMD;
-                INIT_WORK(&cmd->work, tcm_qla2xxx_do_rsp);
-                queue_work(tcm_qla2xxx_free_wq, &cmd->work);
-                return 0;
+                cmd->se_cmd.scsi_sense_reason = TCM_CHECK_CONDITION_ABORT_CMD;
+                transport_generic_request_failure(&cmd->se_cmd);
+                return;
         }
-        /*
-         * We now tell TCM to queue this WRITE CDB with TRANSPORT_PROCESS_WRITE
-         * status to the backstore processing thread.
-         */
-        return transport_generic_handle_data(&cmd->se_cmd);
+
+        return target_execute_cmd(&cmd->se_cmd);
+}
+
+/*
+ * Called from qla_target.c:qlt_do_ctio_completion()
+ */
+static void tcm_qla2xxx_handle_data(struct qla_tgt_cmd *cmd)
+{
+        INIT_WORK(&cmd->work, tcm_qla2xxx_handle_data_work);
+        queue_work(tcm_qla2xxx_free_wq, &cmd->work);
 }
 
 /*
@@ -1690,7 +1676,6 @@ static struct target_core_fabric_ops tcm_qla2xxx_ops = {
         .tpg_alloc_fabric_acl           = tcm_qla2xxx_alloc_fabric_acl,
         .tpg_release_fabric_acl         = tcm_qla2xxx_release_fabric_acl,
         .tpg_get_inst_index             = tcm_qla2xxx_tpg_get_inst_index,
-        .new_cmd_map                    = NULL,
         .check_stop_free                = tcm_qla2xxx_check_stop_free,
         .release_cmd                    = tcm_qla2xxx_release_cmd,
         .put_session                    = tcm_qla2xxx_put_session,
diff --git a/drivers/scsi/scsi_wait_scan.c b/drivers/scsi/scsi_wait_scan.c
index ae7814874618..072734538876 100644
--- a/drivers/scsi/scsi_wait_scan.c
+++ b/drivers/scsi/scsi_wait_scan.c
@@ -22,11 +22,6 @@ static int __init wait_scan_init(void)
          * and might not yet have reached the scsi async scanning
          */
         wait_for_device_probe();
-        /*
-         * and then we wait for the actual asynchronous scsi scan
-         * to finish.
-         */
-        scsi_complete_async_scans();
         return 0;
 }
 
diff --git a/drivers/target/Makefile b/drivers/target/Makefile
index 61648d84fbb6..9fdcb561422f 100644
--- a/drivers/target/Makefile
+++ b/drivers/target/Makefile
@@ -9,7 +9,8 @@ target_core_mod-y		:= target_core_configfs.o \
                                    target_core_tmr.o \
                                    target_core_tpg.o \
                                    target_core_transport.o \
-                                   target_core_cdb.o \
+                                   target_core_sbc.o \
+                                   target_core_spc.o \
                                    target_core_ua.o \
                                    target_core_rd.o \
                                    target_core_stat.o
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index d57d10cb2e47..97c0f78c3c9c 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -429,19 +429,8 @@ int iscsit_reset_np_thread(
 
 int iscsit_del_np_comm(struct iscsi_np *np)
 {
-        if (!np->np_socket)
-                return 0;
-
-        /*
-         * Some network transports allocate their own struct sock->file,
-         * see  if we need to free any additional allocated resources.
-         */
-        if (np->np_flags & NPF_SCTP_STRUCT_FILE) {
-                kfree(np->np_socket->file);
-                np->np_socket->file = NULL;
-        }
-
-        sock_release(np->np_socket);
+        if (np->np_socket)
+                sock_release(np->np_socket);
         return 0;
 }
 
@@ -1413,8 +1402,10 @@ static int iscsit_handle_data_out(struct iscsi_conn *conn, unsigned char *buf)
                 spin_unlock_bh(&cmd->istate_lock);
 
                 iscsit_stop_dataout_timer(cmd);
-                return (!ooo_cmdsn) ? transport_generic_handle_data(
-                                        &cmd->se_cmd) : 0;
+                if (ooo_cmdsn)
+                        return 0;
+                target_execute_cmd(&cmd->se_cmd);
+                return 0;
         } else /* DATAOUT_CANNOT_RECOVER */
                 return -1;
 
@@ -2683,7 +2674,7 @@ static int iscsit_send_logout_response(
                  */
                 logout_conn = iscsit_get_conn_from_cid_rcfr(sess,
                                 cmd->logout_cid);
-                if ((logout_conn)) {
+                if (logout_conn) {
                         iscsit_connection_reinstatement_rcfr(logout_conn);
                         iscsit_dec_conn_usage_count(logout_conn);
                 }
@@ -4077,13 +4068,8 @@ int iscsit_close_connection(
         kfree(conn->conn_ops);
         conn->conn_ops = NULL;
 
-        if (conn->sock) {
-                if (conn->conn_flags & CONNFLAG_SCTP_STRUCT_FILE) {
-                        kfree(conn->sock->file);
-                        conn->sock->file = NULL;
-                }
+        if (conn->sock)
                 sock_release(conn->sock);
-        }
         conn->thread_set = NULL;
 
         pr_debug("Moving to TARG_CONN_STATE_FREE.\n");
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index 69dc8e35c03a..a7b25e783b58 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -47,28 +47,6 @@ struct lio_target_configfs_attribute {
         ssize_t (*store)(void *, const char *, size_t);
 };
 
-struct iscsi_portal_group *lio_get_tpg_from_tpg_item(
-        struct config_item *item,
-        struct iscsi_tiqn **tiqn_out)
-{
-        struct se_portal_group *se_tpg = container_of(to_config_group(item),
-                                        struct se_portal_group, tpg_group);
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
-        int ret;
-
-        if (!tpg) {
-                pr_err("Unable to locate struct iscsi_portal_group "
-                        "pointer\n");
-                return NULL;
-        }
-        ret = iscsit_get_tpg(tpg);
-        if (ret < 0)
-                return NULL;
-
-        *tiqn_out = tpg->tpg_tiqn;
-        return tpg;
-}
-
 /* Start items for lio_target_portal_cit */
 
 static ssize_t lio_target_np_show_sctp(
diff --git a/drivers/target/iscsi/iscsi_target_core.h b/drivers/target/iscsi/iscsi_target_core.h
index 1c70144cdaf1..8a908b28d8b2 100644
--- a/drivers/target/iscsi/iscsi_target_core.h
+++ b/drivers/target/iscsi/iscsi_target_core.h
@@ -224,7 +224,6 @@ enum iscsi_timer_flags_table {
 /* Used for struct iscsi_np->np_flags */
 enum np_flags_table {
         NPF_IP_NETWORK          = 0x00,
-        NPF_SCTP_STRUCT_FILE    = 0x01 /* Bugfix */
 };
 
 /* Used for struct iscsi_np->np_thread_state */
@@ -481,6 +480,7 @@ struct iscsi_tmr_req {
         bool                    task_reassign:1;
         u32                     ref_cmd_sn;
         u32                     exp_data_sn;
+        struct iscsi_cmd        *ref_cmd;
         struct iscsi_conn_recovery *conn_recovery;
         struct se_tmr_req       *se_tmr_req;
 };
@@ -503,7 +503,6 @@ struct iscsi_conn {
         u16                     local_port;
         int                     net_size;
         u32                     auth_id;
-#define CONNFLAG_SCTP_STRUCT_FILE                       0x01
         u32                     conn_flags;
         /* Used for iscsi_tx_login_rsp() */
         u32                     login_itt;
diff --git a/drivers/target/iscsi/iscsi_target_erl1.c b/drivers/target/iscsi/iscsi_target_erl1.c
index ecdd46deedda..3df8a2cef86f 100644
--- a/drivers/target/iscsi/iscsi_target_erl1.c
+++ b/drivers/target/iscsi/iscsi_target_erl1.c
@@ -965,8 +965,8 @@ int iscsit_execute_cmd(struct iscsi_cmd *cmd, int ooo)
                 if (cmd->immediate_data) {
                         if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) {
                                 spin_unlock_bh(&cmd->istate_lock);
-                                return transport_generic_handle_data(
-                                                &cmd->se_cmd);
+                                target_execute_cmd(&cmd->se_cmd);
+                                return 0;
                         }
                         spin_unlock_bh(&cmd->istate_lock);
 
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index a3656c9903a1..0694d9b1bce6 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -518,7 +518,7 @@ int iscsi_login_post_auth_non_zero_tsih(
          * initiator and release the new connection.
          */
         conn_ptr = iscsit_get_conn_from_cid_rcfr(sess, cid);
-        if ((conn_ptr)) {
+        if (conn_ptr) {
                 pr_err("Connection exists with CID %hu for %s,"
                         " performing connection reinstatement.\n",
                         conn_ptr->cid, sess->sess_ops->InitiatorName);
@@ -539,7 +539,7 @@ int iscsi_login_post_auth_non_zero_tsih(
         if (sess->sess_ops->ErrorRecoveryLevel == 2) {
                 cr = iscsit_get_inactive_connection_recovery_entry(
                                 sess, cid);
-                if ((cr)) {
+                if (cr) {
                         pr_debug("Performing implicit logout"
                                 " for connection recovery on CID: %hu\n",
                                         conn->cid);
@@ -795,22 +795,6 @@ int iscsi_target_setup_login_socket(
         }
         np->np_socket = sock;
         /*
-         * The SCTP stack needs struct socket->file.
-         */
-        if ((np->np_network_transport == ISCSI_SCTP_TCP) ||
-            (np->np_network_transport == ISCSI_SCTP_UDP)) {
-                if (!sock->file) {
-                        sock->file = kzalloc(sizeof(struct file), GFP_KERNEL);
-                        if (!sock->file) {
-                                pr_err("Unable to allocate struct"
-                                                " file for SCTP\n");
-                                ret = -ENOMEM;
-                                goto fail;
-                        }
-                        np->np_flags |= NPF_SCTP_STRUCT_FILE;
-                }
-        }
-        /*
          * Setup the np->np_sockaddr from the passed sockaddr setup
          * in iscsi_target_configfs.c code..
          */
@@ -869,21 +853,15 @@ int iscsi_target_setup_login_socket(
 
 fail:
         np->np_socket = NULL;
-        if (sock) {
-                if (np->np_flags & NPF_SCTP_STRUCT_FILE) {
-                        kfree(sock->file);
-                        sock->file = NULL;
-                }
-
+        if (sock)
                 sock_release(sock);
-        }
         return ret;
 }
 
 static int __iscsi_target_login_thread(struct iscsi_np *np)
 {
         u8 buffer[ISCSI_HDR_LEN], iscsi_opcode, zero_tsih = 0;
-        int err, ret = 0, set_sctp_conn_flag, stop;
+        int err, ret = 0, stop;
         struct iscsi_conn *conn = NULL;
         struct iscsi_login *login;
         struct iscsi_portal_group *tpg = NULL;
@@ -894,7 +872,6 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
         struct sockaddr_in6 sock_in6;
 
         flush_signals(current);
-        set_sctp_conn_flag = 0;
         sock = np->np_socket;
 
         spin_lock_bh(&np->np_thread_lock);
@@ -917,35 +894,12 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
                 spin_unlock_bh(&np->np_thread_lock);
                 goto out;
         }
-        /*
-         * The SCTP stack needs struct socket->file.
-         */
-        if ((np->np_network_transport == ISCSI_SCTP_TCP) ||
-            (np->np_network_transport == ISCSI_SCTP_UDP)) {
-                if (!new_sock->file) {
-                        new_sock->file = kzalloc(
-                                        sizeof(struct file), GFP_KERNEL);
-                        if (!new_sock->file) {
-                                pr_err("Unable to allocate struct"
-                                                " file for SCTP\n");
-                                sock_release(new_sock);
-                                /* Get another socket */
-                                return 1;
-                        }
-                        set_sctp_conn_flag = 1;
-                }
-        }
-
         iscsi_start_login_thread_timer(np);
 
         conn = kzalloc(sizeof(struct iscsi_conn), GFP_KERNEL);
         if (!conn) {
                 pr_err("Could not allocate memory for"
                         " new connection\n");
-                if (set_sctp_conn_flag) {
-                        kfree(new_sock->file);
-                        new_sock->file = NULL;
-                }
                 sock_release(new_sock);
                 /* Get another socket */
                 return 1;
@@ -955,9 +909,6 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
         conn->conn_state = TARG_CONN_STATE_FREE;
         conn->sock = new_sock;
 
-        if (set_sctp_conn_flag)
-                conn->conn_flags |= CONNFLAG_SCTP_STRUCT_FILE;
-
         pr_debug("Moving to TARG_CONN_STATE_XPT_UP.\n");
         conn->conn_state = TARG_CONN_STATE_XPT_UP;
 
@@ -1081,7 +1032,7 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
                 goto new_sess_out;
 
         zero_tsih = (pdu->tsih == 0x0000);
-        if ((zero_tsih)) {
+        if (zero_tsih) {
                 /*
                  * This is the leading connection of a new session.
                  * We wait until after authentication to check for
@@ -1205,13 +1156,8 @@ old_sess_out:
                 iscsi_release_param_list(conn->param_list);
                 conn->param_list = NULL;
         }
-        if (conn->sock) {
-                if (conn->conn_flags & CONNFLAG_SCTP_STRUCT_FILE) {
-                        kfree(conn->sock->file);
-                        conn->sock->file = NULL;
-                }
+        if (conn->sock)
                 sock_release(conn->sock);
-        }
         kfree(conn);
 
         if (tpg) {
diff --git a/drivers/target/iscsi/iscsi_target_parameters.c b/drivers/target/iscsi/iscsi_target_parameters.c
index ed5241e7f12a..0c4760fabfc0 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.c
+++ b/drivers/target/iscsi/iscsi_target_parameters.c
@@ -681,7 +681,7 @@ int iscsi_update_param_value(struct iscsi_param *param, char *value)
         param->value = kzalloc(strlen(value) + 1, GFP_KERNEL);
         if (!param->value) {
                 pr_err("Unable to allocate memory for value.\n");
-                return -1;
+                return -ENOMEM;
         }
 
         memcpy(param->value, value, strlen(value));
diff --git a/drivers/target/iscsi/iscsi_target_tmr.c b/drivers/target/iscsi/iscsi_target_tmr.c
index f4e640b51fd1..f62fe123d902 100644
--- a/drivers/target/iscsi/iscsi_target_tmr.c
+++ b/drivers/target/iscsi/iscsi_target_tmr.c
@@ -19,6 +19,7 @@
  ******************************************************************************/
 
 #include <asm/unaligned.h>
+#include <scsi/scsi_device.h>
 #include <scsi/iscsi_proto.h>
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
@@ -61,7 +62,7 @@ u8 iscsit_tmr_abort_task(
         }
 
         se_tmr->ref_task_tag            = hdr->rtt;
-        se_tmr->ref_cmd                 = &ref_cmd->se_cmd;
+        tmr_req->ref_cmd                = ref_cmd;
         tmr_req->ref_cmd_sn             = hdr->refcmdsn;
         tmr_req->exp_data_sn            = hdr->exp_datasn;
 
@@ -121,7 +122,7 @@ u8 iscsit_tmr_task_reassign(
         struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
         struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
         struct iscsi_tm *hdr = (struct iscsi_tm *) buf;
-        int ret;
+        int ret, ref_lun;
 
         pr_debug("Got TASK_REASSIGN TMR ITT: 0x%08x,"
                 " RefTaskTag: 0x%08x, ExpDataSN: 0x%08x, CID: %hu\n",
@@ -155,9 +156,16 @@ u8 iscsit_tmr_task_reassign(
                 return ISCSI_TMF_RSP_REJECTED;
         }
 
+        ref_lun = scsilun_to_int(&hdr->lun);
+        if (ref_lun != ref_cmd->se_cmd.orig_fe_lun) {
+                pr_err("Unable to perform connection recovery for"
+                        " differing ref_lun: %d ref_cmd orig_fe_lun: %u\n",
+                        ref_lun, ref_cmd->se_cmd.orig_fe_lun);
+                return ISCSI_TMF_RSP_REJECTED;
+        }
+
         se_tmr->ref_task_tag            = hdr->rtt;
-        se_tmr->ref_cmd                 = &ref_cmd->se_cmd;
-        se_tmr->ref_task_lun            = get_unaligned_le64(&hdr->lun);
+        tmr_req->ref_cmd                = ref_cmd;
         tmr_req->ref_cmd_sn             = hdr->refcmdsn;
         tmr_req->exp_data_sn            = hdr->exp_datasn;
         tmr_req->conn_recovery          = cr;
@@ -191,9 +199,7 @@ static int iscsit_task_reassign_complete_nop_out(
         struct iscsi_tmr_req *tmr_req,
         struct iscsi_conn *conn)
 {
-        struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
-        struct se_cmd *se_cmd = se_tmr->ref_cmd;
-        struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
+        struct iscsi_cmd *cmd = tmr_req->ref_cmd;
         struct iscsi_conn_recovery *cr;
 
         if (!cmd->cr) {
@@ -251,7 +257,8 @@ static int iscsit_task_reassign_complete_write(
                         pr_debug("WRITE ITT: 0x%08x: t_state: %d"
                                 " never sent to transport\n",
                                 cmd->init_task_tag, cmd->se_cmd.t_state);
-                        return transport_generic_handle_data(se_cmd);
+                        target_execute_cmd(se_cmd);
+                        return 0;
                 }
 
                 cmd->i_state = ISTATE_SEND_STATUS;
@@ -360,9 +367,7 @@ static int iscsit_task_reassign_complete_scsi_cmnd(
         struct iscsi_tmr_req *tmr_req,
         struct iscsi_conn *conn)
 {
-        struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
-        struct se_cmd *se_cmd = se_tmr->ref_cmd;
-        struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
+        struct iscsi_cmd *cmd = tmr_req->ref_cmd;
         struct iscsi_conn_recovery *cr;
 
         if (!cmd->cr) {
@@ -385,7 +390,7 @@ static int iscsit_task_reassign_complete_scsi_cmnd(
         list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
         spin_unlock_bh(&conn->cmd_lock);
 
-        if (se_cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) {
+        if (cmd->se_cmd.se_cmd_flags & SCF_SENT_CHECK_CONDITION) {
                 cmd->i_state = ISTATE_SEND_STATUS;
                 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
                 return 0;
@@ -411,17 +416,14 @@ static int iscsit_task_reassign_complete(
         struct iscsi_tmr_req *tmr_req,
         struct iscsi_conn *conn)
 {
-        struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
-        struct se_cmd *se_cmd;
         struct iscsi_cmd *cmd;
         int ret = 0;
 
-        if (!se_tmr->ref_cmd) {
+        if (!tmr_req->ref_cmd) {
                 pr_err("TMR Request is missing a RefCmd struct iscsi_cmd.\n");
                 return -1;
         }
-        se_cmd = se_tmr->ref_cmd;
-        cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
+        cmd = tmr_req->ref_cmd;
 
         cmd->conn = conn;
 
@@ -547,9 +549,7 @@ int iscsit_task_reassign_prepare_write(
         struct iscsi_tmr_req *tmr_req,
         struct iscsi_conn *conn)
 {
-        struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
-        struct se_cmd *se_cmd = se_tmr->ref_cmd;
-        struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
+        struct iscsi_cmd *cmd = tmr_req->ref_cmd;
         struct iscsi_pdu *pdu = NULL;
         struct iscsi_r2t *r2t = NULL, *r2t_tmp;
         int first_incomplete_r2t = 1, i = 0;
@@ -782,14 +782,12 @@ int iscsit_check_task_reassign_expdatasn(
         struct iscsi_tmr_req *tmr_req,
         struct iscsi_conn *conn)
 {
-        struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
-        struct se_cmd *se_cmd = se_tmr->ref_cmd;
-        struct iscsi_cmd *ref_cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
+        struct iscsi_cmd *ref_cmd = tmr_req->ref_cmd;
 
         if (ref_cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD)
                 return 0;
 
-        if (se_cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION)
+        if (ref_cmd->se_cmd.se_cmd_flags & SCF_SENT_CHECK_CONDITION)
                 return 0;
 
         if (ref_cmd->data_direction == DMA_NONE)
diff --git a/drivers/target/iscsi/iscsi_target_tpg.c b/drivers/target/iscsi/iscsi_target_tpg.c
index 879d8d0fa3fe..a38a3f8ab0d9 100644
--- a/drivers/target/iscsi/iscsi_target_tpg.c
+++ b/drivers/target/iscsi/iscsi_target_tpg.c
@@ -303,6 +303,7 @@ int iscsit_tpg_enable_portal_group(struct iscsi_portal_group *tpg)
 {
         struct iscsi_param *param;
         struct iscsi_tiqn *tiqn = tpg->tpg_tiqn;
+        int ret;
 
         spin_lock(&tpg->tpg_state_lock);
         if (tpg->tpg_state == TPG_STATE_ACTIVE) {
@@ -319,19 +320,19 @@ int iscsit_tpg_enable_portal_group(struct iscsi_portal_group *tpg)
         param = iscsi_find_param_from_key(AUTHMETHOD, tpg->param_list);
         if (!param) {
                 spin_unlock(&tpg->tpg_state_lock);
-                return -ENOMEM;
+                return -EINVAL;
         }
 
         if (ISCSI_TPG_ATTRIB(tpg)->authentication) {
-                if (!strcmp(param->value, NONE))
-                        if (iscsi_update_param_value(param, CHAP) < 0) {
-                                spin_unlock(&tpg->tpg_state_lock);
-                                return -ENOMEM;
-                        }
-                if (iscsit_ta_authentication(tpg, 1) < 0) {
-                        spin_unlock(&tpg->tpg_state_lock);
-                        return -ENOMEM;
+                if (!strcmp(param->value, NONE)) {
+                        ret = iscsi_update_param_value(param, CHAP);
+                        if (ret)
+                                goto err;
                 }
+
+                ret = iscsit_ta_authentication(tpg, 1);
+                if (ret < 0)
+                        goto err;
         }
 
         tpg->tpg_state = TPG_STATE_ACTIVE;
@@ -344,6 +345,10 @@ int iscsit_tpg_enable_portal_group(struct iscsi_portal_group *tpg)
         spin_unlock(&tiqn->tiqn_tpg_lock);
 
         return 0;
+
+err:
+        spin_unlock(&tpg->tpg_state_lock);
+        return ret;
 }
 
 int iscsit_tpg_disable_portal_group(struct iscsi_portal_group *tpg, int force)
@@ -558,7 +563,7 @@ int iscsit_ta_authentication(struct iscsi_portal_group *tpg, u32 authentication)
         if ((authentication != 1) && (authentication != 0)) {
                 pr_err("Illegal value for authentication parameter:"
                         " %u, ignoring request.\n", authentication);
-                return -1;
+                return -EINVAL;
         }
 
         memset(buf1, 0, sizeof(buf1));
@@ -593,7 +598,7 @@ int iscsit_ta_authentication(struct iscsi_portal_group *tpg, u32 authentication)
         } else {
                 snprintf(buf1, sizeof(buf1), "%s", param->value);
                 none = strstr(buf1, NONE);
-                if ((none))
+                if (none)
                         goto out;
                 strncat(buf1, ",", strlen(","));
                 strncat(buf1, NONE, strlen(NONE));
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index 38dfac2b0a1c..5491c632a15e 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -211,12 +211,11 @@ static void tcm_loop_submission_work(struct work_struct *work)
         /*
          * Because some userspace code via scsi-generic do not memset their
          * associated read buffers, go ahead and do that here for type
-         * SCF_SCSI_CONTROL_SG_IO_CDB.  Also note that this is currently
-         * guaranteed to be a single SGL for SCF_SCSI_CONTROL_SG_IO_CDB
-         * by target core in target_setup_cmd_from_cdb() ->
-         * transport_generic_cmd_sequencer().
+         * non-data CDBs.  Also note that this is currently guaranteed to be a
+         * single SGL for this case by target core in
+         * target_setup_cmd_from_cdb() -> transport_generic_cmd_sequencer().
          */
-        if (se_cmd->se_cmd_flags & SCF_SCSI_CONTROL_SG_IO_CDB &&
+        if (!(se_cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) &&
             se_cmd->data_direction == DMA_FROM_DEVICE) {
                 struct scatterlist *sg = scsi_sglist(sc);
                 unsigned char *buf = kmap(sg_page(sg)) + sg->offset;
@@ -779,7 +778,7 @@ static int tcm_loop_write_pending(struct se_cmd *se_cmd)
          * We now tell TCM to add this WRITE CDB directly into the TCM storage
          * object execution queue.
          */
-        transport_generic_process_write(se_cmd);
+        target_execute_cmd(se_cmd);
         return 0;
 }
 
diff --git a/drivers/target/sbp/sbp_target.c b/drivers/target/sbp/sbp_target.c
index 7e6136e2ce81..39ddba584b30 100644
--- a/drivers/target/sbp/sbp_target.c
+++ b/drivers/target/sbp/sbp_target.c
@@ -1219,28 +1219,14 @@ static void sbp_handle_command(struct sbp_target_request *req)
         ret = sbp_fetch_command(req);
         if (ret) {
                 pr_debug("sbp_handle_command: fetch command failed: %d\n", ret);
-                req->status.status |= cpu_to_be32(
-                        STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
-                        STATUS_BLOCK_DEAD(0) |
-                        STATUS_BLOCK_LEN(1) |
-                        STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
-                sbp_send_status(req);
-                sbp_free_request(req);
-                return;
+                goto err;
         }
 
         ret = sbp_fetch_page_table(req);
         if (ret) {
                 pr_debug("sbp_handle_command: fetch page table failed: %d\n",
                         ret);
-                req->status.status |= cpu_to_be32(
-                        STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
-                        STATUS_BLOCK_DEAD(0) |
-                        STATUS_BLOCK_LEN(1) |
-                        STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
-                sbp_send_status(req);
-                sbp_free_request(req);
-                return;
+                goto err;
         }
 
         unpacked_lun = req->login->lun->unpacked_lun;
@@ -1249,9 +1235,21 @@ static void sbp_handle_command(struct sbp_target_request *req)
         pr_debug("sbp_handle_command ORB:0x%llx unpacked_lun:%d data_len:%d data_dir:%d\n",
                         req->orb_pointer, unpacked_lun, data_length, data_dir);
 
-        target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
-                        req->sense_buf, unpacked_lun, data_length,
-                        MSG_SIMPLE_TAG, data_dir, 0);
+        if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
+                              req->sense_buf, unpacked_lun, data_length,
+                              MSG_SIMPLE_TAG, data_dir, 0))
+                goto err;
+
+        return;
+
+err:
+        req->status.status |= cpu_to_be32(
+                STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
+                STATUS_BLOCK_DEAD(0) |
+                STATUS_BLOCK_LEN(1) |
+                STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
+        sbp_send_status(req);
+        sbp_free_request(req);
 }
 
 /*
@@ -1784,8 +1782,7 @@ static int sbp_write_pending(struct se_cmd *se_cmd)
                 return ret;
         }
 
-        transport_generic_process_write(se_cmd);
-
+        target_execute_cmd(se_cmd);
         return 0;
 }
 
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 5ad972856a8d..cf2c66f3c116 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -300,8 +300,8 @@ int core_free_device_list_for_node(
                 lun = deve->se_lun;
 
                 spin_unlock_irq(&nacl->device_list_lock);
-                core_update_device_list_for_node(lun, NULL, deve->mapped_lun,
-                        TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg, 0);
+                core_disable_device_list_for_node(lun, NULL, deve->mapped_lun,
+                        TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
                 spin_lock_irq(&nacl->device_list_lock);
         }
         spin_unlock_irq(&nacl->device_list_lock);
@@ -342,72 +342,46 @@ void core_update_device_list_access(
         spin_unlock_irq(&nacl->device_list_lock);
 }
 
-/*      core_update_device_list_for_node():
+/*      core_enable_device_list_for_node():
  *
  *
  */
-int core_update_device_list_for_node(
+int core_enable_device_list_for_node(
         struct se_lun *lun,
         struct se_lun_acl *lun_acl,
         u32 mapped_lun,
         u32 lun_access,
         struct se_node_acl *nacl,
-        struct se_portal_group *tpg,
-        int enable)
+        struct se_portal_group *tpg)
 {
         struct se_port *port = lun->lun_sep;
-        struct se_dev_entry *deve = nacl->device_list[mapped_lun];
-        int trans = 0;
-        /*
-         * If the MappedLUN entry is being disabled, the entry in
-         * port->sep_alua_list must be removed now before clearing the
-         * struct se_dev_entry pointers below as logic in
-         * core_alua_do_transition_tg_pt() depends on these being present.
-         */
-        if (!enable) {
-                /*
-                 * deve->se_lun_acl will be NULL for demo-mode created LUNs
-                 * that have not been explicitly concerted to MappedLUNs ->
-                 * struct se_lun_acl, but we remove deve->alua_port_list from
-                 * port->sep_alua_list. This also means that active UAs and
-                 * NodeACL context specific PR metadata for demo-mode
-                 * MappedLUN *deve will be released below..
-                 */
-                spin_lock_bh(&port->sep_alua_lock);
-                list_del(&deve->alua_port_list);
-                spin_unlock_bh(&port->sep_alua_lock);
-        }
+        struct se_dev_entry *deve;
 
         spin_lock_irq(&nacl->device_list_lock);
-        if (enable) {
-                /*
-                 * Check if the call is handling demo mode -> explict LUN ACL
-                 * transition.  This transition must be for the same struct se_lun
-                 * + mapped_lun that was setup in demo mode..
-                 */
-                if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
-                        if (deve->se_lun_acl != NULL) {
-                                pr_err("struct se_dev_entry->se_lun_acl"
-                                        " already set for demo mode -> explict"
-                                        " LUN ACL transition\n");
-                                spin_unlock_irq(&nacl->device_list_lock);
-                                return -EINVAL;
-                        }
-                        if (deve->se_lun != lun) {
-                                pr_err("struct se_dev_entry->se_lun does"
-                                        " match passed struct se_lun for demo mode"
-                                        " -> explict LUN ACL transition\n");
-                                spin_unlock_irq(&nacl->device_list_lock);
-                                return -EINVAL;
-                        }
-                        deve->se_lun_acl = lun_acl;
-                        trans = 1;
-                } else {
-                        deve->se_lun = lun;
-                        deve->se_lun_acl = lun_acl;
-                        deve->mapped_lun = mapped_lun;
-                        deve->lun_flags |= TRANSPORT_LUNFLAGS_INITIATOR_ACCESS;
+
+        deve = nacl->device_list[mapped_lun];
+
+        /*
+         * Check if the call is handling demo mode -> explict LUN ACL
+         * transition.  This transition must be for the same struct se_lun
+         * + mapped_lun that was setup in demo mode..
+         */
+        if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
+                if (deve->se_lun_acl != NULL) {
+                        pr_err("struct se_dev_entry->se_lun_acl"
+                               " already set for demo mode -> explict"
+                               " LUN ACL transition\n");
+                        spin_unlock_irq(&nacl->device_list_lock);
+                        return -EINVAL;
                 }
+                if (deve->se_lun != lun) {
+                        pr_err("struct se_dev_entry->se_lun does"
+                               " match passed struct se_lun for demo mode"
+                               " -> explict LUN ACL transition\n");
+                        spin_unlock_irq(&nacl->device_list_lock);
+                        return -EINVAL;
+                }
+                deve->se_lun_acl = lun_acl;
 
                 if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
                         deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
@@ -417,27 +391,72 @@ int core_update_device_list_for_node(
                         deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
                 }
 
-                if (trans) {
-                        spin_unlock_irq(&nacl->device_list_lock);
-                        return 0;
-                }
-                deve->creation_time = get_jiffies_64();
-                deve->attach_count++;
                 spin_unlock_irq(&nacl->device_list_lock);
+                return 0;
+        }
 
-                spin_lock_bh(&port->sep_alua_lock);
-                list_add_tail(&deve->alua_port_list, &port->sep_alua_list);
-                spin_unlock_bh(&port->sep_alua_lock);
+        deve->se_lun = lun;
+        deve->se_lun_acl = lun_acl;
+        deve->mapped_lun = mapped_lun;
+        deve->lun_flags |= TRANSPORT_LUNFLAGS_INITIATOR_ACCESS;
 
-                return 0;
+        if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
+                deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
+                deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
+        } else {
+                deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
+                deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
         }
+
+        deve->creation_time = get_jiffies_64();
+        deve->attach_count++;
+        spin_unlock_irq(&nacl->device_list_lock);
+
+        spin_lock_bh(&port->sep_alua_lock);
+        list_add_tail(&deve->alua_port_list, &port->sep_alua_list);
+        spin_unlock_bh(&port->sep_alua_lock);
+
+        return 0;
+}
+
+/*      core_disable_device_list_for_node():
+ *
+ *
+ */
+int core_disable_device_list_for_node(
+        struct se_lun *lun,
+        struct se_lun_acl *lun_acl,
+        u32 mapped_lun,
+        u32 lun_access,
+        struct se_node_acl *nacl,
+        struct se_portal_group *tpg)
+{
+        struct se_port *port = lun->lun_sep;
+        struct se_dev_entry *deve = nacl->device_list[mapped_lun];
+
+        /*
+         * If the MappedLUN entry is being disabled, the entry in
+         * port->sep_alua_list must be removed now before clearing the
+         * struct se_dev_entry pointers below as logic in
+         * core_alua_do_transition_tg_pt() depends on these being present.
+         *
+         * deve->se_lun_acl will be NULL for demo-mode created LUNs
+         * that have not been explicitly converted to MappedLUNs ->
+         * struct se_lun_acl, but we remove deve->alua_port_list from
+         * port->sep_alua_list. This also means that active UAs and
+         * NodeACL context specific PR metadata for demo-mode
+         * MappedLUN *deve will be released below..
+         */
+        spin_lock_bh(&port->sep_alua_lock);
+        list_del(&deve->alua_port_list);
+        spin_unlock_bh(&port->sep_alua_lock);
         /*
          * Wait for any in process SPEC_I_PT=1 or REGISTER_AND_MOVE
          * PR operation to complete.
          */
-        spin_unlock_irq(&nacl->device_list_lock);
         while (atomic_read(&deve->pr_ref_count) != 0)
                 cpu_relax();
+
         spin_lock_irq(&nacl->device_list_lock);
         /*
          * Disable struct se_dev_entry LUN ACL mapping
@@ -475,9 +494,9 @@ void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)
                                 continue;
                         spin_unlock_irq(&nacl->device_list_lock);
 
-                        core_update_device_list_for_node(lun, NULL,
+                        core_disable_device_list_for_node(lun, NULL,
                                 deve->mapped_lun, TRANSPORT_LUNFLAGS_NO_ACCESS,
-                                nacl, tpg, 0);
+                                nacl, tpg);
 
                         spin_lock_irq(&nacl->device_list_lock);
                 }
@@ -715,7 +734,7 @@ void se_release_device_for_hba(struct se_device *dev)
                 se_dev_stop(dev);
 
         if (dev->dev_ptr) {
-                kthread_stop(dev->process_thread);
+                destroy_workqueue(dev->tmr_wq);
                 if (dev->transport->free_device)
                         dev->transport->free_device(dev->dev_ptr);
         }
@@ -822,7 +841,7 @@ int se_dev_check_shutdown(struct se_device *dev)
         return ret;
 }
 
-u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
+static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
 {
         u32 tmp, aligned_max_sectors;
         /*
@@ -1273,7 +1292,6 @@ int se_dev_set_block_size(struct se_device *dev, u32 block_size)
 
 struct se_lun *core_dev_add_lun(
         struct se_portal_group *tpg,
-        struct se_hba *hba,
         struct se_device *dev,
         u32 lun)
 {
@@ -1298,7 +1316,7 @@ struct se_lun *core_dev_add_lun(
         pr_debug("%s_TPG[%u]_LUN[%u] - Activated %s Logical Unit from"
                 " CORE HBA: %u\n", tpg->se_tpg_tfo->get_fabric_name(),
                 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun_p->unpacked_lun,
-                tpg->se_tpg_tfo->get_fabric_name(), hba->hba_id);
+                tpg->se_tpg_tfo->get_fabric_name(), dev->se_hba->hba_id);
         /*
          * Update LUN maps for dynamically added initiators when
          * generate_node_acl is enabled.
@@ -1470,8 +1488,8 @@ int core_dev_add_initiator_node_lun_acl(
 
         lacl->se_lun = lun;
 
-        if (core_update_device_list_for_node(lun, lacl, lacl->mapped_lun,
-                        lun_access, nacl, tpg, 1) < 0)
+        if (core_enable_device_list_for_node(lun, lacl, lacl->mapped_lun,
+                        lun_access, nacl, tpg) < 0)
                 return -EINVAL;
 
         spin_lock(&lun->lun_acl_lock);
@@ -1514,8 +1532,8 @@ int core_dev_del_initiator_node_lun_acl(
         smp_mb__after_atomic_dec();
         spin_unlock(&lun->lun_acl_lock);
 
-        core_update_device_list_for_node(lun, NULL, lacl->mapped_lun,
-                TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg, 0);
+        core_disable_device_list_for_node(lun, NULL, lacl->mapped_lun,
+                TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
 
         lacl->se_lun = NULL;
 
diff --git a/drivers/target/target_core_fabric_configfs.c b/drivers/target/target_core_fabric_configfs.c
index 405cc98eaed6..ea479e54f5fd 100644
--- a/drivers/target/target_core_fabric_configfs.c
+++ b/drivers/target/target_core_fabric_configfs.c
@@ -764,8 +764,7 @@ static int target_fabric_port_link(
                 goto out;
         }
 
-        lun_p = core_dev_add_lun(se_tpg, dev->se_hba, dev,
-                                lun->unpacked_lun);
+        lun_p = core_dev_add_lun(se_tpg, dev, lun->unpacked_lun);
         if (IS_ERR(lun_p)) {
                 pr_err("core_dev_add_lun() failed\n");
                 ret = PTR_ERR(lun_p);
diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index 9f99d0404908..9e2100551c78 100644
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -331,7 +331,7 @@ static int fd_do_writev(struct se_cmd *cmd, struct scatterlist *sgl,
         return 1;
 }
 
-static void fd_emulate_sync_cache(struct se_cmd *cmd)
+static int fd_execute_sync_cache(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
         struct fd_dev *fd_dev = dev->dev_ptr;
@@ -365,7 +365,7 @@ static void fd_emulate_sync_cache(struct se_cmd *cmd)
                 pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
 
         if (immed)
-                return;
+                return 0;
 
         if (ret) {
                 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
@@ -373,11 +373,15 @@ static void fd_emulate_sync_cache(struct se_cmd *cmd)
         } else {
                 target_complete_cmd(cmd, SAM_STAT_GOOD);
         }
+
+        return 0;
 }
 
-static int fd_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
-                u32 sgl_nents, enum dma_data_direction data_direction)
+static int fd_execute_rw(struct se_cmd *cmd)
 {
+        struct scatterlist *sgl = cmd->t_data_sg;
+        u32 sgl_nents = cmd->t_data_nents;
+        enum dma_data_direction data_direction = cmd->data_direction;
         struct se_device *dev = cmd->se_dev;
         int ret = 0;
 
@@ -550,6 +554,16 @@ static sector_t fd_get_blocks(struct se_device *dev)
         return div_u64(dev_size, dev->se_sub_dev->se_dev_attrib.block_size);
 }
 
+static struct spc_ops fd_spc_ops = {
+        .execute_rw             = fd_execute_rw,
+        .execute_sync_cache     = fd_execute_sync_cache,
+};
+
+static int fd_parse_cdb(struct se_cmd *cmd)
+{
+        return sbc_parse_cdb(cmd, &fd_spc_ops);
+}
+
 static struct se_subsystem_api fileio_template = {
         .name                   = "fileio",
         .owner                  = THIS_MODULE,
@@ -561,8 +575,7 @@ static struct se_subsystem_api fileio_template = {
         .allocate_virtdevice    = fd_allocate_virtdevice,
         .create_virtdevice      = fd_create_virtdevice,
         .free_device            = fd_free_device,
-        .execute_cmd            = fd_execute_cmd,
-        .do_sync_cache          = fd_emulate_sync_cache,
+        .parse_cdb              = fd_parse_cdb,
         .check_configfs_dev_params = fd_check_configfs_dev_params,
         .set_configfs_dev_params = fd_set_configfs_dev_params,
         .show_configfs_dev_params = fd_show_configfs_dev_params,
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index fd47950727b4..76db75e836ed 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -40,6 +40,7 @@
 #include <linux/module.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
+#include <asm/unaligned.h>
 
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
@@ -96,6 +97,7 @@ static struct se_device *iblock_create_virtdevice(
         struct request_queue *q;
         struct queue_limits *limits;
         u32 dev_flags = 0;
+        fmode_t mode;
         int ret = -EINVAL;
 
         if (!ib_dev) {
@@ -117,8 +119,11 @@ static struct se_device *iblock_create_virtdevice(
         pr_debug( "IBLOCK: Claiming struct block_device: %s\n",
                         ib_dev->ibd_udev_path);
 
-        bd = blkdev_get_by_path(ib_dev->ibd_udev_path,
-                                FMODE_WRITE|FMODE_READ|FMODE_EXCL, ib_dev);
+        mode = FMODE_READ|FMODE_EXCL;
+        if (!ib_dev->ibd_readonly)
+                mode |= FMODE_WRITE;
+
+        bd = blkdev_get_by_path(ib_dev->ibd_udev_path, mode, ib_dev);
         if (IS_ERR(bd)) {
                 ret = PTR_ERR(bd);
                 goto failed;
@@ -292,7 +297,7 @@ static void iblock_end_io_flush(struct bio *bio, int err)
  * Implement SYCHRONIZE CACHE.  Note that we can't handle lba ranges and must
  * always flush the whole cache.
  */
-static void iblock_emulate_sync_cache(struct se_cmd *cmd)
+static int iblock_execute_sync_cache(struct se_cmd *cmd)
 {
         struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr;
         int immed = (cmd->t_task_cdb[1] & 0x2);
@@ -311,23 +316,98 @@ static void iblock_emulate_sync_cache(struct se_cmd *cmd)
         if (!immed)
                 bio->bi_private = cmd;
         submit_bio(WRITE_FLUSH, bio);
+        return 0;
 }
 
-static int iblock_do_discard(struct se_device *dev, sector_t lba, u32 range)
+static int iblock_execute_unmap(struct se_cmd *cmd)
 {
+        struct se_device *dev = cmd->se_dev;
         struct iblock_dev *ibd = dev->dev_ptr;
-        struct block_device *bd = ibd->ibd_bd;
-        int barrier = 0;
+        unsigned char *buf, *ptr = NULL;
+        sector_t lba;
+        int size = cmd->data_length;
+        u32 range;
+        int ret = 0;
+        int dl, bd_dl;
+
+        buf = transport_kmap_data_sg(cmd);
+
+        dl = get_unaligned_be16(&buf[0]);
+        bd_dl = get_unaligned_be16(&buf[2]);
+
+        size = min(size - 8, bd_dl);
+        if (size / 16 > dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count) {
+                cmd->scsi_sense_reason = TCM_INVALID_PARAMETER_LIST;
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* First UNMAP block descriptor starts at 8 byte offset */
+        ptr = &buf[8];
+        pr_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u"
+                " ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr);
+
+        while (size >= 16) {
+                lba = get_unaligned_be64(&ptr[0]);
+                range = get_unaligned_be32(&ptr[8]);
+                pr_debug("UNMAP: Using lba: %llu and range: %u\n",
+                                 (unsigned long long)lba, range);
+
+                if (range > dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count) {
+                        cmd->scsi_sense_reason = TCM_INVALID_PARAMETER_LIST;
+                        ret = -EINVAL;
+                        goto err;
+                }
+
+                if (lba + range > dev->transport->get_blocks(dev) + 1) {
+                        cmd->scsi_sense_reason = TCM_ADDRESS_OUT_OF_RANGE;
+                        ret = -EINVAL;
+                        goto err;
+                }
 
-        return blkdev_issue_discard(bd, lba, range, GFP_KERNEL, barrier);
+                ret = blkdev_issue_discard(ibd->ibd_bd, lba, range,
+                                           GFP_KERNEL, 0);
+                if (ret < 0) {
+                        pr_err("blkdev_issue_discard() failed: %d\n",
+                                        ret);
+                        goto err;
+                }
+
+                ptr += 16;
+                size -= 16;
+        }
+
+err:
+        transport_kunmap_data_sg(cmd);
+        if (!ret)
+                target_complete_cmd(cmd, GOOD);
+        return ret;
+}
+
+static int iblock_execute_write_same(struct se_cmd *cmd)
+{
+        struct iblock_dev *ibd = cmd->se_dev->dev_ptr;
+        int ret;
+
+        ret = blkdev_issue_discard(ibd->ibd_bd, cmd->t_task_lba,
+                                   spc_get_write_same_sectors(cmd), GFP_KERNEL,
+                                   0);
+        if (ret < 0) {
+                pr_debug("blkdev_issue_discard() failed for WRITE_SAME\n");
+                return ret;
+        }
+
+        target_complete_cmd(cmd, GOOD);
+        return 0;
 }
 
 enum {
-        Opt_udev_path, Opt_force, Opt_err
+        Opt_udev_path, Opt_readonly, Opt_force, Opt_err
 };
 
 static match_table_t tokens = {
         {Opt_udev_path, "udev_path=%s"},
+        {Opt_readonly, "readonly=%d"},
         {Opt_force, "force=%d"},
         {Opt_err, NULL}
 };
@@ -340,6 +420,7 @@ static ssize_t iblock_set_configfs_dev_params(struct se_hba *hba,
         char *orig, *ptr, *arg_p, *opts;
         substring_t args[MAX_OPT_ARGS];
         int ret = 0, token;
+        unsigned long tmp_readonly;
 
         opts = kstrdup(page, GFP_KERNEL);
         if (!opts)
@@ -372,6 +453,22 @@ static ssize_t iblock_set_configfs_dev_params(struct se_hba *hba,
                                         ib_dev->ibd_udev_path);
                         ib_dev->ibd_flags |= IBDF_HAS_UDEV_PATH;
                         break;
+                case Opt_readonly:
+                        arg_p = match_strdup(&args[0]);
+                        if (!arg_p) {
+                                ret = -ENOMEM;
+                                break;
+                        }
+                        ret = strict_strtoul(arg_p, 0, &tmp_readonly);
+                        kfree(arg_p);
+                        if (ret < 0) {
+                                pr_err("strict_strtoul() failed for"
+                                                " readonly=\n");
+                                goto out;
+                        }
+                        ib_dev->ibd_readonly = tmp_readonly;
+                        pr_debug("IBLOCK: readonly: %d\n", ib_dev->ibd_readonly);
+                        break;
                 case Opt_force:
                         break;
                 default:
@@ -411,11 +508,10 @@ static ssize_t iblock_show_configfs_dev_params(
         if (bd)
                 bl += sprintf(b + bl, "iBlock device: %s",
                                 bdevname(bd, buf));
-        if (ibd->ibd_flags & IBDF_HAS_UDEV_PATH) {
-                bl += sprintf(b + bl, "  UDEV PATH: %s\n",
+        if (ibd->ibd_flags & IBDF_HAS_UDEV_PATH)
+                bl += sprintf(b + bl, "  UDEV PATH: %s",
                                 ibd->ibd_udev_path);
-        } else
-                bl += sprintf(b + bl, "\n");
+        bl += sprintf(b + bl, "  readonly: %d\n", ibd->ibd_readonly);
 
         bl += sprintf(b + bl, "        ");
         if (bd) {
@@ -493,9 +589,11 @@ static void iblock_submit_bios(struct bio_list *list, int rw)
         blk_finish_plug(&plug);
 }
 
-static int iblock_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
-                u32 sgl_nents, enum dma_data_direction data_direction)
+static int iblock_execute_rw(struct se_cmd *cmd)
 {
+        struct scatterlist *sgl = cmd->t_data_sg;
+        u32 sgl_nents = cmd->t_data_nents;
+        enum dma_data_direction data_direction = cmd->data_direction;
         struct se_device *dev = cmd->se_dev;
         struct iblock_req *ibr;
         struct bio *bio;
@@ -642,6 +740,18 @@ static void iblock_bio_done(struct bio *bio, int err)
         iblock_complete_cmd(cmd);
 }
 
+static struct spc_ops iblock_spc_ops = {
+        .execute_rw             = iblock_execute_rw,
+        .execute_sync_cache     = iblock_execute_sync_cache,
+        .execute_write_same     = iblock_execute_write_same,
+        .execute_unmap          = iblock_execute_unmap,
+};
+
+static int iblock_parse_cdb(struct se_cmd *cmd)
+{
+        return sbc_parse_cdb(cmd, &iblock_spc_ops);
+}
+
 static struct se_subsystem_api iblock_template = {
         .name                   = "iblock",
         .owner                  = THIS_MODULE,
@@ -653,9 +763,7 @@ static struct se_subsystem_api iblock_template = {
         .allocate_virtdevice    = iblock_allocate_virtdevice,
         .create_virtdevice      = iblock_create_virtdevice,
         .free_device            = iblock_free_device,
-        .execute_cmd            = iblock_execute_cmd,
-        .do_discard             = iblock_do_discard,
-        .do_sync_cache          = iblock_emulate_sync_cache,
+        .parse_cdb              = iblock_parse_cdb,
         .check_configfs_dev_params = iblock_check_configfs_dev_params,
         .set_configfs_dev_params = iblock_set_configfs_dev_params,
         .show_configfs_dev_params = iblock_show_configfs_dev_params,
diff --git a/drivers/target/target_core_iblock.h b/drivers/target/target_core_iblock.h
index 66cf7b9e205e..533627ae79ec 100644
--- a/drivers/target/target_core_iblock.h
+++ b/drivers/target/target_core_iblock.h
@@ -18,6 +18,7 @@ struct iblock_dev {
         u32     ibd_flags;
         struct bio_set  *ibd_bio_set;
         struct block_device *ibd_bd;
+        bool ibd_readonly;
 } ____cacheline_aligned;
 
 #endif /* TARGET_CORE_IBLOCK_H */
diff --git a/drivers/target/target_core_internal.h b/drivers/target/target_core_internal.h
index 165e82429687..0fd428225d11 100644
--- a/drivers/target/target_core_internal.h
+++ b/drivers/target/target_core_internal.h
@@ -4,25 +4,16 @@
 /* target_core_alua.c */
 extern struct t10_alua_lu_gp *default_lu_gp;
 
-/* target_core_cdb.c */
-int     target_emulate_inquiry(struct se_cmd *cmd);
-int     target_emulate_readcapacity(struct se_cmd *cmd);
-int     target_emulate_readcapacity_16(struct se_cmd *cmd);
-int     target_emulate_modesense(struct se_cmd *cmd);
-int     target_emulate_request_sense(struct se_cmd *cmd);
-int     target_emulate_unmap(struct se_cmd *cmd);
-int     target_emulate_write_same(struct se_cmd *cmd);
-int     target_emulate_synchronize_cache(struct se_cmd *cmd);
-int     target_emulate_noop(struct se_cmd *cmd);
-
 /* target_core_device.c */
 struct se_dev_entry *core_get_se_deve_from_rtpi(struct se_node_acl *, u16);
 int     core_free_device_list_for_node(struct se_node_acl *,
                 struct se_portal_group *);
 void    core_dec_lacl_count(struct se_node_acl *, struct se_cmd *);
 void    core_update_device_list_access(u32, u32, struct se_node_acl *);
-int     core_update_device_list_for_node(struct se_lun *, struct se_lun_acl *,
-                u32, u32, struct se_node_acl *, struct se_portal_group *, int);
+int     core_enable_device_list_for_node(struct se_lun *, struct se_lun_acl *,
+                u32, u32, struct se_node_acl *, struct se_portal_group *);
+int     core_disable_device_list_for_node(struct se_lun *, struct se_lun_acl *,
+                u32, u32, struct se_node_acl *, struct se_portal_group *);
 void    core_clear_lun_from_tpg(struct se_lun *, struct se_portal_group *);
 int     core_dev_export(struct se_device *, struct se_portal_group *,
                 struct se_lun *);
@@ -56,8 +47,7 @@ int	se_dev_set_max_sectors(struct se_device *, u32);
 int     se_dev_set_fabric_max_sectors(struct se_device *, u32);
 int     se_dev_set_optimal_sectors(struct se_device *, u32);
 int     se_dev_set_block_size(struct se_device *, u32);
-struct se_lun *core_dev_add_lun(struct se_portal_group *, struct se_hba *,
-                struct se_device *, u32);
+struct se_lun *core_dev_add_lun(struct se_portal_group *, struct se_device *, u32);
 int     core_dev_del_lun(struct se_portal_group *, u32);
 struct se_lun *core_get_lun_from_tpg(struct se_portal_group *, u32);
 struct se_lun_acl *core_dev_init_initiator_node_lun_acl(struct se_portal_group *,
@@ -104,7 +94,6 @@ void	release_se_kmem_caches(void);
 u32     scsi_get_new_index(scsi_index_t);
 void    transport_subsystem_check_init(void);
 void    transport_cmd_finish_abort(struct se_cmd *, int);
-void    __target_remove_from_execute_list(struct se_cmd *);
 unsigned char *transport_dump_cmd_direction(struct se_cmd *);
 void    transport_dump_dev_state(struct se_device *, char *, int *);
 void    transport_dump_dev_info(struct se_device *, struct se_lun *,
@@ -116,6 +105,7 @@ int	transport_dump_vpd_ident(struct t10_vpd *, unsigned char *, int);
 bool    target_stop_cmd(struct se_cmd *cmd, unsigned long *flags);
 int     transport_clear_lun_from_sessions(struct se_lun *);
 void    transport_send_task_abort(struct se_cmd *);
+int     target_cmd_size_check(struct se_cmd *cmd, unsigned int size);
 
 /* target_core_stat.c */
 void    target_stat_setup_dev_default_groups(struct se_subsystem_dev *);
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index 85564998500a..1e946502c378 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -507,7 +507,7 @@ static int core_scsi3_pr_seq_non_holder(
          * Check if write exclusive initiator ports *NOT* holding the
          * WRITE_EXCLUSIVE_* reservation.
          */
-        if ((we) && !(registered_nexus)) {
+        if (we && !registered_nexus) {
                 if (cmd->data_direction == DMA_TO_DEVICE) {
                         /*
                          * Conflict for write exclusive
@@ -2031,7 +2031,7 @@ static int __core_scsi3_write_aptpl_to_file(
         if (IS_ERR(file) || !file || !file->f_dentry) {
                 pr_err("filp_open(%s) for APTPL metadata"
                         " failed\n", path);
-                return (PTR_ERR(file) < 0 ? PTR_ERR(file) : -ENOENT);
+                return IS_ERR(file) ? PTR_ERR(file) : -ENOENT;
         }
 
         iov[0].iov_base = &buf[0];
@@ -2486,7 +2486,7 @@ static int core_scsi3_pro_reserve(
          */
         spin_lock(&dev->dev_reservation_lock);
         pr_res_holder = dev->dev_pr_res_holder;
-        if ((pr_res_holder)) {
+        if (pr_res_holder) {
                 /*
                  * From spc4r17 Section 5.7.9: Reserving:
                  *
@@ -3818,7 +3818,7 @@ int target_scsi3_emulate_pr_out(struct se_cmd *cmd)
                         " SPC-2 reservation is held, returning"
                         " RESERVATION_CONFLICT\n");
                 cmd->scsi_sense_reason = TCM_RESERVATION_CONFLICT;
-                ret = EINVAL;
+                ret = -EINVAL;
                 goto out;
         }
 
@@ -3828,7 +3828,8 @@ int target_scsi3_emulate_pr_out(struct se_cmd *cmd)
          */
         if (!cmd->se_sess) {
                 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
 
         if (cmd->data_length < 24) {
@@ -4029,7 +4030,7 @@ static int core_scsi3_pri_read_reservation(struct se_cmd *cmd)
 
         spin_lock(&se_dev->dev_reservation_lock);
         pr_reg = se_dev->dev_pr_res_holder;
-        if ((pr_reg)) {
+        if (pr_reg) {
                 /*
                  * Set the hardcoded Additional Length
                  */
diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index 4ce2cf642fce..6e32ff6f2fa0 100644
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -35,8 +35,10 @@
 #include <linux/spinlock.h>
 #include <linux/genhd.h>
 #include <linux/cdrom.h>
-#include <linux/file.h>
+#include <linux/ratelimit.h>
 #include <linux/module.h>
+#include <asm/unaligned.h>
+
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
@@ -46,12 +48,14 @@
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 
+#include "target_core_alua.h"
 #include "target_core_pscsi.h"
 
 #define ISPRINT(a)  ((a >= ' ') && (a <= '~'))
 
 static struct se_subsystem_api pscsi_template;
 
+static int pscsi_execute_cmd(struct se_cmd *cmd);
 static void pscsi_req_done(struct request *, int);
 
 /*      pscsi_attach_hba():
@@ -1019,9 +1023,79 @@ fail:
         return -ENOMEM;
 }
 
-static int pscsi_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
-                u32 sgl_nents, enum dma_data_direction data_direction)
+/*
+ * Clear a lun set in the cdb if the initiator talking to use spoke
+ * and old standards version, as we can't assume the underlying device
+ * won't choke up on it.
+ */
+static inline void pscsi_clear_cdb_lun(unsigned char *cdb)
+{
+        switch (cdb[0]) {
+        case READ_10: /* SBC - RDProtect */
+        case READ_12: /* SBC - RDProtect */
+        case READ_16: /* SBC - RDProtect */
+        case SEND_DIAGNOSTIC: /* SPC - SELF-TEST Code */
+        case VERIFY: /* SBC - VRProtect */
+        case VERIFY_16: /* SBC - VRProtect */
+        case WRITE_VERIFY: /* SBC - VRProtect */
+        case WRITE_VERIFY_12: /* SBC - VRProtect */
+        case MAINTENANCE_IN: /* SPC - Parameter Data Format for SA RTPG */
+                break;
+        default:
+                cdb[1] &= 0x1f; /* clear logical unit number */
+                break;
+        }
+}
+
+static int pscsi_parse_cdb(struct se_cmd *cmd)
+{
+        unsigned char *cdb = cmd->t_task_cdb;
+        unsigned int dummy_size;
+        int ret;
+
+        if (cmd->se_cmd_flags & SCF_BIDI) {
+                cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+                cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
+                return -EINVAL;
+        }
+
+        pscsi_clear_cdb_lun(cdb);
+
+        /*
+         * For REPORT LUNS we always need to emulate the response, for everything
+         * else the default for pSCSI is to pass the command to the underlying
+         * LLD / physical hardware.
+         */
+        switch (cdb[0]) {
+        case REPORT_LUNS:
+                ret = spc_parse_cdb(cmd, &dummy_size);
+                if (ret)
+                        return ret;
+                break;
+        case READ_6:
+        case READ_10:
+        case READ_12:
+        case READ_16:
+        case WRITE_6:
+        case WRITE_10:
+        case WRITE_12:
+        case WRITE_16:
+        case WRITE_VERIFY:
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                /* FALLTHROUGH*/
+        default:
+                cmd->execute_cmd = pscsi_execute_cmd;
+                break;
+        }
+
+        return 0;
+}
+
+static int pscsi_execute_cmd(struct se_cmd *cmd)
 {
+        struct scatterlist *sgl = cmd->t_data_sg;
+        u32 sgl_nents = cmd->t_data_nents;
+        enum dma_data_direction data_direction = cmd->data_direction;
         struct pscsi_dev_virt *pdv = cmd->se_dev->dev_ptr;
         struct pscsi_plugin_task *pt;
         struct request *req;
@@ -1042,7 +1116,7 @@ static int pscsi_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
         memcpy(pt->pscsi_cdb, cmd->t_task_cdb,
                 scsi_command_size(cmd->t_task_cdb));
 
-        if (cmd->se_cmd_flags & SCF_SCSI_NON_DATA_CDB) {
+        if (!sgl) {
                 req = blk_get_request(pdv->pdv_sd->request_queue,
                                 (data_direction == DMA_TO_DEVICE),
                                 GFP_KERNEL);
@@ -1188,7 +1262,7 @@ static struct se_subsystem_api pscsi_template = {
         .create_virtdevice      = pscsi_create_virtdevice,
         .free_device            = pscsi_free_device,
         .transport_complete     = pscsi_transport_complete,
-        .execute_cmd            = pscsi_execute_cmd,
+        .parse_cdb              = pscsi_parse_cdb,
         .check_configfs_dev_params = pscsi_check_configfs_dev_params,
         .set_configfs_dev_params = pscsi_set_configfs_dev_params,
         .show_configfs_dev_params = pscsi_show_configfs_dev_params,
diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c
index d0ceb873c0e5..d00bbe33ff8b 100644
--- a/drivers/target/target_core_rd.c
+++ b/drivers/target/target_core_rd.c
@@ -284,9 +284,11 @@ static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
         return NULL;
 }
 
-static int rd_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
-                u32 sgl_nents, enum dma_data_direction data_direction)
+static int rd_execute_rw(struct se_cmd *cmd)
 {
+        struct scatterlist *sgl = cmd->t_data_sg;
+        u32 sgl_nents = cmd->t_data_nents;
+        enum dma_data_direction data_direction = cmd->data_direction;
         struct se_device *se_dev = cmd->se_dev;
         struct rd_dev *dev = se_dev->dev_ptr;
         struct rd_dev_sg_table *table;
@@ -460,6 +462,15 @@ static sector_t rd_get_blocks(struct se_device *dev)
         return blocks_long;
 }
 
+static struct spc_ops rd_spc_ops = {
+        .execute_rw             = rd_execute_rw,
+};
+
+static int rd_parse_cdb(struct se_cmd *cmd)
+{
+        return sbc_parse_cdb(cmd, &rd_spc_ops);
+}
+
 static struct se_subsystem_api rd_mcp_template = {
         .name                   = "rd_mcp",
         .transport_type         = TRANSPORT_PLUGIN_VHBA_VDEV,
@@ -468,7 +479,7 @@ static struct se_subsystem_api rd_mcp_template = {
         .allocate_virtdevice    = rd_allocate_virtdevice,
         .create_virtdevice      = rd_create_virtdevice,
         .free_device            = rd_free_device,
-        .execute_cmd            = rd_execute_cmd,
+        .parse_cdb              = rd_parse_cdb,
         .check_configfs_dev_params = rd_check_configfs_dev_params,
         .set_configfs_dev_params = rd_set_configfs_dev_params,
         .show_configfs_dev_params = rd_show_configfs_dev_params,
diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
new file mode 100644
index 000000000000..a9dd9469e3bd
--- /dev/null
+++ b/drivers/target/target_core_sbc.c
@@ -0,0 +1,581 @@
+/*
+ * SCSI Block Commands (SBC) parsing and emulation.
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005 PyX Technologies, Inc.
+ * Copyright (c) 2005, 2006, 2007 SBE, Inc.
+ * Copyright (c) 2007-2010 Rising Tide Systems
+ * Copyright (c) 2008-2010 Linux-iSCSI.org
+ *
+ * Nicholas A. Bellinger <nab@kernel.org>
+ *
+ * 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/ratelimit.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_backend.h>
+#include <target/target_core_fabric.h>
+
+#include "target_core_internal.h"
+#include "target_core_ua.h"
+
+
+static int sbc_emulate_readcapacity(struct se_cmd *cmd)
+{
+        struct se_device *dev = cmd->se_dev;
+        unsigned char *buf;
+        unsigned long long blocks_long = dev->transport->get_blocks(dev);
+        u32 blocks;
+
+        if (blocks_long >= 0x00000000ffffffff)
+                blocks = 0xffffffff;
+        else
+                blocks = (u32)blocks_long;
+
+        buf = transport_kmap_data_sg(cmd);
+
+        buf[0] = (blocks >> 24) & 0xff;
+        buf[1] = (blocks >> 16) & 0xff;
+        buf[2] = (blocks >> 8) & 0xff;
+        buf[3] = blocks & 0xff;
+        buf[4] = (dev->se_sub_dev->se_dev_attrib.block_size >> 24) & 0xff;
+        buf[5] = (dev->se_sub_dev->se_dev_attrib.block_size >> 16) & 0xff;
+        buf[6] = (dev->se_sub_dev->se_dev_attrib.block_size >> 8) & 0xff;
+        buf[7] = dev->se_sub_dev->se_dev_attrib.block_size & 0xff;
+
+        transport_kunmap_data_sg(cmd);
+
+        target_complete_cmd(cmd, GOOD);
+        return 0;
+}
+
+static int sbc_emulate_readcapacity_16(struct se_cmd *cmd)
+{
+        struct se_device *dev = cmd->se_dev;
+        unsigned char *buf;
+        unsigned long long blocks = dev->transport->get_blocks(dev);
+
+        buf = transport_kmap_data_sg(cmd);
+
+        buf[0] = (blocks >> 56) & 0xff;
+        buf[1] = (blocks >> 48) & 0xff;
+        buf[2] = (blocks >> 40) & 0xff;
+        buf[3] = (blocks >> 32) & 0xff;
+        buf[4] = (blocks >> 24) & 0xff;
+        buf[5] = (blocks >> 16) & 0xff;
+        buf[6] = (blocks >> 8) & 0xff;
+        buf[7] = blocks & 0xff;
+        buf[8] = (dev->se_sub_dev->se_dev_attrib.block_size >> 24) & 0xff;
+        buf[9] = (dev->se_sub_dev->se_dev_attrib.block_size >> 16) & 0xff;
+        buf[10] = (dev->se_sub_dev->se_dev_attrib.block_size >> 8) & 0xff;
+        buf[11] = dev->se_sub_dev->se_dev_attrib.block_size & 0xff;
+        /*
+         * Set Thin Provisioning Enable bit following sbc3r22 in section
+         * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled.
+         */
+        if (dev->se_sub_dev->se_dev_attrib.emulate_tpu || dev->se_sub_dev->se_dev_attrib.emulate_tpws)
+                buf[14] = 0x80;
+
+        transport_kunmap_data_sg(cmd);
+
+        target_complete_cmd(cmd, GOOD);
+        return 0;
+}
+
+int spc_get_write_same_sectors(struct se_cmd *cmd)
+{
+        u32 num_blocks;
+
+        if (cmd->t_task_cdb[0] == WRITE_SAME)
+                num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]);
+        else if (cmd->t_task_cdb[0] == WRITE_SAME_16)
+                num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
+        else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */
+                num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
+
+        /*
+         * Use the explicit range when non zero is supplied, otherwise calculate
+         * the remaining range based on ->get_blocks() - starting LBA.
+         */
+        if (num_blocks)
+                return num_blocks;
+
+        return cmd->se_dev->transport->get_blocks(cmd->se_dev) -
+                cmd->t_task_lba + 1;
+}
+EXPORT_SYMBOL(spc_get_write_same_sectors);
+
+static int sbc_emulate_verify(struct se_cmd *cmd)
+{
+        target_complete_cmd(cmd, GOOD);
+        return 0;
+}
+
+static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors)
+{
+        return cmd->se_dev->se_sub_dev->se_dev_attrib.block_size * sectors;
+}
+
+static int sbc_check_valid_sectors(struct se_cmd *cmd)
+{
+        struct se_device *dev = cmd->se_dev;
+        unsigned long long end_lba;
+        u32 sectors;
+
+        sectors = cmd->data_length / dev->se_sub_dev->se_dev_attrib.block_size;
+        end_lba = dev->transport->get_blocks(dev) + 1;
+
+        if (cmd->t_task_lba + sectors > end_lba) {
+                pr_err("target: lba %llu, sectors %u exceeds end lba %llu\n",
+                        cmd->t_task_lba, sectors, end_lba);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static inline u32 transport_get_sectors_6(unsigned char *cdb)
+{
+        /*
+         * Use 8-bit sector value.  SBC-3 says:
+         *
+         *   A TRANSFER LENGTH field set to zero specifies that 256
+         *   logical blocks shall be written.  Any other value
+         *   specifies the number of logical blocks that shall be
+         *   written.
+         */
+        return cdb[4] ? : 256;
+}
+
+static inline u32 transport_get_sectors_10(unsigned char *cdb)
+{
+        return (u32)(cdb[7] << 8) + cdb[8];
+}
+
+static inline u32 transport_get_sectors_12(unsigned char *cdb)
+{
+        return (u32)(cdb[6] << 24) + (cdb[7] << 16) + (cdb[8] << 8) + cdb[9];
+}
+
+static inline u32 transport_get_sectors_16(unsigned char *cdb)
+{
+        return (u32)(cdb[10] << 24) + (cdb[11] << 16) +
+                    (cdb[12] << 8) + cdb[13];
+}
+
+/*
+ * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants
+ */
+static inline u32 transport_get_sectors_32(unsigned char *cdb)
+{
+        return (u32)(cdb[28] << 24) + (cdb[29] << 16) +
+                    (cdb[30] << 8) + cdb[31];
+
+}
+
+static inline u32 transport_lba_21(unsigned char *cdb)
+{
+        return ((cdb[1] & 0x1f) << 16) | (cdb[2] << 8) | cdb[3];
+}
+
+static inline u32 transport_lba_32(unsigned char *cdb)
+{
+        return (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
+}
+
+static inline unsigned long long transport_lba_64(unsigned char *cdb)
+{
+        unsigned int __v1, __v2;
+
+        __v1 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
+        __v2 = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
+
+        return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
+}
+
+/*
+ * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs
+ */
+static inline unsigned long long transport_lba_64_ext(unsigned char *cdb)
+{
+        unsigned int __v1, __v2;
+
+        __v1 = (cdb[12] << 24) | (cdb[13] << 16) | (cdb[14] << 8) | cdb[15];
+        __v2 = (cdb[16] << 24) | (cdb[17] << 16) | (cdb[18] << 8) | cdb[19];
+
+        return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
+}
+
+static int sbc_write_same_supported(struct se_device *dev,
+                unsigned char *flags)
+{
+        if ((flags[0] & 0x04) || (flags[0] & 0x02)) {
+                pr_err("WRITE_SAME PBDATA and LBDATA"
+                        " bits not supported for Block Discard"
+                        " Emulation\n");
+                return -ENOSYS;
+        }
+
+        /*
+         * Currently for the emulated case we only accept
+         * tpws with the UNMAP=1 bit set.
+         */
+        if (!(flags[0] & 0x08)) {
+                pr_err("WRITE_SAME w/o UNMAP bit not"
+                        " supported for Block Discard Emulation\n");
+                return -ENOSYS;
+        }
+
+        return 0;
+}
+
+static void xdreadwrite_callback(struct se_cmd *cmd)
+{
+        unsigned char *buf, *addr;
+        struct scatterlist *sg;
+        unsigned int offset;
+        int i;
+        int count;
+        /*
+         * From sbc3r22.pdf section 5.48 XDWRITEREAD (10) command
+         *
+         * 1) read the specified logical block(s);
+         * 2) transfer logical blocks from the data-out buffer;
+         * 3) XOR the logical blocks transferred from the data-out buffer with
+         *    the logical blocks read, storing the resulting XOR data in a buffer;
+         * 4) if the DISABLE WRITE bit is set to zero, then write the logical
+         *    blocks transferred from the data-out buffer; and
+         * 5) transfer the resulting XOR data to the data-in buffer.
+         */
+        buf = kmalloc(cmd->data_length, GFP_KERNEL);
+        if (!buf) {
+                pr_err("Unable to allocate xor_callback buf\n");
+                return;
+        }
+        /*
+         * Copy the scatterlist WRITE buffer located at cmd->t_data_sg
+         * into the locally allocated *buf
+         */
+        sg_copy_to_buffer(cmd->t_data_sg,
+                          cmd->t_data_nents,
+                          buf,
+                          cmd->data_length);
+
+        /*
+         * Now perform the XOR against the BIDI read memory located at
+         * cmd->t_mem_bidi_list
+         */
+
+        offset = 0;
+        for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) {
+                addr = kmap_atomic(sg_page(sg));
+                if (!addr)
+                        goto out;
+
+                for (i = 0; i < sg->length; i++)
+                        *(addr + sg->offset + i) ^= *(buf + offset + i);
+
+                offset += sg->length;
+                kunmap_atomic(addr);
+        }
+
+out:
+        kfree(buf);
+}
+
+int sbc_parse_cdb(struct se_cmd *cmd, struct spc_ops *ops)
+{
+        struct se_subsystem_dev *su_dev = cmd->se_dev->se_sub_dev;
+        struct se_device *dev = cmd->se_dev;
+        unsigned char *cdb = cmd->t_task_cdb;
+        unsigned int size;
+        u32 sectors = 0;
+        int ret;
+
+        switch (cdb[0]) {
+        case READ_6:
+                sectors = transport_get_sectors_6(cdb);
+                cmd->t_task_lba = transport_lba_21(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                cmd->execute_cmd = ops->execute_rw;
+                break;
+        case READ_10:
+                sectors = transport_get_sectors_10(cdb);
+                cmd->t_task_lba = transport_lba_32(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                cmd->execute_cmd = ops->execute_rw;
+                break;
+        case READ_12:
+                sectors = transport_get_sectors_12(cdb);
+                cmd->t_task_lba = transport_lba_32(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                cmd->execute_cmd = ops->execute_rw;
+                break;
+        case READ_16:
+                sectors = transport_get_sectors_16(cdb);
+                cmd->t_task_lba = transport_lba_64(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                cmd->execute_cmd = ops->execute_rw;
+                break;
+        case WRITE_6:
+                sectors = transport_get_sectors_6(cdb);
+                cmd->t_task_lba = transport_lba_21(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                cmd->execute_cmd = ops->execute_rw;
+                break;
+        case WRITE_10:
+        case WRITE_VERIFY:
+                sectors = transport_get_sectors_10(cdb);
+                cmd->t_task_lba = transport_lba_32(cdb);
+                if (cdb[1] & 0x8)
+                        cmd->se_cmd_flags |= SCF_FUA;
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                cmd->execute_cmd = ops->execute_rw;
+                break;
+        case WRITE_12:
+                sectors = transport_get_sectors_12(cdb);
+                cmd->t_task_lba = transport_lba_32(cdb);
+                if (cdb[1] & 0x8)
+                        cmd->se_cmd_flags |= SCF_FUA;
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                cmd->execute_cmd = ops->execute_rw;
+                break;
+        case WRITE_16:
+                sectors = transport_get_sectors_16(cdb);
+                cmd->t_task_lba = transport_lba_64(cdb);
+                if (cdb[1] & 0x8)
+                        cmd->se_cmd_flags |= SCF_FUA;
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                cmd->execute_cmd = ops->execute_rw;
+                break;
+        case XDWRITEREAD_10:
+                if ((cmd->data_direction != DMA_TO_DEVICE) ||
+                    !(cmd->se_cmd_flags & SCF_BIDI))
+                        goto out_invalid_cdb_field;
+                sectors = transport_get_sectors_10(cdb);
+
+                cmd->t_task_lba = transport_lba_32(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+
+                /*
+                 * Setup BIDI XOR callback to be run after I/O completion.
+                 */
+                cmd->execute_cmd = ops->execute_rw;
+                cmd->transport_complete_callback = &xdreadwrite_callback;
+                if (cdb[1] & 0x8)
+                        cmd->se_cmd_flags |= SCF_FUA;
+                break;
+        case VARIABLE_LENGTH_CMD:
+        {
+                u16 service_action = get_unaligned_be16(&cdb[8]);
+                switch (service_action) {
+                case XDWRITEREAD_32:
+                        sectors = transport_get_sectors_32(cdb);
+
+                        /*
+                         * Use WRITE_32 and READ_32 opcodes for the emulated
+                         * XDWRITE_READ_32 logic.
+                         */
+                        cmd->t_task_lba = transport_lba_64_ext(cdb);
+                        cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+
+                        /*
+                         * Setup BIDI XOR callback to be run during after I/O
+                         * completion.
+                         */
+                        cmd->execute_cmd = ops->execute_rw;
+                        cmd->transport_complete_callback = &xdreadwrite_callback;
+                        if (cdb[1] & 0x8)
+                                cmd->se_cmd_flags |= SCF_FUA;
+                        break;
+                case WRITE_SAME_32:
+                        if (!ops->execute_write_same)
+                                goto out_unsupported_cdb;
+
+                        sectors = transport_get_sectors_32(cdb);
+                        if (!sectors) {
+                                pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
+                                       " supported\n");
+                                goto out_invalid_cdb_field;
+                        }
+
+                        size = sbc_get_size(cmd, 1);
+                        cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
+
+                        if (sbc_write_same_supported(dev, &cdb[10]) < 0)
+                                goto out_unsupported_cdb;
+                        cmd->execute_cmd = ops->execute_write_same;
+                        break;
+                default:
+                        pr_err("VARIABLE_LENGTH_CMD service action"
+                                " 0x%04x not supported\n", service_action);
+                        goto out_unsupported_cdb;
+                }
+                break;
+        }
+        case READ_CAPACITY:
+                size = READ_CAP_LEN;
+                cmd->execute_cmd = sbc_emulate_readcapacity;
+                break;
+        case SERVICE_ACTION_IN:
+                switch (cmd->t_task_cdb[1] & 0x1f) {
+                case SAI_READ_CAPACITY_16:
+                        cmd->execute_cmd = sbc_emulate_readcapacity_16;
+                        break;
+                default:
+                        pr_err("Unsupported SA: 0x%02x\n",
+                                cmd->t_task_cdb[1] & 0x1f);
+                        goto out_invalid_cdb_field;
+                }
+                size = (cdb[10] << 24) | (cdb[11] << 16) |
+                       (cdb[12] << 8) | cdb[13];
+                break;
+        case SYNCHRONIZE_CACHE:
+        case SYNCHRONIZE_CACHE_16:
+                if (!ops->execute_sync_cache)
+                        goto out_unsupported_cdb;
+
+                /*
+                 * Extract LBA and range to be flushed for emulated SYNCHRONIZE_CACHE
+                 */
+                if (cdb[0] == SYNCHRONIZE_CACHE) {
+                        sectors = transport_get_sectors_10(cdb);
+                        cmd->t_task_lba = transport_lba_32(cdb);
+                } else {
+                        sectors = transport_get_sectors_16(cdb);
+                        cmd->t_task_lba = transport_lba_64(cdb);
+                }
+
+                size = sbc_get_size(cmd, sectors);
+
+                /*
+                 * Check to ensure that LBA + Range does not exceed past end of
+                 * device for IBLOCK and FILEIO ->do_sync_cache() backend calls
+                 */
+                if (cmd->t_task_lba || sectors) {
+                        if (sbc_check_valid_sectors(cmd) < 0)
+                                goto out_invalid_cdb_field;
+                }
+                cmd->execute_cmd = ops->execute_sync_cache;
+                break;
+        case UNMAP:
+                if (!ops->execute_unmap)
+                        goto out_unsupported_cdb;
+
+                size = get_unaligned_be16(&cdb[7]);
+                cmd->execute_cmd = ops->execute_unmap;
+                break;
+        case WRITE_SAME_16:
+                if (!ops->execute_write_same)
+                        goto out_unsupported_cdb;
+
+                sectors = transport_get_sectors_16(cdb);
+                if (!sectors) {
+                        pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
+                        goto out_invalid_cdb_field;
+                }
+
+                size = sbc_get_size(cmd, 1);
+                cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
+
+                if (sbc_write_same_supported(dev, &cdb[1]) < 0)
+                        goto out_unsupported_cdb;
+                cmd->execute_cmd = ops->execute_write_same;
+                break;
+        case WRITE_SAME:
+                if (!ops->execute_write_same)
+                        goto out_unsupported_cdb;
+
+                sectors = transport_get_sectors_10(cdb);
+                if (!sectors) {
+                        pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
+                        goto out_invalid_cdb_field;
+                }
+
+                size = sbc_get_size(cmd, 1);
+                cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
+
+                /*
+                 * Follow sbcr26 with WRITE_SAME (10) and check for the existence
+                 * of byte 1 bit 3 UNMAP instead of original reserved field
+                 */
+                if (sbc_write_same_supported(dev, &cdb[1]) < 0)
+                        goto out_unsupported_cdb;
+                cmd->execute_cmd = ops->execute_write_same;
+                break;
+        case VERIFY:
+                size = 0;
+                cmd->execute_cmd = sbc_emulate_verify;
+                break;
+        default:
+                ret = spc_parse_cdb(cmd, &size);
+                if (ret)
+                        return ret;
+        }
+
+        /* reject any command that we don't have a handler for */
+        if (!(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) && !cmd->execute_cmd)
+                goto out_unsupported_cdb;
+
+        if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
+                unsigned long long end_lba;
+
+                if (sectors > su_dev->se_dev_attrib.fabric_max_sectors) {
+                        printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
+                                " big sectors %u exceeds fabric_max_sectors:"
+                                " %u\n", cdb[0], sectors,
+                                su_dev->se_dev_attrib.fabric_max_sectors);
+                        goto out_invalid_cdb_field;
+                }
+                if (sectors > su_dev->se_dev_attrib.hw_max_sectors) {
+                        printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
+                                " big sectors %u exceeds backend hw_max_sectors:"
+                                " %u\n", cdb[0], sectors,
+                                su_dev->se_dev_attrib.hw_max_sectors);
+                        goto out_invalid_cdb_field;
+                }
+
+                end_lba = dev->transport->get_blocks(dev) + 1;
+                if (cmd->t_task_lba + sectors > end_lba) {
+                        pr_err("cmd exceeds last lba %llu "
+                                "(lba %llu, sectors %u)\n",
+                                end_lba, cmd->t_task_lba, sectors);
+                        goto out_invalid_cdb_field;
+                }
+
+                size = sbc_get_size(cmd, sectors);
+        }
+
+        ret = target_cmd_size_check(cmd, size);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+
+out_unsupported_cdb:
+        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+        cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
+        return -EINVAL;
+out_invalid_cdb_field:
+        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+        cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
+        return -EINVAL;
+}
+EXPORT_SYMBOL(sbc_parse_cdb);
diff --git a/drivers/target/target_core_cdb.c b/drivers/target/target_core_spc.c
index 9888693a18fe..4c861de538c9 100644
--- a/drivers/target/target_core_cdb.c
+++ b/drivers/target/target_core_spc.c
@@ -1,5 +1,5 @@
 /*
- * CDB emulation for non-READ/WRITE commands.
+ * SCSI Primary Commands (SPC) parsing and emulation.
  *
  * Copyright (c) 2002, 2003, 2004, 2005 PyX Technologies, Inc.
  * Copyright (c) 2005, 2006, 2007 SBE, Inc.
@@ -26,17 +26,21 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <asm/unaligned.h>
+
 #include <scsi/scsi.h>
+#include <scsi/scsi_tcq.h>
 
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
 
 #include "target_core_internal.h"
+#include "target_core_alua.h"
+#include "target_core_pr.h"
 #include "target_core_ua.h"
 
-static void
-target_fill_alua_data(struct se_port *port, unsigned char *buf)
+
+static void spc_fill_alua_data(struct se_port *port, unsigned char *buf)
 {
         struct t10_alua_tg_pt_gp *tg_pt_gp;
         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
@@ -65,8 +69,7 @@ target_fill_alua_data(struct se_port *port, unsigned char *buf)
         spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 }
 
-static int
-target_emulate_inquiry_std(struct se_cmd *cmd, char *buf)
+static int spc_emulate_inquiry_std(struct se_cmd *cmd, char *buf)
 {
         struct se_lun *lun = cmd->se_lun;
         struct se_device *dev = cmd->se_dev;
@@ -93,7 +96,7 @@ target_emulate_inquiry_std(struct se_cmd *cmd, char *buf)
          * Enable SCCS and TPGS fields for Emulated ALUA
          */
         if (dev->se_sub_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED)
-                target_fill_alua_data(lun->lun_sep, buf);
+                spc_fill_alua_data(lun->lun_sep, buf);
 
         buf[7] = 0x2; /* CmdQue=1 */
 
@@ -106,8 +109,7 @@ target_emulate_inquiry_std(struct se_cmd *cmd, char *buf)
 }
 
 /* unit serial number */
-static int
-target_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
+static int spc_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
 {
         struct se_device *dev = cmd->se_dev;
         u16 len = 0;
@@ -127,8 +129,8 @@ target_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
         return 0;
 }
 
-static void
-target_parse_naa_6h_vendor_specific(struct se_device *dev, unsigned char *buf)
+static void spc_parse_naa_6h_vendor_specific(struct se_device *dev,
+                unsigned char *buf)
 {
         unsigned char *p = &dev->se_sub_dev->t10_wwn.unit_serial[0];
         int cnt;
@@ -162,8 +164,7 @@ target_parse_naa_6h_vendor_specific(struct se_device *dev, unsigned char *buf)
  * Device identification VPD, for a complete list of
  * DESIGNATOR TYPEs see spc4r17 Table 459.
  */
-static int
-target_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
+static int spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
 {
         struct se_device *dev = cmd->se_dev;
         struct se_lun *lun = cmd->se_lun;
@@ -220,7 +221,7 @@ target_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
          * VENDOR_SPECIFIC_IDENTIFIER and
          * VENDOR_SPECIFIC_IDENTIFIER_EXTENTION
          */
-        target_parse_naa_6h_vendor_specific(dev, &buf[off]);
+        spc_parse_naa_6h_vendor_specific(dev, &buf[off]);
 
         len = 20;
         off = (len + 4);
@@ -414,8 +415,7 @@ check_scsi_name:
 }
 
 /* Extended INQUIRY Data VPD Page */
-static int
-target_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
+static int spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
 {
         buf[3] = 0x3c;
         /* Set HEADSUP, ORDSUP, SIMPSUP */
@@ -428,15 +428,14 @@ target_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
 }
 
 /* Block Limits VPD page */
-static int
-target_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
+static int spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
 {
         struct se_device *dev = cmd->se_dev;
         u32 max_sectors;
         int have_tp = 0;
 
         /*
-         * Following sbc3r22 section 6.5.3 Block Limits VPD page, when
+         * Following spc3r22 section 6.5.3 Block Limits VPD page, when
          * emulate_tpu=1 or emulate_tpws=1 we will be expect a
          * different page length for Thin Provisioning.
          */
@@ -500,8 +499,7 @@ target_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
 }
 
 /* Block Device Characteristics VPD page */
-static int
-target_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)
+static int spc_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)
 {
         struct se_device *dev = cmd->se_dev;
 
@@ -513,13 +511,12 @@ target_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)
 }
 
 /* Thin Provisioning VPD */
-static int
-target_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
+static int spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
 {
         struct se_device *dev = cmd->se_dev;
 
         /*
-         * From sbc3r22 section 6.5.4 Thin Provisioning VPD page:
+         * From spc3r22 section 6.5.4 Thin Provisioning VPD page:
          *
          * The PAGE LENGTH field is defined in SPC-4. If the DP bit is set to
          * zero, then the page length shall be set to 0004h.  If the DP bit
@@ -564,25 +561,23 @@ target_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
         return 0;
 }
 
-static int
-target_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf);
+static int spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf);
 
 static struct {
         uint8_t         page;
         int             (*emulate)(struct se_cmd *, unsigned char *);
 } evpd_handlers[] = {
-        { .page = 0x00, .emulate = target_emulate_evpd_00 },
-        { .page = 0x80, .emulate = target_emulate_evpd_80 },
-        { .page = 0x83, .emulate = target_emulate_evpd_83 },
-        { .page = 0x86, .emulate = target_emulate_evpd_86 },
-        { .page = 0xb0, .emulate = target_emulate_evpd_b0 },
-        { .page = 0xb1, .emulate = target_emulate_evpd_b1 },
-        { .page = 0xb2, .emulate = target_emulate_evpd_b2 },
+        { .page = 0x00, .emulate = spc_emulate_evpd_00 },
+        { .page = 0x80, .emulate = spc_emulate_evpd_80 },
+        { .page = 0x83, .emulate = spc_emulate_evpd_83 },
+        { .page = 0x86, .emulate = spc_emulate_evpd_86 },
+        { .page = 0xb0, .emulate = spc_emulate_evpd_b0 },
+        { .page = 0xb1, .emulate = spc_emulate_evpd_b1 },
+        { .page = 0xb2, .emulate = spc_emulate_evpd_b2 },
 };
 
 /* supported vital product data pages */
-static int
-target_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
+static int spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
 {
         int p;
 
@@ -601,7 +596,7 @@ target_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
         return 0;
 }
 
-int target_emulate_inquiry(struct se_cmd *cmd)
+static int spc_emulate_inquiry(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
         struct se_portal_group *tpg = cmd->se_lun->lun_sep->sep_tpg;
@@ -643,7 +638,7 @@ int target_emulate_inquiry(struct se_cmd *cmd)
                         goto out;
                 }
 
-                ret = target_emulate_inquiry_std(cmd, buf);
+                ret = spc_emulate_inquiry_std(cmd, buf);
                 goto out;
         }
 
@@ -671,70 +666,7 @@ out:
         return ret;
 }
 
-int target_emulate_readcapacity(struct se_cmd *cmd)
-{
-        struct se_device *dev = cmd->se_dev;
-        unsigned char *buf;
-        unsigned long long blocks_long = dev->transport->get_blocks(dev);
-        u32 blocks;
-
-        if (blocks_long >= 0x00000000ffffffff)
-                blocks = 0xffffffff;
-        else
-                blocks = (u32)blocks_long;
-
-        buf = transport_kmap_data_sg(cmd);
-
-        buf[0] = (blocks >> 24) & 0xff;
-        buf[1] = (blocks >> 16) & 0xff;
-        buf[2] = (blocks >> 8) & 0xff;
-        buf[3] = blocks & 0xff;
-        buf[4] = (dev->se_sub_dev->se_dev_attrib.block_size >> 24) & 0xff;
-        buf[5] = (dev->se_sub_dev->se_dev_attrib.block_size >> 16) & 0xff;
-        buf[6] = (dev->se_sub_dev->se_dev_attrib.block_size >> 8) & 0xff;
-        buf[7] = dev->se_sub_dev->se_dev_attrib.block_size & 0xff;
-
-        transport_kunmap_data_sg(cmd);
-
-        target_complete_cmd(cmd, GOOD);
-        return 0;
-}
-
-int target_emulate_readcapacity_16(struct se_cmd *cmd)
-{
-        struct se_device *dev = cmd->se_dev;
-        unsigned char *buf;
-        unsigned long long blocks = dev->transport->get_blocks(dev);
-
-        buf = transport_kmap_data_sg(cmd);
-
-        buf[0] = (blocks >> 56) & 0xff;
-        buf[1] = (blocks >> 48) & 0xff;
-        buf[2] = (blocks >> 40) & 0xff;
-        buf[3] = (blocks >> 32) & 0xff;
-        buf[4] = (blocks >> 24) & 0xff;
-        buf[5] = (blocks >> 16) & 0xff;
-        buf[6] = (blocks >> 8) & 0xff;
-        buf[7] = blocks & 0xff;
-        buf[8] = (dev->se_sub_dev->se_dev_attrib.block_size >> 24) & 0xff;
-        buf[9] = (dev->se_sub_dev->se_dev_attrib.block_size >> 16) & 0xff;
-        buf[10] = (dev->se_sub_dev->se_dev_attrib.block_size >> 8) & 0xff;
-        buf[11] = dev->se_sub_dev->se_dev_attrib.block_size & 0xff;
-        /*
-         * Set Thin Provisioning Enable bit following sbc3r22 in section
-         * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled.
-         */
-        if (dev->se_sub_dev->se_dev_attrib.emulate_tpu || dev->se_sub_dev->se_dev_attrib.emulate_tpws)
-                buf[14] = 0x80;
-
-        transport_kunmap_data_sg(cmd);
-
-        target_complete_cmd(cmd, GOOD);
-        return 0;
-}
-
-static int
-target_modesense_rwrecovery(unsigned char *p)
+static int spc_modesense_rwrecovery(unsigned char *p)
 {
         p[0] = 0x01;
         p[1] = 0x0a;
@@ -742,8 +674,7 @@ target_modesense_rwrecovery(unsigned char *p)
         return 12;
 }
 
-static int
-target_modesense_control(struct se_device *dev, unsigned char *p)
+static int spc_modesense_control(struct se_device *dev, unsigned char *p)
 {
         p[0] = 0x0a;
         p[1] = 0x0a;
@@ -828,8 +759,7 @@ target_modesense_control(struct se_device *dev, unsigned char *p)
         return 12;
 }
 
-static int
-target_modesense_caching(struct se_device *dev, unsigned char *p)
+static int spc_modesense_caching(struct se_device *dev, unsigned char *p)
 {
         p[0] = 0x08;
         p[1] = 0x12;
@@ -840,8 +770,7 @@ target_modesense_caching(struct se_device *dev, unsigned char *p)
         return 20;
 }
 
-static void
-target_modesense_write_protect(unsigned char *buf, int type)
+static void spc_modesense_write_protect(unsigned char *buf, int type)
 {
         /*
          * I believe that the WP bit (bit 7) in the mode header is the same for
@@ -856,8 +785,7 @@ target_modesense_write_protect(unsigned char *buf, int type)
         }
 }
 
-static void
-target_modesense_dpofua(unsigned char *buf, int type)
+static void spc_modesense_dpofua(unsigned char *buf, int type)
 {
         switch (type) {
         case TYPE_DISK:
@@ -868,7 +796,7 @@ target_modesense_dpofua(unsigned char *buf, int type)
         }
 }
 
-int target_emulate_modesense(struct se_cmd *cmd)
+static int spc_emulate_modesense(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
         char *cdb = cmd->t_task_cdb;
@@ -883,18 +811,18 @@ int target_emulate_modesense(struct se_cmd *cmd)
 
         switch (cdb[2] & 0x3f) {
         case 0x01:
-                length = target_modesense_rwrecovery(&buf[offset]);
+                length = spc_modesense_rwrecovery(&buf[offset]);
                 break;
         case 0x08:
-                length = target_modesense_caching(dev, &buf[offset]);
+                length = spc_modesense_caching(dev, &buf[offset]);
                 break;
         case 0x0a:
-                length = target_modesense_control(dev, &buf[offset]);
+                length = spc_modesense_control(dev, &buf[offset]);
                 break;
         case 0x3f:
-                length = target_modesense_rwrecovery(&buf[offset]);
-                length += target_modesense_caching(dev, &buf[offset+length]);
-                length += target_modesense_control(dev, &buf[offset+length]);
+                length = spc_modesense_rwrecovery(&buf[offset]);
+                length += spc_modesense_caching(dev, &buf[offset+length]);
+                length += spc_modesense_control(dev, &buf[offset+length]);
                 break;
         default:
                 pr_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n",
@@ -912,11 +840,11 @@ int target_emulate_modesense(struct se_cmd *cmd)
                 if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) ||
                     (cmd->se_deve &&
                     (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)))
-                        target_modesense_write_protect(&buf[3], type);
+                        spc_modesense_write_protect(&buf[3], type);
 
                 if ((dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0) &&
                     (dev->se_sub_dev->se_dev_attrib.emulate_fua_write > 0))
-                        target_modesense_dpofua(&buf[3], type);
+                        spc_modesense_dpofua(&buf[3], type);
 
                 if ((offset + 2) > cmd->data_length)
                         offset = cmd->data_length;
@@ -928,11 +856,11 @@ int target_emulate_modesense(struct se_cmd *cmd)
                 if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) ||
                     (cmd->se_deve &&
                     (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)))
-                        target_modesense_write_protect(&buf[2], type);
+                        spc_modesense_write_protect(&buf[2], type);
 
                 if ((dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0) &&
                     (dev->se_sub_dev->se_dev_attrib.emulate_fua_write > 0))
-                        target_modesense_dpofua(&buf[2], type);
+                        spc_modesense_dpofua(&buf[2], type);
 
                 if ((offset + 1) > cmd->data_length)
                         offset = cmd->data_length;
@@ -946,7 +874,7 @@ int target_emulate_modesense(struct se_cmd *cmd)
         return 0;
 }
 
-int target_emulate_request_sense(struct se_cmd *cmd)
+static int spc_emulate_request_sense(struct se_cmd *cmd)
 {
         unsigned char *cdb = cmd->t_task_cdb;
         unsigned char *buf;
@@ -1005,126 +933,172 @@ end:
         return 0;
 }
 
-/*
- * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support.
- * Note this is not used for TCM/pSCSI passthrough
- */
-int target_emulate_unmap(struct se_cmd *cmd)
+static int spc_emulate_testunitready(struct se_cmd *cmd)
 {
-        struct se_device *dev = cmd->se_dev;
-        unsigned char *buf, *ptr = NULL;
-        unsigned char *cdb = &cmd->t_task_cdb[0];
-        sector_t lba;
-        unsigned int size = cmd->data_length, range;
-        int ret = 0, offset;
-        unsigned short dl, bd_dl;
-
-        if (!dev->transport->do_discard) {
-                pr_err("UNMAP emulation not supported for: %s\n",
-                                dev->transport->name);
-                cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
-                return -ENOSYS;
-        }
-
-        /* First UNMAP block descriptor starts at 8 byte offset */
-        offset = 8;
-        size -= 8;
-        dl = get_unaligned_be16(&cdb[0]);
-        bd_dl = get_unaligned_be16(&cdb[2]);
-
-        buf = transport_kmap_data_sg(cmd);
-
-        ptr = &buf[offset];
-        pr_debug("UNMAP: Sub: %s Using dl: %hu bd_dl: %hu size: %hu"
-                " ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr);
-
-        while (size) {
-                lba = get_unaligned_be64(&ptr[0]);
-                range = get_unaligned_be32(&ptr[8]);
-                pr_debug("UNMAP: Using lba: %llu and range: %u\n",
-                                 (unsigned long long)lba, range);
-
-                ret = dev->transport->do_discard(dev, lba, range);
-                if (ret < 0) {
-                        pr_err("blkdev_issue_discard() failed: %d\n",
-                                        ret);
-                        goto err;
-                }
-
-                ptr += 16;
-                size -= 16;
-        }
-
-err:
-        transport_kunmap_data_sg(cmd);
-        if (!ret)
-                target_complete_cmd(cmd, GOOD);
-        return ret;
+        target_complete_cmd(cmd, GOOD);
+        return 0;
 }
 
-/*
- * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support.
- * Note this is not used for TCM/pSCSI passthrough
- */
-int target_emulate_write_same(struct se_cmd *cmd)
+int spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
 {
         struct se_device *dev = cmd->se_dev;
-        sector_t range;
-        sector_t lba = cmd->t_task_lba;
-        u32 num_blocks;
-        int ret;
-
-        if (!dev->transport->do_discard) {
-                pr_err("WRITE_SAME emulation not supported"
-                                " for: %s\n", dev->transport->name);
-                cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
-                return -ENOSYS;
-        }
-
-        if (cmd->t_task_cdb[0] == WRITE_SAME)
-                num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]);
-        else if (cmd->t_task_cdb[0] == WRITE_SAME_16)
-                num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
-        else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */
-                num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
-
-        /*
-         * Use the explicit range when non zero is supplied, otherwise calculate
-         * the remaining range based on ->get_blocks() - starting LBA.
-         */
-        if (num_blocks != 0)
-                range = num_blocks;
-        else
-                range = (dev->transport->get_blocks(dev) - lba);
-
-        pr_debug("WRITE_SAME UNMAP: LBA: %llu Range: %llu\n",
-                 (unsigned long long)lba, (unsigned long long)range);
+        struct se_subsystem_dev *su_dev = dev->se_sub_dev;
+        unsigned char *cdb = cmd->t_task_cdb;
 
-        ret = dev->transport->do_discard(dev, lba, range);
-        if (ret < 0) {
-                pr_debug("blkdev_issue_discard() failed for WRITE_SAME\n");
-                return ret;
-        }
+        switch (cdb[0]) {
+        case MODE_SELECT:
+                *size = cdb[4];
+                break;
+        case MODE_SELECT_10:
+                *size = (cdb[7] << 8) + cdb[8];
+                break;
+        case MODE_SENSE:
+                *size = cdb[4];
+                cmd->execute_cmd = spc_emulate_modesense;
+                break;
+        case MODE_SENSE_10:
+                *size = (cdb[7] << 8) + cdb[8];
+                cmd->execute_cmd = spc_emulate_modesense;
+                break;
+        case LOG_SELECT:
+        case LOG_SENSE:
+                *size = (cdb[7] << 8) + cdb[8];
+                break;
+        case PERSISTENT_RESERVE_IN:
+                if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS)
+                        cmd->execute_cmd = target_scsi3_emulate_pr_in;
+                *size = (cdb[7] << 8) + cdb[8];
+                break;
+        case PERSISTENT_RESERVE_OUT:
+                if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS)
+                        cmd->execute_cmd = target_scsi3_emulate_pr_out;
+                *size = (cdb[7] << 8) + cdb[8];
+                break;
+        case RELEASE:
+        case RELEASE_10:
+                if (cdb[0] == RELEASE_10)
+                        *size = (cdb[7] << 8) | cdb[8];
+                else
+                        *size = cmd->data_length;
+
+                if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH)
+                        cmd->execute_cmd = target_scsi2_reservation_release;
+                break;
+        case RESERVE:
+        case RESERVE_10:
+                /*
+                 * The SPC-2 RESERVE does not contain a size in the SCSI CDB.
+                 * Assume the passthrough or $FABRIC_MOD will tell us about it.
+                 */
+                if (cdb[0] == RESERVE_10)
+                        *size = (cdb[7] << 8) | cdb[8];
+                else
+                        *size = cmd->data_length;
 
-        target_complete_cmd(cmd, GOOD);
-        return 0;
-}
+                /*
+                 * Setup the legacy emulated handler for SPC-2 and
+                 * >= SPC-3 compatible reservation handling (CRH=1)
+                 * Otherwise, we assume the underlying SCSI logic is
+                 * is running in SPC_PASSTHROUGH, and wants reservations
+                 * emulation disabled.
+                 */
+                if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH)
+                        cmd->execute_cmd = target_scsi2_reservation_reserve;
+                break;
+        case REQUEST_SENSE:
+                *size = cdb[4];
+                cmd->execute_cmd = spc_emulate_request_sense;
+                break;
+        case INQUIRY:
+                *size = (cdb[3] << 8) + cdb[4];
 
-int target_emulate_synchronize_cache(struct se_cmd *cmd)
-{
-        if (!cmd->se_dev->transport->do_sync_cache) {
-                pr_err("SYNCHRONIZE_CACHE emulation not supported"
-                        " for: %s\n", cmd->se_dev->transport->name);
+                /*
+                 * Do implict HEAD_OF_QUEUE processing for INQUIRY.
+                 * See spc4r17 section 5.3
+                 */
+                if (cmd->se_dev->dev_task_attr_type == SAM_TASK_ATTR_EMULATED)
+                        cmd->sam_task_attr = MSG_HEAD_TAG;
+                cmd->execute_cmd = spc_emulate_inquiry;
+                break;
+        case SECURITY_PROTOCOL_IN:
+        case SECURITY_PROTOCOL_OUT:
+                *size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
+                break;
+        case EXTENDED_COPY:
+        case READ_ATTRIBUTE:
+        case RECEIVE_COPY_RESULTS:
+        case WRITE_ATTRIBUTE:
+                *size = (cdb[10] << 24) | (cdb[11] << 16) |
+                       (cdb[12] << 8) | cdb[13];
+                break;
+        case RECEIVE_DIAGNOSTIC:
+        case SEND_DIAGNOSTIC:
+                *size = (cdb[3] << 8) | cdb[4];
+                break;
+        case WRITE_BUFFER:
+                *size = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8];
+                break;
+        case REPORT_LUNS:
+                cmd->execute_cmd = target_report_luns;
+                *size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
+                /*
+                 * Do implict HEAD_OF_QUEUE processing for REPORT_LUNS
+                 * See spc4r17 section 5.3
+                 */
+                if (cmd->se_dev->dev_task_attr_type == SAM_TASK_ATTR_EMULATED)
+                        cmd->sam_task_attr = MSG_HEAD_TAG;
+                break;
+        case TEST_UNIT_READY:
+                cmd->execute_cmd = spc_emulate_testunitready;
+                *size = 0;
+                break;
+        case MAINTENANCE_IN:
+                if (dev->transport->get_device_type(dev) != TYPE_ROM) {
+                        /*
+                         * MAINTENANCE_IN from SCC-2
+                         * Check for emulated MI_REPORT_TARGET_PGS
+                         */
+                        if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS &&
+                            su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
+                                cmd->execute_cmd =
+                                        target_emulate_report_target_port_groups;
+                        }
+                        *size = get_unaligned_be32(&cdb[6]);
+                } else {
+                        /*
+                         * GPCMD_SEND_KEY from multi media commands
+                         */
+                        *size = get_unaligned_be16(&cdb[8]);
+                }
+                break;
+        case MAINTENANCE_OUT:
+                if (dev->transport->get_device_type(dev) != TYPE_ROM) {
+                        /*
+                         * MAINTENANCE_OUT from SCC-2
+                         * Check for emulated MO_SET_TARGET_PGS.
+                         */
+                        if (cdb[1] == MO_SET_TARGET_PGS &&
+                            su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
+                                cmd->execute_cmd =
+                                        target_emulate_set_target_port_groups;
+                        }
+                        *size = get_unaligned_be32(&cdb[6]);
+                } else {
+                        /*
+                         * GPCMD_SEND_KEY from multi media commands
+                         */
+                        *size = get_unaligned_be16(&cdb[8]);
+                }
+                break;
+        default:
+                pr_warn("TARGET_CORE[%s]: Unsupported SCSI Opcode"
+                        " 0x%02x, sending CHECK_CONDITION.\n",
+                        cmd->se_tfo->get_fabric_name(), cdb[0]);
+                cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
                 cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
-                return -ENOSYS;
+                return -EINVAL;
         }
 
-        cmd->se_dev->transport->do_sync_cache(cmd);
-        return 0;
-}
-
-int target_emulate_noop(struct se_cmd *cmd)
-{
-        target_complete_cmd(cmd, GOOD);
         return 0;
 }
+EXPORT_SYMBOL(spc_parse_cdb);
diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index 84caf1bed9a3..1c59a3c23b2c 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -295,9 +295,6 @@ static void core_tmr_drain_state_list(
 
                 list_move_tail(&cmd->state_list, &drain_task_list);
                 cmd->state_active = false;
-
-                if (!list_empty(&cmd->execute_list))
-                        __target_remove_from_execute_list(cmd);
         }
         spin_unlock_irqrestore(&dev->execute_task_lock, flags);
 
@@ -354,57 +351,6 @@ static void core_tmr_drain_state_list(
         }
 }
 
-static void core_tmr_drain_cmd_list(
-        struct se_device *dev,
-        struct se_cmd *prout_cmd,
-        struct se_node_acl *tmr_nacl,
-        int tas,
-        struct list_head *preempt_and_abort_list)
-{
-        LIST_HEAD(drain_cmd_list);
-        struct se_queue_obj *qobj = &dev->dev_queue_obj;
-        struct se_cmd *cmd, *tcmd;
-        unsigned long flags;
-
-        /*
-         * Release all commands remaining in the per-device command queue.
-         *
-         * This follows the same logic as above for the state list.
-         */
-        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
-        list_for_each_entry_safe(cmd, tcmd, &qobj->qobj_list, se_queue_node) {
-                /*
-                 * For PREEMPT_AND_ABORT usage, only process commands
-                 * with a matching reservation key.
-                 */
-                if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
-                        continue;
-                /*
-                 * Not aborting PROUT PREEMPT_AND_ABORT CDB..
-                 */
-                if (prout_cmd == cmd)
-                        continue;
-
-                cmd->transport_state &= ~CMD_T_QUEUED;
-                atomic_dec(&qobj->queue_cnt);
-                list_move_tail(&cmd->se_queue_node, &drain_cmd_list);
-        }
-        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
-
-        while (!list_empty(&drain_cmd_list)) {
-                cmd = list_entry(drain_cmd_list.next, struct se_cmd, se_queue_node);
-                list_del_init(&cmd->se_queue_node);
-
-                pr_debug("LUN_RESET: %s from Device Queue: cmd: %p t_state:"
-                        " %d t_fe_count: %d\n", (preempt_and_abort_list) ?
-                        "Preempt" : "", cmd, cmd->t_state,
-                        atomic_read(&cmd->t_fe_count));
-
-                core_tmr_handle_tas_abort(tmr_nacl, cmd, tas,
-                                atomic_read(&cmd->t_fe_count));
-        }
-}
-
 int core_tmr_lun_reset(
         struct se_device *dev,
         struct se_tmr_req *tmr,
@@ -447,8 +393,7 @@ int core_tmr_lun_reset(
         core_tmr_drain_tmr_list(dev, tmr, preempt_and_abort_list);
         core_tmr_drain_state_list(dev, prout_cmd, tmr_nacl, tas,
                                 preempt_and_abort_list);
-        core_tmr_drain_cmd_list(dev, prout_cmd, tmr_nacl, tas,
-                                preempt_and_abort_list);
+
         /*
          * Clear any legacy SPC-2 reservation when called during
          * LOGICAL UNIT RESET
diff --git a/drivers/target/target_core_tpg.c b/drivers/target/target_core_tpg.c
index 8bd58e284185..b8628a5014b9 100644
--- a/drivers/target/target_core_tpg.c
+++ b/drivers/target/target_core_tpg.c
@@ -77,8 +77,8 @@ static void core_clear_initiator_node_from_tpg(
 
                 lun = deve->se_lun;
                 spin_unlock_irq(&nacl->device_list_lock);
-                core_update_device_list_for_node(lun, NULL, deve->mapped_lun,
-                        TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg, 0);
+                core_disable_device_list_for_node(lun, NULL, deve->mapped_lun,
+                        TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
 
                 spin_lock_irq(&nacl->device_list_lock);
         }
@@ -172,8 +172,8 @@ void core_tpg_add_node_to_devs(
                         (lun_access == TRANSPORT_LUNFLAGS_READ_WRITE) ?
                         "READ-WRITE" : "READ-ONLY");
 
-                core_update_device_list_for_node(lun, NULL, lun->unpacked_lun,
-                                lun_access, acl, tpg, 1);
+                core_enable_device_list_for_node(lun, NULL, lun->unpacked_lun,
+                                lun_access, acl, tpg);
                 spin_lock(&tpg->tpg_lun_lock);
         }
         spin_unlock(&tpg->tpg_lun_lock);
@@ -306,10 +306,8 @@ struct se_node_acl *core_tpg_check_initiator_node_acl(
          * TPG LUNs if the fabric is not explictly asking for
          * tpg_check_demo_mode_login_only() == 1.
          */
-        if ((tpg->se_tpg_tfo->tpg_check_demo_mode_login_only != NULL) &&
-            (tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg) == 1))
-                do { ; } while (0);
-        else
+        if ((tpg->se_tpg_tfo->tpg_check_demo_mode_login_only == NULL) ||
+            (tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg) != 1))
                 core_tpg_add_node_to_devs(acl, tpg);
 
         spin_lock_irq(&tpg->acl_node_lock);
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 634d0f31a28c..0eaae23d12b5 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -66,15 +66,12 @@ struct kmem_cache *t10_alua_lu_gp_mem_cache;
 struct kmem_cache *t10_alua_tg_pt_gp_cache;
 struct kmem_cache *t10_alua_tg_pt_gp_mem_cache;
 
-static int transport_generic_write_pending(struct se_cmd *);
-static int transport_processing_thread(void *param);
-static int __transport_execute_tasks(struct se_device *dev, struct se_cmd *);
 static void transport_complete_task_attr(struct se_cmd *cmd);
 static void transport_handle_queue_full(struct se_cmd *cmd,
                 struct se_device *dev);
 static int transport_generic_get_mem(struct se_cmd *cmd);
+static int target_get_sess_cmd(struct se_session *, struct se_cmd *, bool);
 static void transport_put_cmd(struct se_cmd *cmd);
-static void transport_remove_cmd_from_queue(struct se_cmd *cmd);
 static int transport_set_sense_codes(struct se_cmd *cmd, u8 asc, u8 ascq);
 static void target_complete_ok_work(struct work_struct *work);
 
@@ -195,14 +192,6 @@ u32 scsi_get_new_index(scsi_index_t type)
         return new_index;
 }
 
-static void transport_init_queue_obj(struct se_queue_obj *qobj)
-{
-        atomic_set(&qobj->queue_cnt, 0);
-        INIT_LIST_HEAD(&qobj->qobj_list);
-        init_waitqueue_head(&qobj->thread_wq);
-        spin_lock_init(&qobj->cmd_queue_lock);
-}
-
 void transport_subsystem_check_init(void)
 {
         int ret;
@@ -243,7 +232,6 @@ struct se_session *transport_init_session(void)
         INIT_LIST_HEAD(&se_sess->sess_list);
         INIT_LIST_HEAD(&se_sess->sess_acl_list);
         INIT_LIST_HEAD(&se_sess->sess_cmd_list);
-        INIT_LIST_HEAD(&se_sess->sess_wait_list);
         spin_lock_init(&se_sess->sess_cmd_lock);
         kref_init(&se_sess->sess_kref);
 
@@ -468,18 +456,7 @@ static void target_remove_from_state_list(struct se_cmd *cmd)
         spin_unlock_irqrestore(&dev->execute_task_lock, flags);
 }
 
-/*      transport_cmd_check_stop():
- *
- *      'transport_off = 1' determines if CMD_T_ACTIVE should be cleared.
- *      'transport_off = 2' determines if task_dev_state should be removed.
- *
- *      A non-zero u8 t_state sets cmd->t_state.
- *      Returns 1 when command is stopped, else 0.
- */
-static int transport_cmd_check_stop(
-        struct se_cmd *cmd,
-        int transport_off,
-        u8 t_state)
+static int transport_cmd_check_stop(struct se_cmd *cmd, bool remove_from_lists)
 {
         unsigned long flags;
 
@@ -493,13 +470,23 @@ static int transport_cmd_check_stop(
                         __func__, __LINE__, cmd->se_tfo->get_task_tag(cmd));
 
                 cmd->transport_state &= ~CMD_T_ACTIVE;
-                if (transport_off == 2)
+                if (remove_from_lists)
                         target_remove_from_state_list(cmd);
                 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
                 complete(&cmd->transport_lun_stop_comp);
                 return 1;
         }
+
+        if (remove_from_lists) {
+                target_remove_from_state_list(cmd);
+
+                /*
+                 * Clear struct se_cmd->se_lun before the handoff to FE.
+                 */
+                cmd->se_lun = NULL;
+        }
+
         /*
          * Determine if frontend context caller is requesting the stopping of
          * this command for frontend exceptions.
@@ -509,58 +496,36 @@ static int transport_cmd_check_stop(
                         __func__, __LINE__,
                         cmd->se_tfo->get_task_tag(cmd));
 
-                if (transport_off == 2)
-                        target_remove_from_state_list(cmd);
-
-                /*
-                 * Clear struct se_cmd->se_lun before the transport_off == 2 handoff
-                 * to FE.
-                 */
-                if (transport_off == 2)
-                        cmd->se_lun = NULL;
                 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
                 complete(&cmd->t_transport_stop_comp);
                 return 1;
         }
-        if (transport_off) {
-                cmd->transport_state &= ~CMD_T_ACTIVE;
-                if (transport_off == 2) {
-                        target_remove_from_state_list(cmd);
-                        /*
-                         * Clear struct se_cmd->se_lun before the transport_off == 2
-                         * handoff to fabric module.
-                         */
-                        cmd->se_lun = NULL;
-                        /*
-                         * Some fabric modules like tcm_loop can release
-                         * their internally allocated I/O reference now and
-                         * struct se_cmd now.
-                         *
-                         * Fabric modules are expected to return '1' here if the
-                         * se_cmd being passed is released at this point,
-                         * or zero if not being released.
-                         */
-                        if (cmd->se_tfo->check_stop_free != NULL) {
-                                spin_unlock_irqrestore(
-                                        &cmd->t_state_lock, flags);
-
-                                return cmd->se_tfo->check_stop_free(cmd);
-                        }
+
+        cmd->transport_state &= ~CMD_T_ACTIVE;
+        if (remove_from_lists) {
+                /*
+                 * Some fabric modules like tcm_loop can release
+                 * their internally allocated I/O reference now and
+                 * struct se_cmd now.
+                 *
+                 * Fabric modules are expected to return '1' here if the
+                 * se_cmd being passed is released at this point,
+                 * or zero if not being released.
+                 */
+                if (cmd->se_tfo->check_stop_free != NULL) {
+                        spin_unlock_irqrestore(&cmd->t_state_lock, flags);
+                        return cmd->se_tfo->check_stop_free(cmd);
                 }
-                spin_unlock_irqrestore(&cmd->t_state_lock, flags);
+        }
 
-                return 0;
-        } else if (t_state)
-                cmd->t_state = t_state;
         spin_unlock_irqrestore(&cmd->t_state_lock, flags);
-
         return 0;
 }
 
 static int transport_cmd_check_stop_to_fabric(struct se_cmd *cmd)
 {
-        return transport_cmd_check_stop(cmd, 2, 0);
+        return transport_cmd_check_stop(cmd, true);
 }
 
 static void transport_lun_remove_cmd(struct se_cmd *cmd)
@@ -591,79 +556,8 @@ void transport_cmd_finish_abort(struct se_cmd *cmd, int remove)
 
         if (transport_cmd_check_stop_to_fabric(cmd))
                 return;
-        if (remove) {
-                transport_remove_cmd_from_queue(cmd);
+        if (remove)
                 transport_put_cmd(cmd);
-        }
-}
-
-static void transport_add_cmd_to_queue(struct se_cmd *cmd, int t_state,
-                bool at_head)
-{
-        struct se_device *dev = cmd->se_dev;
-        struct se_queue_obj *qobj = &dev->dev_queue_obj;
-        unsigned long flags;
-
-        if (t_state) {
-                spin_lock_irqsave(&cmd->t_state_lock, flags);
-                cmd->t_state = t_state;
-                cmd->transport_state |= CMD_T_ACTIVE;
-                spin_unlock_irqrestore(&cmd->t_state_lock, flags);
-        }
-
-        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
-
-        /* If the cmd is already on the list, remove it before we add it */
-        if (!list_empty(&cmd->se_queue_node))
-                list_del(&cmd->se_queue_node);
-        else
-                atomic_inc(&qobj->queue_cnt);
-
-        if (at_head)
-                list_add(&cmd->se_queue_node, &qobj->qobj_list);
-        else
-                list_add_tail(&cmd->se_queue_node, &qobj->qobj_list);
-        cmd->transport_state |= CMD_T_QUEUED;
-        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
-
-        wake_up_interruptible(&qobj->thread_wq);
-}
-
-static struct se_cmd *
-transport_get_cmd_from_queue(struct se_queue_obj *qobj)
-{
-        struct se_cmd *cmd;
-        unsigned long flags;
-
-        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
-        if (list_empty(&qobj->qobj_list)) {
-                spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
-                return NULL;
-        }
-        cmd = list_first_entry(&qobj->qobj_list, struct se_cmd, se_queue_node);
-
-        cmd->transport_state &= ~CMD_T_QUEUED;
-        list_del_init(&cmd->se_queue_node);
-        atomic_dec(&qobj->queue_cnt);
-        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
-
-        return cmd;
-}
-
-static void transport_remove_cmd_from_queue(struct se_cmd *cmd)
-{
-        struct se_queue_obj *qobj = &cmd->se_dev->dev_queue_obj;
-        unsigned long flags;
-
-        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
-        if (!(cmd->transport_state & CMD_T_QUEUED)) {
-                spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
-                return;
-        }
-        cmd->transport_state &= ~CMD_T_QUEUED;
-        atomic_dec(&qobj->queue_cnt);
-        list_del_init(&cmd->se_queue_node);
-        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
 }
 
 static void target_complete_failure_work(struct work_struct *work)
@@ -742,68 +636,11 @@ static void target_add_to_state_list(struct se_cmd *cmd)
         spin_unlock_irqrestore(&dev->execute_task_lock, flags);
 }
 
-static void __target_add_to_execute_list(struct se_cmd *cmd)
-{
-        struct se_device *dev = cmd->se_dev;
-        bool head_of_queue = false;
-
-        if (!list_empty(&cmd->execute_list))
-                return;
-
-        if (dev->dev_task_attr_type == SAM_TASK_ATTR_EMULATED &&
-            cmd->sam_task_attr == MSG_HEAD_TAG)
-                head_of_queue = true;
-
-        if (head_of_queue)
-                list_add(&cmd->execute_list, &dev->execute_list);
-        else
-                list_add_tail(&cmd->execute_list, &dev->execute_list);
-
-        atomic_inc(&dev->execute_tasks);
-
-        if (cmd->state_active)
-                return;
-
-        if (head_of_queue)
-                list_add(&cmd->state_list, &dev->state_list);
-        else
-                list_add_tail(&cmd->state_list, &dev->state_list);
-
-        cmd->state_active = true;
-}
-
-static void target_add_to_execute_list(struct se_cmd *cmd)
-{
-        unsigned long flags;
-        struct se_device *dev = cmd->se_dev;
-
-        spin_lock_irqsave(&dev->execute_task_lock, flags);
-        __target_add_to_execute_list(cmd);
-        spin_unlock_irqrestore(&dev->execute_task_lock, flags);
-}
-
-void __target_remove_from_execute_list(struct se_cmd *cmd)
-{
-        list_del_init(&cmd->execute_list);
-        atomic_dec(&cmd->se_dev->execute_tasks);
-}
-
-static void target_remove_from_execute_list(struct se_cmd *cmd)
-{
-        struct se_device *dev = cmd->se_dev;
-        unsigned long flags;
-
-        if (WARN_ON(list_empty(&cmd->execute_list)))
-                return;
-
-        spin_lock_irqsave(&dev->execute_task_lock, flags);
-        __target_remove_from_execute_list(cmd);
-        spin_unlock_irqrestore(&dev->execute_task_lock, flags);
-}
-
 /*
  * Handle QUEUE_FULL / -EAGAIN and -ENOMEM status
  */
+static void transport_write_pending_qf(struct se_cmd *cmd);
+static void transport_complete_qf(struct se_cmd *cmd);
 
 static void target_qf_do_work(struct work_struct *work)
 {
@@ -827,7 +664,10 @@ static void target_qf_do_work(struct work_struct *work)
                         (cmd->t_state == TRANSPORT_COMPLETE_QF_WP) ? "WRITE_PENDING"
                         : "UNKNOWN");
 
-                transport_add_cmd_to_queue(cmd, cmd->t_state, true);
+                if (cmd->t_state == TRANSPORT_COMPLETE_QF_WP)
+                        transport_write_pending_qf(cmd);
+                else if (cmd->t_state == TRANSPORT_COMPLETE_QF_OK)
+                        transport_complete_qf(cmd);
         }
 }
 
@@ -874,8 +714,7 @@ void transport_dump_dev_state(
                 break;
         }
 
-        *bl += sprintf(b + *bl, "  Execute/Max Queue Depth: %d/%d",
-                atomic_read(&dev->execute_tasks), dev->queue_depth);
+        *bl += sprintf(b + *bl, "  Max Queue Depth: %d", dev->queue_depth);
         *bl += sprintf(b + *bl, "  SectorSize: %u  HwMaxSectors: %u\n",
                 dev->se_sub_dev->se_dev_attrib.block_size,
                 dev->se_sub_dev->se_dev_attrib.hw_max_sectors);
@@ -1212,7 +1051,6 @@ struct se_device *transport_add_device_to_core_hba(
                 return NULL;
         }
 
-        transport_init_queue_obj(&dev->dev_queue_obj);
         dev->dev_flags          = device_flags;
         dev->dev_status         |= TRANSPORT_DEVICE_DEACTIVATED;
         dev->dev_ptr            = transport_dev;
@@ -1222,7 +1060,6 @@ struct se_device *transport_add_device_to_core_hba(
         INIT_LIST_HEAD(&dev->dev_list);
         INIT_LIST_HEAD(&dev->dev_sep_list);
         INIT_LIST_HEAD(&dev->dev_tmr_list);
-        INIT_LIST_HEAD(&dev->execute_list);
         INIT_LIST_HEAD(&dev->delayed_cmd_list);
         INIT_LIST_HEAD(&dev->state_list);
         INIT_LIST_HEAD(&dev->qf_cmd_list);
@@ -1261,17 +1098,17 @@ struct se_device *transport_add_device_to_core_hba(
          * Setup the Asymmetric Logical Unit Assignment for struct se_device
          */
         if (core_setup_alua(dev, force_pt) < 0)
-                goto out;
+                goto err_dev_list;
 
         /*
          * Startup the struct se_device processing thread
          */
-        dev->process_thread = kthread_run(transport_processing_thread, dev,
-                                          "LIO_%s", dev->transport->name);
-        if (IS_ERR(dev->process_thread)) {
-                pr_err("Unable to create kthread: LIO_%s\n",
+        dev->tmr_wq = alloc_workqueue("tmr-%s", WQ_MEM_RECLAIM | WQ_UNBOUND, 1,
+                                      dev->transport->name);
+        if (!dev->tmr_wq) {
+                pr_err("Unable to create tmr workqueue for %s\n",
                         dev->transport->name);
-                goto out;
+                goto err_dev_list;
         }
         /*
          * Setup work_queue for QUEUE_FULL
@@ -1289,7 +1126,7 @@ struct se_device *transport_add_device_to_core_hba(
                 if (!inquiry_prod || !inquiry_rev) {
                         pr_err("All non TCM/pSCSI plugins require"
                                 " INQUIRY consts\n");
-                        goto out;
+                        goto err_wq;
                 }
 
                 strncpy(&dev->se_sub_dev->t10_wwn.vendor[0], "LIO-ORG", 8);
@@ -1299,9 +1136,10 @@ struct se_device *transport_add_device_to_core_hba(
         scsi_dump_inquiry(dev);
 
         return dev;
-out:
-        kthread_stop(dev->process_thread);
 
+err_wq:
+        destroy_workqueue(dev->tmr_wq);
+err_dev_list:
         spin_lock(&hba->device_lock);
         list_del(&dev->dev_list);
         hba->dev_count--;
@@ -1315,35 +1153,54 @@ out:
 }
 EXPORT_SYMBOL(transport_add_device_to_core_hba);
 
-/*      transport_generic_prepare_cdb():
- *
- *      Since the Initiator sees iSCSI devices as LUNs,  the SCSI CDB will
- *      contain the iSCSI LUN in bits 7-5 of byte 1 as per SAM-2.
- *      The point of this is since we are mapping iSCSI LUNs to
- *      SCSI Target IDs having a non-zero LUN in the CDB will throw the
- *      devices and HBAs for a loop.
- */
-static inline void transport_generic_prepare_cdb(
-        unsigned char *cdb)
+int target_cmd_size_check(struct se_cmd *cmd, unsigned int size)
 {
-        switch (cdb[0]) {
-        case READ_10: /* SBC - RDProtect */
-        case READ_12: /* SBC - RDProtect */
-        case READ_16: /* SBC - RDProtect */
-        case SEND_DIAGNOSTIC: /* SPC - SELF-TEST Code */
-        case VERIFY: /* SBC - VRProtect */
-        case VERIFY_16: /* SBC - VRProtect */
-        case WRITE_VERIFY: /* SBC - VRProtect */
-        case WRITE_VERIFY_12: /* SBC - VRProtect */
-        case MAINTENANCE_IN: /* SPC - Parameter Data Format for SA RTPG */
-                break;
-        default:
-                cdb[1] &= 0x1f; /* clear logical unit number */
-                break;
+        struct se_device *dev = cmd->se_dev;
+
+        if (cmd->unknown_data_length) {
+                cmd->data_length = size;
+        } else if (size != cmd->data_length) {
+                pr_warn("TARGET_CORE[%s]: Expected Transfer Length:"
+                        " %u does not match SCSI CDB Length: %u for SAM Opcode:"
+                        " 0x%02x\n", cmd->se_tfo->get_fabric_name(),
+                                cmd->data_length, size, cmd->t_task_cdb[0]);
+
+                cmd->cmd_spdtl = size;
+
+                if (cmd->data_direction == DMA_TO_DEVICE) {
+                        pr_err("Rejecting underflow/overflow"
+                                        " WRITE data\n");
+                        goto out_invalid_cdb_field;
+                }
+                /*
+                 * Reject READ_* or WRITE_* with overflow/underflow for
+                 * type SCF_SCSI_DATA_CDB.
+                 */
+                if (dev->se_sub_dev->se_dev_attrib.block_size != 512)  {
+                        pr_err("Failing OVERFLOW/UNDERFLOW for LBA op"
+                                " CDB on non 512-byte sector setup subsystem"
+                                " plugin: %s\n", dev->transport->name);
+                        /* Returns CHECK_CONDITION + INVALID_CDB_FIELD */
+                        goto out_invalid_cdb_field;
+                }
+
+                if (size > cmd->data_length) {
+                        cmd->se_cmd_flags |= SCF_OVERFLOW_BIT;
+                        cmd->residual_count = (size - cmd->data_length);
+                } else {
+                        cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT;
+                        cmd->residual_count = (cmd->data_length - size);
+                }
+                cmd->data_length = size;
         }
-}
 
-static int transport_generic_cmd_sequencer(struct se_cmd *, unsigned char *);
+        return 0;
+
+out_invalid_cdb_field:
+        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+        cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
+        return -EINVAL;
+}
 
 /*
  * Used by fabric modules containing a local struct se_cmd within their
@@ -1361,9 +1218,7 @@ void transport_init_se_cmd(
         INIT_LIST_HEAD(&cmd->se_lun_node);
         INIT_LIST_HEAD(&cmd->se_delayed_node);
         INIT_LIST_HEAD(&cmd->se_qf_node);
-        INIT_LIST_HEAD(&cmd->se_queue_node);
         INIT_LIST_HEAD(&cmd->se_cmd_list);
-        INIT_LIST_HEAD(&cmd->execute_list);
         INIT_LIST_HEAD(&cmd->state_list);
         init_completion(&cmd->transport_lun_fe_stop_comp);
         init_completion(&cmd->transport_lun_stop_comp);
@@ -1418,9 +1273,12 @@ int target_setup_cmd_from_cdb(
         struct se_cmd *cmd,
         unsigned char *cdb)
 {
+        struct se_subsystem_dev *su_dev = cmd->se_dev->se_sub_dev;
+        u32 pr_reg_type = 0;
+        u8 alua_ascq = 0;
+        unsigned long flags;
         int ret;
 
-        transport_generic_prepare_cdb(cdb);
         /*
          * Ensure that the received CDB is less than the max (252 + 8) bytes
          * for VARIABLE_LENGTH_CMD
@@ -1457,15 +1315,66 @@ int target_setup_cmd_from_cdb(
          * Copy the original CDB into cmd->
          */
         memcpy(cmd->t_task_cdb, cdb, scsi_command_size(cdb));
+
         /*
-         * Setup the received CDB based on SCSI defined opcodes and
-         * perform unit attention, persistent reservations and ALUA
-         * checks for virtual device backends.  The cmd->t_task_cdb
-         * pointer is expected to be setup before we reach this point.
+         * Check for an existing UNIT ATTENTION condition
          */
-        ret = transport_generic_cmd_sequencer(cmd, cdb);
+        if (core_scsi3_ua_check(cmd, cdb) < 0) {
+                cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+                cmd->scsi_sense_reason = TCM_CHECK_CONDITION_UNIT_ATTENTION;
+                return -EINVAL;
+        }
+
+        ret = su_dev->t10_alua.alua_state_check(cmd, cdb, &alua_ascq);
+        if (ret != 0) {
+                /*
+                 * Set SCSI additional sense code (ASC) to 'LUN Not Accessible';
+                 * The ALUA additional sense code qualifier (ASCQ) is determined
+                 * by the ALUA primary or secondary access state..
+                 */
+                if (ret > 0) {
+                        pr_debug("[%s]: ALUA TG Port not available, "
+                                "SenseKey: NOT_READY, ASC/ASCQ: "
+                                "0x04/0x%02x\n",
+                                cmd->se_tfo->get_fabric_name(), alua_ascq);
+
+                        transport_set_sense_codes(cmd, 0x04, alua_ascq);
+                        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+                        cmd->scsi_sense_reason = TCM_CHECK_CONDITION_NOT_READY;
+                        return -EINVAL;
+                }
+                cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+                cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
+                return -EINVAL;
+        }
+
+        /*
+         * Check status for SPC-3 Persistent Reservations
+         */
+        if (su_dev->t10_pr.pr_ops.t10_reservation_check(cmd, &pr_reg_type)) {
+                if (su_dev->t10_pr.pr_ops.t10_seq_non_holder(
+                                        cmd, cdb, pr_reg_type) != 0) {
+                        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+                        cmd->se_cmd_flags |= SCF_SCSI_RESERVATION_CONFLICT;
+                        cmd->scsi_status = SAM_STAT_RESERVATION_CONFLICT;
+                        cmd->scsi_sense_reason = TCM_RESERVATION_CONFLICT;
+                        return -EBUSY;
+                }
+                /*
+                 * This means the CDB is allowed for the SCSI Initiator port
+                 * when said port is *NOT* holding the legacy SPC-2 or
+                 * SPC-3 Persistent Reservation.
+                 */
+        }
+
+        ret = cmd->se_dev->transport->parse_cdb(cmd);
         if (ret < 0)
                 return ret;
+
+        spin_lock_irqsave(&cmd->t_state_lock, flags);
+        cmd->se_cmd_flags |= SCF_SUPPORTED_SAM_OPCODE;
+        spin_unlock_irqrestore(&cmd->t_state_lock, flags);
+
         /*
          * Check for SAM Task Attribute Emulation
          */
@@ -1503,10 +1412,9 @@ int transport_handle_cdb_direct(
                 return -EINVAL;
         }
         /*
-         * Set TRANSPORT_NEW_CMD state and CMD_T_ACTIVE following
-         * transport_generic_handle_cdb*() -> transport_add_cmd_to_queue()
-         * in existing usage to ensure that outstanding descriptors are handled
-         * correctly during shutdown via transport_wait_for_tasks()
+         * Set TRANSPORT_NEW_CMD state and CMD_T_ACTIVE to ensure that
+         * outstanding descriptors are handled correctly during shutdown via
+         * transport_wait_for_tasks()
          *
          * Also, we don't take cmd->t_state_lock here as we only expect
          * this to be called for initial descriptor submission.
@@ -1540,10 +1448,14 @@ EXPORT_SYMBOL(transport_handle_cdb_direct);
  * @data_dir: DMA data direction
  * @flags: flags for command submission from target_sc_flags_tables
  *
+ * Returns non zero to signal active I/O shutdown failure.  All other
+ * setup exceptions will be returned as a SCSI CHECK_CONDITION response,
+ * but still return zero here.
+ *
  * This may only be called from process context, and also currently
  * assumes internal allocation of fabric payload buffer by target-core.
  **/
-void target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,
+int target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,
                 unsigned char *cdb, unsigned char *sense, u32 unpacked_lun,
                 u32 data_length, int task_attr, int data_dir, int flags)
 {
@@ -1569,7 +1481,9 @@ void target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,
          * for fabrics using TARGET_SCF_ACK_KREF that expect a second
          * kref_put() to happen during fabric packet acknowledgement.
          */
-        target_get_sess_cmd(se_sess, se_cmd, (flags & TARGET_SCF_ACK_KREF));
+        rc = target_get_sess_cmd(se_sess, se_cmd, (flags & TARGET_SCF_ACK_KREF));
+        if (rc)
+                return rc;
         /*
          * Signal bidirectional data payloads to target-core
          */
@@ -1582,16 +1496,13 @@ void target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,
                 transport_send_check_condition_and_sense(se_cmd,
                                 se_cmd->scsi_sense_reason, 0);
                 target_put_sess_cmd(se_sess, se_cmd);
-                return;
+                return 0;
         }
-        /*
-         * Sanitize CDBs via transport_generic_cmd_sequencer() and
-         * allocate the necessary tasks to complete the received CDB+data
-         */
+
         rc = target_setup_cmd_from_cdb(se_cmd, cdb);
         if (rc != 0) {
                 transport_generic_request_failure(se_cmd);
-                return;
+                return 0;
         }
 
         /*
@@ -1600,14 +1511,8 @@ void target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,
          */
         core_alua_check_nonop_delay(se_cmd);
 
-        /*
-         * Dispatch se_cmd descriptor to se_lun->lun_se_dev backend
-         * for immediate execution of READs, otherwise wait for
-         * transport_generic_handle_data() to be called for WRITEs
-         * when fabric has filled the incoming buffer.
-         */
         transport_handle_cdb_direct(se_cmd);
-        return;
+        return 0;
 }
 EXPORT_SYMBOL(target_submit_cmd);
 
@@ -1662,7 +1567,11 @@ int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,
                 se_cmd->se_tmr_req->ref_task_tag = tag;
 
         /* See target_submit_cmd for commentary */
-        target_get_sess_cmd(se_sess, se_cmd, (flags & TARGET_SCF_ACK_KREF));
+        ret = target_get_sess_cmd(se_sess, se_cmd, (flags & TARGET_SCF_ACK_KREF));
+        if (ret) {
+                core_tmr_release_req(se_cmd->se_tmr_req);
+                return ret;
+        }
 
         ret = transport_lookup_tmr_lun(se_cmd, unpacked_lun);
         if (ret) {
@@ -1680,67 +1589,6 @@ int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,
 EXPORT_SYMBOL(target_submit_tmr);
 
 /*
- * Used by fabric module frontends defining a TFO->new_cmd_map() caller
- * to  queue up a newly setup se_cmd w/ TRANSPORT_NEW_CMD_MAP in order to
- * complete setup in TCM process context w/ TFO->new_cmd_map().
- */
-int transport_generic_handle_cdb_map(
-        struct se_cmd *cmd)
-{
-        if (!cmd->se_lun) {
-                dump_stack();
-                pr_err("cmd->se_lun is NULL\n");
-                return -EINVAL;
-        }
-
-        transport_add_cmd_to_queue(cmd, TRANSPORT_NEW_CMD_MAP, false);
-        return 0;
-}
-EXPORT_SYMBOL(transport_generic_handle_cdb_map);
-
-/*      transport_generic_handle_data():
- *
- *
- */
-int transport_generic_handle_data(
-        struct se_cmd *cmd)
-{
-        /*
-         * For the software fabric case, then we assume the nexus is being
-         * failed/shutdown when signals are pending from the kthread context
-         * caller, so we return a failure.  For the HW target mode case running
-         * in interrupt code, the signal_pending() check is skipped.
-         */
-        if (!in_interrupt() && signal_pending(current))
-                return -EPERM;
-        /*
-         * If the received CDB has aleady been ABORTED by the generic
-         * target engine, we now call transport_check_aborted_status()
-         * to queue any delated TASK_ABORTED status for the received CDB to the
-         * fabric module as we are expecting no further incoming DATA OUT
-         * sequences at this point.
-         */
-        if (transport_check_aborted_status(cmd, 1) != 0)
-                return 0;
-
-        transport_add_cmd_to_queue(cmd, TRANSPORT_PROCESS_WRITE, false);
-        return 0;
-}
-EXPORT_SYMBOL(transport_generic_handle_data);
-
-/*      transport_generic_handle_tmr():
- *
- *
- */
-int transport_generic_handle_tmr(
-        struct se_cmd *cmd)
-{
-        transport_add_cmd_to_queue(cmd, TRANSPORT_PROCESS_TMR, false);
-        return 0;
-}
-EXPORT_SYMBOL(transport_generic_handle_tmr);
-
-/*
  * If the cmd is active, request it to be stopped and sleep until it
  * has completed.
  */
@@ -1797,6 +1645,7 @@ void transport_generic_request_failure(struct se_cmd *cmd)
         case TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE:
         case TCM_UNKNOWN_MODE_PAGE:
         case TCM_WRITE_PROTECTED:
+        case TCM_ADDRESS_OUT_OF_RANGE:
         case TCM_CHECK_CONDITION_ABORT_CMD:
         case TCM_CHECK_CONDITION_UNIT_ATTENTION:
         case TCM_CHECK_CONDITION_NOT_READY:
@@ -1832,13 +1681,7 @@ void transport_generic_request_failure(struct se_cmd *cmd)
                 cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
                 break;
         }
-        /*
-         * If a fabric does not define a cmd->se_tfo->new_cmd_map caller,
-         * make the call to transport_send_check_condition_and_sense()
-         * directly.  Otherwise expect the fabric to make the call to
-         * transport_send_check_condition_and_sense() after handling
-         * possible unsoliticied write data payloads.
-         */
+
         ret = transport_send_check_condition_and_sense(cmd,
                         cmd->scsi_sense_reason, 0);
         if (ret == -EAGAIN || ret == -ENOMEM)
@@ -1856,406 +1699,123 @@ queue_full:
 }
 EXPORT_SYMBOL(transport_generic_request_failure);
 
-static inline u32 transport_lba_21(unsigned char *cdb)
+static void __target_execute_cmd(struct se_cmd *cmd)
 {
-        return ((cdb[1] & 0x1f) << 16) | (cdb[2] << 8) | cdb[3];
-}
+        int error = 0;
 
-static inline u32 transport_lba_32(unsigned char *cdb)
-{
-        return (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
-}
-
-static inline unsigned long long transport_lba_64(unsigned char *cdb)
-{
-        unsigned int __v1, __v2;
-
-        __v1 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
-        __v2 = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
-
-        return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
-}
-
-/*
- * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs
- */
-static inline unsigned long long transport_lba_64_ext(unsigned char *cdb)
-{
-        unsigned int __v1, __v2;
-
-        __v1 = (cdb[12] << 24) | (cdb[13] << 16) | (cdb[14] << 8) | cdb[15];
-        __v2 = (cdb[16] << 24) | (cdb[17] << 16) | (cdb[18] << 8) | cdb[19];
-
-        return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
-}
-
-static void transport_set_supported_SAM_opcode(struct se_cmd *se_cmd)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&se_cmd->t_state_lock, flags);
-        se_cmd->se_cmd_flags |= SCF_SUPPORTED_SAM_OPCODE;
-        spin_unlock_irqrestore(&se_cmd->t_state_lock, flags);
-}
-
-/*
- * Called from Fabric Module context from transport_execute_tasks()
- *
- * The return of this function determins if the tasks from struct se_cmd
- * get added to the execution queue in transport_execute_tasks(),
- * or are added to the delayed or ordered lists here.
- */
-static inline int transport_execute_task_attr(struct se_cmd *cmd)
-{
-        if (cmd->se_dev->dev_task_attr_type != SAM_TASK_ATTR_EMULATED)
-                return 1;
-        /*
-         * Check for the existence of HEAD_OF_QUEUE, and if true return 1
-         * to allow the passed struct se_cmd list of tasks to the front of the list.
-         */
-         if (cmd->sam_task_attr == MSG_HEAD_TAG) {
-                pr_debug("Added HEAD_OF_QUEUE for CDB:"
-                        " 0x%02x, se_ordered_id: %u\n",
-                        cmd->t_task_cdb[0],
-                        cmd->se_ordered_id);
-                return 1;
-        } else if (cmd->sam_task_attr == MSG_ORDERED_TAG) {
-                atomic_inc(&cmd->se_dev->dev_ordered_sync);
-                smp_mb__after_atomic_inc();
-
-                pr_debug("Added ORDERED for CDB: 0x%02x to ordered"
-                                " list, se_ordered_id: %u\n",
-                                cmd->t_task_cdb[0],
-                                cmd->se_ordered_id);
-                /*
-                 * Add ORDERED command to tail of execution queue if
-                 * no other older commands exist that need to be
-                 * completed first.
-                 */
-                if (!atomic_read(&cmd->se_dev->simple_cmds))
-                        return 1;
-        } else {
-                /*
-                 * For SIMPLE and UNTAGGED Task Attribute commands
-                 */
-                atomic_inc(&cmd->se_dev->simple_cmds);
-                smp_mb__after_atomic_inc();
-        }
-        /*
-         * Otherwise if one or more outstanding ORDERED task attribute exist,
-         * add the dormant task(s) built for the passed struct se_cmd to the
-         * execution queue and become in Active state for this struct se_device.
-         */
-        if (atomic_read(&cmd->se_dev->dev_ordered_sync) != 0) {
-                /*
-                 * Otherwise, add cmd w/ tasks to delayed cmd queue that
-                 * will be drained upon completion of HEAD_OF_QUEUE task.
-                 */
-                spin_lock(&cmd->se_dev->delayed_cmd_lock);
-                cmd->se_cmd_flags |= SCF_DELAYED_CMD_FROM_SAM_ATTR;
-                list_add_tail(&cmd->se_delayed_node,
-                                &cmd->se_dev->delayed_cmd_list);
-                spin_unlock(&cmd->se_dev->delayed_cmd_lock);
-
-                pr_debug("Added CDB: 0x%02x Task Attr: 0x%02x to"
-                        " delayed CMD list, se_ordered_id: %u\n",
-                        cmd->t_task_cdb[0], cmd->sam_task_attr,
-                        cmd->se_ordered_id);
-                /*
-                 * Return zero to let transport_execute_tasks() know
-                 * not to add the delayed tasks to the execution list.
-                 */
-                return 0;
-        }
-        /*
-         * Otherwise, no ORDERED task attributes exist..
-         */
-        return 1;
-}
-
-/*
- * Called from fabric module context in transport_generic_new_cmd() and
- * transport_generic_process_write()
- */
-static void transport_execute_tasks(struct se_cmd *cmd)
-{
-        int add_tasks;
-        struct se_device *se_dev = cmd->se_dev;
-        /*
-         * Call transport_cmd_check_stop() to see if a fabric exception
-         * has occurred that prevents execution.
-         */
-        if (!transport_cmd_check_stop(cmd, 0, TRANSPORT_PROCESSING)) {
-                /*
-                 * Check for SAM Task Attribute emulation and HEAD_OF_QUEUE
-                 * attribute for the tasks of the received struct se_cmd CDB
-                 */
-                add_tasks = transport_execute_task_attr(cmd);
-                if (add_tasks) {
-                        __transport_execute_tasks(se_dev, cmd);
-                        return;
-                }
-        }
-        __transport_execute_tasks(se_dev, NULL);
-}
-
-static int __transport_execute_tasks(struct se_device *dev, struct se_cmd *new_cmd)
-{
-        int error;
-        struct se_cmd *cmd = NULL;
-        unsigned long flags;
-
-check_depth:
-        spin_lock_irq(&dev->execute_task_lock);
-        if (new_cmd != NULL)
-                __target_add_to_execute_list(new_cmd);
-
-        if (list_empty(&dev->execute_list)) {
-                spin_unlock_irq(&dev->execute_task_lock);
-                return 0;
-        }
-        cmd = list_first_entry(&dev->execute_list, struct se_cmd, execute_list);
-        __target_remove_from_execute_list(cmd);
-        spin_unlock_irq(&dev->execute_task_lock);
-
-        spin_lock_irqsave(&cmd->t_state_lock, flags);
-        cmd->transport_state |= CMD_T_BUSY;
-        cmd->transport_state |= CMD_T_SENT;
-
-        spin_unlock_irqrestore(&cmd->t_state_lock, flags);
+        spin_lock_irq(&cmd->t_state_lock);
+        cmd->transport_state |= (CMD_T_BUSY|CMD_T_SENT);
+        spin_unlock_irq(&cmd->t_state_lock);
 
         if (cmd->execute_cmd)
                 error = cmd->execute_cmd(cmd);
-        else {
-                error = dev->transport->execute_cmd(cmd, cmd->t_data_sg,
-                                cmd->t_data_nents, cmd->data_direction);
-        }
 
-        if (error != 0) {
-                spin_lock_irqsave(&cmd->t_state_lock, flags);
-                cmd->transport_state &= ~CMD_T_BUSY;
-                cmd->transport_state &= ~CMD_T_SENT;
-                spin_unlock_irqrestore(&cmd->t_state_lock, flags);
+        if (error) {
+                spin_lock_irq(&cmd->t_state_lock);
+                cmd->transport_state &= ~(CMD_T_BUSY|CMD_T_SENT);
+                spin_unlock_irq(&cmd->t_state_lock);
 
                 transport_generic_request_failure(cmd);
         }
-
-        new_cmd = NULL;
-        goto check_depth;
-
-        return 0;
 }
 
-static inline u32 transport_get_sectors_6(
-        unsigned char *cdb,
-        struct se_cmd *cmd,
-        int *ret)
+void target_execute_cmd(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
 
         /*
-         * Assume TYPE_DISK for non struct se_device objects.
-         * Use 8-bit sector value.
-         */
-        if (!dev)
-                goto type_disk;
-
-        /*
-         * Use 24-bit allocation length for TYPE_TAPE.
+         * If the received CDB has aleady been aborted stop processing it here.
          */
-        if (dev->transport->get_device_type(dev) == TYPE_TAPE)
-                return (u32)(cdb[2] << 16) + (cdb[3] << 8) + cdb[4];
-
-        /*
-         * Everything else assume TYPE_DISK Sector CDB location.
-         * Use 8-bit sector value.  SBC-3 says:
-         *
-         *   A TRANSFER LENGTH field set to zero specifies that 256
-         *   logical blocks shall be written.  Any other value
-         *   specifies the number of logical blocks that shall be
-         *   written.
-         */
-type_disk:
-        return cdb[4] ? : 256;
-}
-
-static inline u32 transport_get_sectors_10(
-        unsigned char *cdb,
-        struct se_cmd *cmd,
-        int *ret)
-{
-        struct se_device *dev = cmd->se_dev;
+        if (transport_check_aborted_status(cmd, 1))
+                return;
 
         /*
-         * Assume TYPE_DISK for non struct se_device objects.
-         * Use 16-bit sector value.
+         * Determine if IOCTL context caller in requesting the stopping of this
+         * command for LUN shutdown purposes.
          */
-        if (!dev)
-                goto type_disk;
+        spin_lock_irq(&cmd->t_state_lock);
+        if (cmd->transport_state & CMD_T_LUN_STOP) {
+                pr_debug("%s:%d CMD_T_LUN_STOP for ITT: 0x%08x\n",
+                        __func__, __LINE__, cmd->se_tfo->get_task_tag(cmd));
 
-        /*
-         * XXX_10 is not defined in SSC, throw an exception
-         */
-        if (dev->transport->get_device_type(dev) == TYPE_TAPE) {
-                *ret = -EINVAL;
-                return 0;
+                cmd->transport_state &= ~CMD_T_ACTIVE;
+                spin_unlock_irq(&cmd->t_state_lock);
+                complete(&cmd->transport_lun_stop_comp);
+                return;
         }
-
         /*
-         * Everything else assume TYPE_DISK Sector CDB location.
-         * Use 16-bit sector value.
-         */
-type_disk:
-        return (u32)(cdb[7] << 8) + cdb[8];
-}
-
-static inline u32 transport_get_sectors_12(
-        unsigned char *cdb,
-        struct se_cmd *cmd,
-        int *ret)
-{
-        struct se_device *dev = cmd->se_dev;
-
-        /*
-         * Assume TYPE_DISK for non struct se_device objects.
-         * Use 32-bit sector value.
+         * Determine if frontend context caller is requesting the stopping of
+         * this command for frontend exceptions.
          */
-        if (!dev)
-                goto type_disk;
+        if (cmd->transport_state & CMD_T_STOP) {
+                pr_debug("%s:%d CMD_T_STOP for ITT: 0x%08x\n",
+                        __func__, __LINE__,
+                        cmd->se_tfo->get_task_tag(cmd));
 
-        /*
-         * XXX_12 is not defined in SSC, throw an exception
-         */
-        if (dev->transport->get_device_type(dev) == TYPE_TAPE) {
-                *ret = -EINVAL;
-                return 0;
+                spin_unlock_irq(&cmd->t_state_lock);
+                complete(&cmd->t_transport_stop_comp);
+                return;
         }
 
-        /*
-         * Everything else assume TYPE_DISK Sector CDB location.
-         * Use 32-bit sector value.
-         */
-type_disk:
-        return (u32)(cdb[6] << 24) + (cdb[7] << 16) + (cdb[8] << 8) + cdb[9];
-}
-
-static inline u32 transport_get_sectors_16(
-        unsigned char *cdb,
-        struct se_cmd *cmd,
-        int *ret)
-{
-        struct se_device *dev = cmd->se_dev;
-
-        /*
-         * Assume TYPE_DISK for non struct se_device objects.
-         * Use 32-bit sector value.
-         */
-        if (!dev)
-                goto type_disk;
+        cmd->t_state = TRANSPORT_PROCESSING;
+        spin_unlock_irq(&cmd->t_state_lock);
 
-        /*
-         * Use 24-bit allocation length for TYPE_TAPE.
-         */
-        if (dev->transport->get_device_type(dev) == TYPE_TAPE)
-                return (u32)(cdb[12] << 16) + (cdb[13] << 8) + cdb[14];
-
-type_disk:
-        return (u32)(cdb[10] << 24) + (cdb[11] << 16) +
-                    (cdb[12] << 8) + cdb[13];
-}
+        if (dev->dev_task_attr_type != SAM_TASK_ATTR_EMULATED)
+                goto execute;
 
-/*
- * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants
- */
-static inline u32 transport_get_sectors_32(
-        unsigned char *cdb,
-        struct se_cmd *cmd,
-        int *ret)
-{
         /*
-         * Assume TYPE_DISK for non struct se_device objects.
-         * Use 32-bit sector value.
+         * Check for the existence of HEAD_OF_QUEUE, and if true return 1
+         * to allow the passed struct se_cmd list of tasks to the front of the list.
          */
-        return (u32)(cdb[28] << 24) + (cdb[29] << 16) +
-                    (cdb[30] << 8) + cdb[31];
+        switch (cmd->sam_task_attr) {
+        case MSG_HEAD_TAG:
+                pr_debug("Added HEAD_OF_QUEUE for CDB: 0x%02x, "
+                         "se_ordered_id: %u\n",
+                         cmd->t_task_cdb[0], cmd->se_ordered_id);
+                goto execute;
+        case MSG_ORDERED_TAG:
+                atomic_inc(&dev->dev_ordered_sync);
+                smp_mb__after_atomic_inc();
 
-}
+                pr_debug("Added ORDERED for CDB: 0x%02x to ordered list, "
+                         " se_ordered_id: %u\n",
+                         cmd->t_task_cdb[0], cmd->se_ordered_id);
 
-static inline u32 transport_get_size(
-        u32 sectors,
-        unsigned char *cdb,
-        struct se_cmd *cmd)
-{
-        struct se_device *dev = cmd->se_dev;
-
-        if (dev->transport->get_device_type(dev) == TYPE_TAPE) {
-                if (cdb[1] & 1) { /* sectors */
-                        return dev->se_sub_dev->se_dev_attrib.block_size * sectors;
-                } else /* bytes */
-                        return sectors;
+                /*
+                 * Execute an ORDERED command if no other older commands
+                 * exist that need to be completed first.
+                 */
+                if (!atomic_read(&dev->simple_cmds))
+                        goto execute;
+                break;
+        default:
+                /*
+                 * For SIMPLE and UNTAGGED Task Attribute commands
+                 */
+                atomic_inc(&dev->simple_cmds);
+                smp_mb__after_atomic_inc();
+                break;
         }
 
-        pr_debug("Returning block_size: %u, sectors: %u == %u for"
-                " %s object\n", dev->se_sub_dev->se_dev_attrib.block_size,
-                sectors, dev->se_sub_dev->se_dev_attrib.block_size * sectors,
-                dev->transport->name);
-
-        return dev->se_sub_dev->se_dev_attrib.block_size * sectors;
-}
+        if (atomic_read(&dev->dev_ordered_sync) != 0) {
+                spin_lock(&dev->delayed_cmd_lock);
+                list_add_tail(&cmd->se_delayed_node, &dev->delayed_cmd_list);
+                spin_unlock(&dev->delayed_cmd_lock);
 
-static void transport_xor_callback(struct se_cmd *cmd)
-{
-        unsigned char *buf, *addr;
-        struct scatterlist *sg;
-        unsigned int offset;
-        int i;
-        int count;
-        /*
-         * From sbc3r22.pdf section 5.48 XDWRITEREAD (10) command
-         *
-         * 1) read the specified logical block(s);
-         * 2) transfer logical blocks from the data-out buffer;
-         * 3) XOR the logical blocks transferred from the data-out buffer with
-         *    the logical blocks read, storing the resulting XOR data in a buffer;
-         * 4) if the DISABLE WRITE bit is set to zero, then write the logical
-         *    blocks transferred from the data-out buffer; and
-         * 5) transfer the resulting XOR data to the data-in buffer.
-         */
-        buf = kmalloc(cmd->data_length, GFP_KERNEL);
-        if (!buf) {
-                pr_err("Unable to allocate xor_callback buf\n");
+                pr_debug("Added CDB: 0x%02x Task Attr: 0x%02x to"
+                        " delayed CMD list, se_ordered_id: %u\n",
+                        cmd->t_task_cdb[0], cmd->sam_task_attr,
+                        cmd->se_ordered_id);
                 return;
         }
-        /*
-         * Copy the scatterlist WRITE buffer located at cmd->t_data_sg
-         * into the locally allocated *buf
-         */
-        sg_copy_to_buffer(cmd->t_data_sg,
-                          cmd->t_data_nents,
-                          buf,
-                          cmd->data_length);
 
+execute:
         /*
-         * Now perform the XOR against the BIDI read memory located at
-         * cmd->t_mem_bidi_list
+         * Otherwise, no ORDERED task attributes exist..
          */
-
-        offset = 0;
-        for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) {
-                addr = kmap_atomic(sg_page(sg));
-                if (!addr)
-                        goto out;
-
-                for (i = 0; i < sg->length; i++)
-                        *(addr + sg->offset + i) ^= *(buf + offset + i);
-
-                offset += sg->length;
-                kunmap_atomic(addr);
-        }
-
-out:
-        kfree(buf);
+        __target_execute_cmd(cmd);
 }
+EXPORT_SYMBOL(target_execute_cmd);
 
 /*
  * Used to obtain Sense Data from underlying Linux/SCSI struct scsi_cmnd
@@ -2312,737 +1872,31 @@ out:
         return -1;
 }
 
-static inline long long transport_dev_end_lba(struct se_device *dev)
-{
-        return dev->transport->get_blocks(dev) + 1;
-}
-
-static int transport_cmd_get_valid_sectors(struct se_cmd *cmd)
-{
-        struct se_device *dev = cmd->se_dev;
-        u32 sectors;
-
-        if (dev->transport->get_device_type(dev) != TYPE_DISK)
-                return 0;
-
-        sectors = (cmd->data_length / dev->se_sub_dev->se_dev_attrib.block_size);
-
-        if ((cmd->t_task_lba + sectors) > transport_dev_end_lba(dev)) {
-                pr_err("LBA: %llu Sectors: %u exceeds"
-                        " transport_dev_end_lba(): %llu\n",
-                        cmd->t_task_lba, sectors,
-                        transport_dev_end_lba(dev));
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
-static int target_check_write_same_discard(unsigned char *flags, struct se_device *dev)
-{
-        /*
-         * Determine if the received WRITE_SAME is used to for direct
-         * passthrough into Linux/SCSI with struct request via TCM/pSCSI
-         * or we are signaling the use of internal WRITE_SAME + UNMAP=1
-         * emulation for -> Linux/BLOCK disbard with TCM/IBLOCK code.
-         */
-        int passthrough = (dev->transport->transport_type ==
-                                TRANSPORT_PLUGIN_PHBA_PDEV);
-
-        if (!passthrough) {
-                if ((flags[0] & 0x04) || (flags[0] & 0x02)) {
-                        pr_err("WRITE_SAME PBDATA and LBDATA"
-                                " bits not supported for Block Discard"
-                                " Emulation\n");
-                        return -ENOSYS;
-                }
-                /*
-                 * Currently for the emulated case we only accept
-                 * tpws with the UNMAP=1 bit set.
-                 */
-                if (!(flags[0] & 0x08)) {
-                        pr_err("WRITE_SAME w/o UNMAP bit not"
-                                " supported for Block Discard Emulation\n");
-                        return -ENOSYS;
-                }
-        }
-
-        return 0;
-}
-
-/*      transport_generic_cmd_sequencer():
- *
- *      Generic Command Sequencer that should work for most DAS transport
- *      drivers.
- *
- *      Called from target_setup_cmd_from_cdb() in the $FABRIC_MOD
- *      RX Thread.
- *
- *      FIXME: Need to support other SCSI OPCODES where as well.
+/*
+ * Process all commands up to the last received ORDERED task attribute which
+ * requires another blocking boundary
  */
-static int transport_generic_cmd_sequencer(
-        struct se_cmd *cmd,
-        unsigned char *cdb)
+static void target_restart_delayed_cmds(struct se_device *dev)
 {
-        struct se_device *dev = cmd->se_dev;
-        struct se_subsystem_dev *su_dev = dev->se_sub_dev;
-        int ret = 0, sector_ret = 0, passthrough;
-        u32 sectors = 0, size = 0, pr_reg_type = 0;
-        u16 service_action;
-        u8 alua_ascq = 0;
-        /*
-         * Check for an existing UNIT ATTENTION condition
-         */
-        if (core_scsi3_ua_check(cmd, cdb) < 0) {
-                cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
-                cmd->scsi_sense_reason = TCM_CHECK_CONDITION_UNIT_ATTENTION;
-                return -EINVAL;
-        }
-        /*
-         * Check status of Asymmetric Logical Unit Assignment port
-         */
-        ret = su_dev->t10_alua.alua_state_check(cmd, cdb, &alua_ascq);
-        if (ret != 0) {
-                /*
-                 * Set SCSI additional sense code (ASC) to 'LUN Not Accessible';
-                 * The ALUA additional sense code qualifier (ASCQ) is determined
-                 * by the ALUA primary or secondary access state..
-                 */
-                if (ret > 0) {
-                        pr_debug("[%s]: ALUA TG Port not available,"
-                                " SenseKey: NOT_READY, ASC/ASCQ: 0x04/0x%02x\n",
-                                cmd->se_tfo->get_fabric_name(), alua_ascq);
+        for (;;) {
+                struct se_cmd *cmd;
 
-                        transport_set_sense_codes(cmd, 0x04, alua_ascq);
-                        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
-                        cmd->scsi_sense_reason = TCM_CHECK_CONDITION_NOT_READY;
-                        return -EINVAL;
-                }
-                goto out_invalid_cdb_field;
-        }
-        /*
-         * Check status for SPC-3 Persistent Reservations
-         */
-        if (su_dev->t10_pr.pr_ops.t10_reservation_check(cmd, &pr_reg_type) != 0) {
-                if (su_dev->t10_pr.pr_ops.t10_seq_non_holder(
-                                        cmd, cdb, pr_reg_type) != 0) {
-                        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
-                        cmd->se_cmd_flags |= SCF_SCSI_RESERVATION_CONFLICT;
-                        cmd->scsi_status = SAM_STAT_RESERVATION_CONFLICT;
-                        cmd->scsi_sense_reason = TCM_RESERVATION_CONFLICT;
-                        return -EBUSY;
-                }
-                /*
-                 * This means the CDB is allowed for the SCSI Initiator port
-                 * when said port is *NOT* holding the legacy SPC-2 or
-                 * SPC-3 Persistent Reservation.
-                 */
-        }
-
-        /*
-         * If we operate in passthrough mode we skip most CDB emulation and
-         * instead hand the commands down to the physical SCSI device.
-         */
-        passthrough =
-                (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV);
-
-        switch (cdb[0]) {
-        case READ_6:
-                sectors = transport_get_sectors_6(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->t_task_lba = transport_lba_21(cdb);
-                cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-                break;
-        case READ_10:
-                sectors = transport_get_sectors_10(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->t_task_lba = transport_lba_32(cdb);
-                cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-                break;
-        case READ_12:
-                sectors = transport_get_sectors_12(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->t_task_lba = transport_lba_32(cdb);
-                cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-                break;
-        case READ_16:
-                sectors = transport_get_sectors_16(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->t_task_lba = transport_lba_64(cdb);
-                cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-                break;
-        case WRITE_6:
-                sectors = transport_get_sectors_6(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->t_task_lba = transport_lba_21(cdb);
-                cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-                break;
-        case WRITE_10:
-        case WRITE_VERIFY:
-                sectors = transport_get_sectors_10(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->t_task_lba = transport_lba_32(cdb);
-                if (cdb[1] & 0x8)
-                        cmd->se_cmd_flags |= SCF_FUA;
-                cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-                break;
-        case WRITE_12:
-                sectors = transport_get_sectors_12(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->t_task_lba = transport_lba_32(cdb);
-                if (cdb[1] & 0x8)
-                        cmd->se_cmd_flags |= SCF_FUA;
-                cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-                break;
-        case WRITE_16:
-                sectors = transport_get_sectors_16(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->t_task_lba = transport_lba_64(cdb);
-                if (cdb[1] & 0x8)
-                        cmd->se_cmd_flags |= SCF_FUA;
-                cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-                break;
-        case XDWRITEREAD_10:
-                if ((cmd->data_direction != DMA_TO_DEVICE) ||
-                    !(cmd->se_cmd_flags & SCF_BIDI))
-                        goto out_invalid_cdb_field;
-                sectors = transport_get_sectors_10(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->t_task_lba = transport_lba_32(cdb);
-                cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-
-                /*
-                 * Do now allow BIDI commands for passthrough mode.
-                 */
-                if (passthrough)
-                        goto out_unsupported_cdb;
-
-                /*
-                 * Setup BIDI XOR callback to be run after I/O completion.
-                 */
-                cmd->transport_complete_callback = &transport_xor_callback;
-                if (cdb[1] & 0x8)
-                        cmd->se_cmd_flags |= SCF_FUA;
-                break;
-        case VARIABLE_LENGTH_CMD:
-                service_action = get_unaligned_be16(&cdb[8]);
-                switch (service_action) {
-                case XDWRITEREAD_32:
-                        sectors = transport_get_sectors_32(cdb, cmd, &sector_ret);
-                        if (sector_ret)
-                                goto out_unsupported_cdb;
-                        size = transport_get_size(sectors, cdb, cmd);
-                        /*
-                         * Use WRITE_32 and READ_32 opcodes for the emulated
-                         * XDWRITE_READ_32 logic.
-                         */
-                        cmd->t_task_lba = transport_lba_64_ext(cdb);
-                        cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
-
-                        /*
-                         * Do now allow BIDI commands for passthrough mode.
-                         */
-                        if (passthrough)
-                                goto out_unsupported_cdb;
-
-                        /*
-                         * Setup BIDI XOR callback to be run during after I/O
-                         * completion.
-                         */
-                        cmd->transport_complete_callback = &transport_xor_callback;
-                        if (cdb[1] & 0x8)
-                                cmd->se_cmd_flags |= SCF_FUA;
-                        break;
-                case WRITE_SAME_32:
-                        sectors = transport_get_sectors_32(cdb, cmd, &sector_ret);
-                        if (sector_ret)
-                                goto out_unsupported_cdb;
-
-                        if (sectors)
-                                size = transport_get_size(1, cdb, cmd);
-                        else {
-                                pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
-                                       " supported\n");
-                                goto out_invalid_cdb_field;
-                        }
-
-                        cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
-                        cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-
-                        if (target_check_write_same_discard(&cdb[10], dev) < 0)
-                                goto out_unsupported_cdb;
-                        if (!passthrough)
-                                cmd->execute_cmd = target_emulate_write_same;
-                        break;
-                default:
-                        pr_err("VARIABLE_LENGTH_CMD service action"
-                                " 0x%04x not supported\n", service_action);
-                        goto out_unsupported_cdb;
-                }
-                break;
-        case MAINTENANCE_IN:
-                if (dev->transport->get_device_type(dev) != TYPE_ROM) {
-                        /* MAINTENANCE_IN from SCC-2 */
-                        /*
-                         * Check for emulated MI_REPORT_TARGET_PGS.
-                         */
-                        if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS &&
-                            su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
-                                cmd->execute_cmd =
-                                        target_emulate_report_target_port_groups;
-                        }
-                        size = (cdb[6] << 24) | (cdb[7] << 16) |
-                               (cdb[8] << 8) | cdb[9];
-                } else {
-                        /* GPCMD_SEND_KEY from multi media commands */
-                        size = (cdb[8] << 8) + cdb[9];
-                }
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case MODE_SELECT:
-                size = cdb[4];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case MODE_SELECT_10:
-                size = (cdb[7] << 8) + cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case MODE_SENSE:
-                size = cdb[4];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                if (!passthrough)
-                        cmd->execute_cmd = target_emulate_modesense;
-                break;
-        case MODE_SENSE_10:
-                size = (cdb[7] << 8) + cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                if (!passthrough)
-                        cmd->execute_cmd = target_emulate_modesense;
-                break;
-        case GPCMD_READ_BUFFER_CAPACITY:
-        case GPCMD_SEND_OPC:
-        case LOG_SELECT:
-        case LOG_SENSE:
-                size = (cdb[7] << 8) + cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case READ_BLOCK_LIMITS:
-                size = READ_BLOCK_LEN;
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case GPCMD_GET_CONFIGURATION:
-        case GPCMD_READ_FORMAT_CAPACITIES:
-        case GPCMD_READ_DISC_INFO:
-        case GPCMD_READ_TRACK_RZONE_INFO:
-                size = (cdb[7] << 8) + cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case PERSISTENT_RESERVE_IN:
-                if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS)
-                        cmd->execute_cmd = target_scsi3_emulate_pr_in;
-                size = (cdb[7] << 8) + cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case PERSISTENT_RESERVE_OUT:
-                if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS)
-                        cmd->execute_cmd = target_scsi3_emulate_pr_out;
-                size = (cdb[7] << 8) + cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case GPCMD_MECHANISM_STATUS:
-        case GPCMD_READ_DVD_STRUCTURE:
-                size = (cdb[8] << 8) + cdb[9];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case READ_POSITION:
-                size = READ_POSITION_LEN;
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case MAINTENANCE_OUT:
-                if (dev->transport->get_device_type(dev) != TYPE_ROM) {
-                        /* MAINTENANCE_OUT from SCC-2
-                         *
-                         * Check for emulated MO_SET_TARGET_PGS.
-                         */
-                        if (cdb[1] == MO_SET_TARGET_PGS &&
-                            su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
-                                cmd->execute_cmd =
-                                        target_emulate_set_target_port_groups;
-                        }
-
-                        size = (cdb[6] << 24) | (cdb[7] << 16) |
-                               (cdb[8] << 8) | cdb[9];
-                } else  {
-                        /* GPCMD_REPORT_KEY from multi media commands */
-                        size = (cdb[8] << 8) + cdb[9];
-                }
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case INQUIRY:
-                size = (cdb[3] << 8) + cdb[4];
-                /*
-                 * Do implict HEAD_OF_QUEUE processing for INQUIRY.
-                 * See spc4r17 section 5.3
-                 */
-                if (cmd->se_dev->dev_task_attr_type == SAM_TASK_ATTR_EMULATED)
-                        cmd->sam_task_attr = MSG_HEAD_TAG;
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                if (!passthrough)
-                        cmd->execute_cmd = target_emulate_inquiry;
-                break;
-        case READ_BUFFER:
-                size = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case READ_CAPACITY:
-                size = READ_CAP_LEN;
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                if (!passthrough)
-                        cmd->execute_cmd = target_emulate_readcapacity;
-                break;
-        case READ_MEDIA_SERIAL_NUMBER:
-        case SECURITY_PROTOCOL_IN:
-        case SECURITY_PROTOCOL_OUT:
-                size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case SERVICE_ACTION_IN:
-                switch (cmd->t_task_cdb[1] & 0x1f) {
-                case SAI_READ_CAPACITY_16:
-                        if (!passthrough)
-                                cmd->execute_cmd =
-                                        target_emulate_readcapacity_16;
-                        break;
-                default:
-                        if (passthrough)
-                                break;
-
-                        pr_err("Unsupported SA: 0x%02x\n",
-                                cmd->t_task_cdb[1] & 0x1f);
-                        goto out_invalid_cdb_field;
-                }
-                /*FALLTHROUGH*/
-        case ACCESS_CONTROL_IN:
-        case ACCESS_CONTROL_OUT:
-        case EXTENDED_COPY:
-        case READ_ATTRIBUTE:
-        case RECEIVE_COPY_RESULTS:
-        case WRITE_ATTRIBUTE:
-                size = (cdb[10] << 24) | (cdb[11] << 16) |
-                       (cdb[12] << 8) | cdb[13];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case RECEIVE_DIAGNOSTIC:
-        case SEND_DIAGNOSTIC:
-                size = (cdb[3] << 8) | cdb[4];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-/* #warning FIXME: Figure out correct GPCMD_READ_CD blocksize. */
-#if 0
-        case GPCMD_READ_CD:
-                sectors = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8];
-                size = (2336 * sectors);
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-#endif
-        case READ_TOC:
-                size = cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case REQUEST_SENSE:
-                size = cdb[4];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                if (!passthrough)
-                        cmd->execute_cmd = target_emulate_request_sense;
-                break;
-        case READ_ELEMENT_STATUS:
-                size = 65536 * cdb[7] + 256 * cdb[8] + cdb[9];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case WRITE_BUFFER:
-                size = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case RESERVE:
-        case RESERVE_10:
-                /*
-                 * The SPC-2 RESERVE does not contain a size in the SCSI CDB.
-                 * Assume the passthrough or $FABRIC_MOD will tell us about it.
-                 */
-                if (cdb[0] == RESERVE_10)
-                        size = (cdb[7] << 8) | cdb[8];
-                else
-                        size = cmd->data_length;
-
-                /*
-                 * Setup the legacy emulated handler for SPC-2 and
-                 * >= SPC-3 compatible reservation handling (CRH=1)
-                 * Otherwise, we assume the underlying SCSI logic is
-                 * is running in SPC_PASSTHROUGH, and wants reservations
-                 * emulation disabled.
-                 */
-                if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH)
-                        cmd->execute_cmd = target_scsi2_reservation_reserve;
-                cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB;
-                break;
-        case RELEASE:
-        case RELEASE_10:
-                /*
-                 * The SPC-2 RELEASE does not contain a size in the SCSI CDB.
-                 * Assume the passthrough or $FABRIC_MOD will tell us about it.
-                */
-                if (cdb[0] == RELEASE_10)
-                        size = (cdb[7] << 8) | cdb[8];
-                else
-                        size = cmd->data_length;
-
-                if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH)
-                        cmd->execute_cmd = target_scsi2_reservation_release;
-                cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB;
-                break;
-        case SYNCHRONIZE_CACHE:
-        case SYNCHRONIZE_CACHE_16:
-                /*
-                 * Extract LBA and range to be flushed for emulated SYNCHRONIZE_CACHE
-                 */
-                if (cdb[0] == SYNCHRONIZE_CACHE) {
-                        sectors = transport_get_sectors_10(cdb, cmd, &sector_ret);
-                        cmd->t_task_lba = transport_lba_32(cdb);
-                } else {
-                        sectors = transport_get_sectors_16(cdb, cmd, &sector_ret);
-                        cmd->t_task_lba = transport_lba_64(cdb);
-                }
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-
-                size = transport_get_size(sectors, cdb, cmd);
-                cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB;
-
-                if (passthrough)
+                spin_lock(&dev->delayed_cmd_lock);
+                if (list_empty(&dev->delayed_cmd_list)) {
+                        spin_unlock(&dev->delayed_cmd_lock);
                         break;
-
-                /*
-                 * Check to ensure that LBA + Range does not exceed past end of
-                 * device for IBLOCK and FILEIO ->do_sync_cache() backend calls
-                 */
-                if ((cmd->t_task_lba != 0) || (sectors != 0)) {
-                        if (transport_cmd_get_valid_sectors(cmd) < 0)
-                                goto out_invalid_cdb_field;
-                }
-                cmd->execute_cmd = target_emulate_synchronize_cache;
-                break;
-        case UNMAP:
-                size = get_unaligned_be16(&cdb[7]);
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                if (!passthrough)
-                        cmd->execute_cmd = target_emulate_unmap;
-                break;
-        case WRITE_SAME_16:
-                sectors = transport_get_sectors_16(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
-
-                if (sectors)
-                        size = transport_get_size(1, cdb, cmd);
-                else {
-                        pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
-                        goto out_invalid_cdb_field;
                 }
 
-                cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-
-                if (target_check_write_same_discard(&cdb[1], dev) < 0)
-                        goto out_unsupported_cdb;
-                if (!passthrough)
-                        cmd->execute_cmd = target_emulate_write_same;
-                break;
-        case WRITE_SAME:
-                sectors = transport_get_sectors_10(cdb, cmd, &sector_ret);
-                if (sector_ret)
-                        goto out_unsupported_cdb;
+                cmd = list_entry(dev->delayed_cmd_list.next,
+                                 struct se_cmd, se_delayed_node);
+                list_del(&cmd->se_delayed_node);
+                spin_unlock(&dev->delayed_cmd_lock);
 
-                if (sectors)
-                        size = transport_get_size(1, cdb, cmd);
-                else {
-                        pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
-                        goto out_invalid_cdb_field;
-                }
+                __target_execute_cmd(cmd);
 
-                cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                /*
-                 * Follow sbcr26 with WRITE_SAME (10) and check for the existence
-                 * of byte 1 bit 3 UNMAP instead of original reserved field
-                 */
-                if (target_check_write_same_discard(&cdb[1], dev) < 0)
-                        goto out_unsupported_cdb;
-                if (!passthrough)
-                        cmd->execute_cmd = target_emulate_write_same;
-                break;
-        case ALLOW_MEDIUM_REMOVAL:
-        case ERASE:
-        case REZERO_UNIT:
-        case SEEK_10:
-        case SPACE:
-        case START_STOP:
-        case TEST_UNIT_READY:
-        case VERIFY:
-        case WRITE_FILEMARKS:
-                cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB;
-                if (!passthrough)
-                        cmd->execute_cmd = target_emulate_noop;
-                break;
-        case GPCMD_CLOSE_TRACK:
-        case INITIALIZE_ELEMENT_STATUS:
-        case GPCMD_LOAD_UNLOAD:
-        case GPCMD_SET_SPEED:
-        case MOVE_MEDIUM:
-                cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB;
-                break;
-        case REPORT_LUNS:
-                cmd->execute_cmd = target_report_luns;
-                size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
-                /*
-                 * Do implict HEAD_OF_QUEUE processing for REPORT_LUNS
-                 * See spc4r17 section 5.3
-                 */
-                if (cmd->se_dev->dev_task_attr_type == SAM_TASK_ATTR_EMULATED)
-                        cmd->sam_task_attr = MSG_HEAD_TAG;
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case GET_EVENT_STATUS_NOTIFICATION:
-                size = (cdb[7] << 8) | cdb[8];
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        case ATA_16:
-                /* Only support ATA passthrough to pSCSI backends.. */
-                if (!passthrough)
-                        goto out_unsupported_cdb;
-
-                /* T_LENGTH */
-                switch (cdb[2] & 0x3) {
-                case 0x0:
-                        sectors = 0;
-                        break;
-                case 0x1:
-                        sectors = (((cdb[1] & 0x1) ? cdb[3] : 0) << 8) | cdb[4];
-                        break;
-                case 0x2:
-                        sectors = (((cdb[1] & 0x1) ? cdb[5] : 0) << 8) | cdb[6];
+                if (cmd->sam_task_attr == MSG_ORDERED_TAG)
                         break;
-                case 0x3:
-                        pr_err("T_LENGTH=0x3 not supported for ATA_16\n");
-                        goto out_invalid_cdb_field;
-                }
-
-                /* BYTE_BLOCK */
-                if (cdb[2] & 0x4) {
-                        /* BLOCK T_TYPE: 512 or sector */
-                        size = sectors * ((cdb[2] & 0x10) ?
-                                dev->se_sub_dev->se_dev_attrib.block_size : 512);
-                } else {
-                        /* BYTE */
-                        size = sectors;
-                }
-                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
-                break;
-        default:
-                pr_warn("TARGET_CORE[%s]: Unsupported SCSI Opcode"
-                        " 0x%02x, sending CHECK_CONDITION.\n",
-                        cmd->se_tfo->get_fabric_name(), cdb[0]);
-                goto out_unsupported_cdb;
-        }
-
-        if (cmd->unknown_data_length)
-                cmd->data_length = size;
-
-        if (size != cmd->data_length) {
-                pr_warn("TARGET_CORE[%s]: Expected Transfer Length:"
-                        " %u does not match SCSI CDB Length: %u for SAM Opcode:"
-                        " 0x%02x\n", cmd->se_tfo->get_fabric_name(),
-                                cmd->data_length, size, cdb[0]);
-
-                cmd->cmd_spdtl = size;
-
-                if (cmd->data_direction == DMA_TO_DEVICE) {
-                        pr_err("Rejecting underflow/overflow"
-                                        " WRITE data\n");
-                        goto out_invalid_cdb_field;
-                }
-                /*
-                 * Reject READ_* or WRITE_* with overflow/underflow for
-                 * type SCF_SCSI_DATA_SG_IO_CDB.
-                 */
-                if (!ret && (dev->se_sub_dev->se_dev_attrib.block_size != 512))  {
-                        pr_err("Failing OVERFLOW/UNDERFLOW for LBA op"
-                                " CDB on non 512-byte sector setup subsystem"
-                                " plugin: %s\n", dev->transport->name);
-                        /* Returns CHECK_CONDITION + INVALID_CDB_FIELD */
-                        goto out_invalid_cdb_field;
-                }
-
-                if (size > cmd->data_length) {
-                        cmd->se_cmd_flags |= SCF_OVERFLOW_BIT;
-                        cmd->residual_count = (size - cmd->data_length);
-                } else {
-                        cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT;
-                        cmd->residual_count = (cmd->data_length - size);
-                }
-                cmd->data_length = size;
         }
-
-        if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
-                if (sectors > su_dev->se_dev_attrib.fabric_max_sectors) {
-                        printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
-                                " big sectors %u exceeds fabric_max_sectors:"
-                                " %u\n", cdb[0], sectors,
-                                su_dev->se_dev_attrib.fabric_max_sectors);
-                        goto out_invalid_cdb_field;
-                }
-                if (sectors > su_dev->se_dev_attrib.hw_max_sectors) {
-                        printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
-                                " big sectors %u exceeds backend hw_max_sectors:"
-                                " %u\n", cdb[0], sectors,
-                                su_dev->se_dev_attrib.hw_max_sectors);
-                        goto out_invalid_cdb_field;
-                }
-        }
-
-        /* reject any command that we don't have a handler for */
-        if (!(passthrough || cmd->execute_cmd ||
-             (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB)))
-                goto out_unsupported_cdb;
-
-        transport_set_supported_SAM_opcode(cmd);
-        return ret;
-
-out_unsupported_cdb:
-        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
-        cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
-        return -EINVAL;
-out_invalid_cdb_field:
-        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
-        cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
-        return -EINVAL;
 }
 
 /*
@@ -3052,8 +1906,6 @@ out_invalid_cdb_field:
 static void transport_complete_task_attr(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
-        struct se_cmd *cmd_p, *cmd_tmp;
-        int new_active_tasks = 0;
 
         if (cmd->sam_task_attr == MSG_SIMPLE_TAG) {
                 atomic_dec(&dev->simple_cmds);
@@ -3075,38 +1927,8 @@ static void transport_complete_task_attr(struct se_cmd *cmd)
                 pr_debug("Incremented dev_cur_ordered_id: %u for ORDERED:"
                         " %u\n", dev->dev_cur_ordered_id, cmd->se_ordered_id);
         }
-        /*
-         * Process all commands up to the last received
-         * ORDERED task attribute which requires another blocking
-         * boundary
-         */
-        spin_lock(&dev->delayed_cmd_lock);
-        list_for_each_entry_safe(cmd_p, cmd_tmp,
-                        &dev->delayed_cmd_list, se_delayed_node) {
-
-                list_del(&cmd_p->se_delayed_node);
-                spin_unlock(&dev->delayed_cmd_lock);
-
-                pr_debug("Calling add_tasks() for"
-                        " cmd_p: 0x%02x Task Attr: 0x%02x"
-                        " Dormant -> Active, se_ordered_id: %u\n",
-                        cmd_p->t_task_cdb[0],
-                        cmd_p->sam_task_attr, cmd_p->se_ordered_id);
 
-                target_add_to_execute_list(cmd_p);
-                new_active_tasks++;
-
-                spin_lock(&dev->delayed_cmd_lock);
-                if (cmd_p->sam_task_attr == MSG_ORDERED_TAG)
-                        break;
-        }
-        spin_unlock(&dev->delayed_cmd_lock);
-        /*
-         * If new tasks have become active, wake up the transport thread
-         * to do the processing of the Active tasks.
-         */
-        if (new_active_tasks != 0)
-                wake_up_interruptible(&dev->dev_queue_obj.thread_wq);
+        target_restart_delayed_cmds(dev);
 }
 
 static void transport_complete_qf(struct se_cmd *cmd)
@@ -3365,31 +2187,27 @@ int transport_generic_map_mem_to_cmd(
         if (!sgl || !sgl_count)
                 return 0;
 
-        if ((cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) ||
-            (cmd->se_cmd_flags & SCF_SCSI_CONTROL_SG_IO_CDB)) {
-                /*
-                 * Reject SCSI data overflow with map_mem_to_cmd() as incoming
-                 * scatterlists already have been set to follow what the fabric
-                 * passes for the original expected data transfer length.
-                 */
-                if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
-                        pr_warn("Rejecting SCSI DATA overflow for fabric using"
-                                " SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC\n");
-                        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
-                        cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
-                        return -EINVAL;
-                }
+        /*
+         * Reject SCSI data overflow with map_mem_to_cmd() as incoming
+         * scatterlists already have been set to follow what the fabric
+         * passes for the original expected data transfer length.
+         */
+        if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
+                pr_warn("Rejecting SCSI DATA overflow for fabric using"
+                        " SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC\n");
+                cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+                cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
+                return -EINVAL;
+        }
 
-                cmd->t_data_sg = sgl;
-                cmd->t_data_nents = sgl_count;
+        cmd->t_data_sg = sgl;
+        cmd->t_data_nents = sgl_count;
 
-                if (sgl_bidi && sgl_bidi_count) {
-                        cmd->t_bidi_data_sg = sgl_bidi;
-                        cmd->t_bidi_data_nents = sgl_bidi_count;
-                }
-                cmd->se_cmd_flags |= SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC;
+        if (sgl_bidi && sgl_bidi_count) {
+                cmd->t_bidi_data_sg = sgl_bidi;
+                cmd->t_bidi_data_nents = sgl_bidi_count;
         }
-
+        cmd->se_cmd_flags |= SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC;
         return 0;
 }
 EXPORT_SYMBOL(transport_generic_map_mem_to_cmd);
@@ -3461,7 +2279,7 @@ transport_generic_get_mem(struct se_cmd *cmd)
         cmd->t_data_nents = nents;
         sg_init_table(cmd->t_data_sg, nents);
 
-        zero_flag = cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB ? 0 : __GFP_ZERO;
+        zero_flag = cmd->se_cmd_flags & SCF_SCSI_DATA_CDB ? 0 : __GFP_ZERO;
 
         while (length) {
                 u32 page_len = min_t(u32, length, PAGE_SIZE);
@@ -3492,7 +2310,6 @@ out:
  */
 int transport_generic_new_cmd(struct se_cmd *cmd)
 {
-        struct se_device *dev = cmd->se_dev;
         int ret = 0;
 
         /*
@@ -3508,8 +2325,7 @@ int transport_generic_new_cmd(struct se_cmd *cmd)
         }
 
         /* Workaround for handling zero-length control CDBs */
-        if ((cmd->se_cmd_flags & SCF_SCSI_CONTROL_SG_IO_CDB) &&
-            !cmd->data_length) {
+        if (!(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) && !cmd->data_length) {
                 spin_lock_irq(&cmd->t_state_lock);
                 cmd->t_state = TRANSPORT_COMPLETE;
                 cmd->transport_state |= CMD_T_ACTIVE;
@@ -3527,52 +2343,45 @@ int transport_generic_new_cmd(struct se_cmd *cmd)
                 return 0;
         }
 
-        if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
-                struct se_dev_attrib *attr = &dev->se_sub_dev->se_dev_attrib;
-
-                if (transport_cmd_get_valid_sectors(cmd) < 0)
-                        return -EINVAL;
-
-                BUG_ON(cmd->data_length % attr->block_size);
-                BUG_ON(DIV_ROUND_UP(cmd->data_length, attr->block_size) >
-                        attr->hw_max_sectors);
-        }
-
         atomic_inc(&cmd->t_fe_count);
 
         /*
-         * For WRITEs, let the fabric know its buffer is ready.
-         *
-         * The command will be added to the execution queue after its write
-         * data has arrived.
+         * If this command is not a write we can execute it right here,
+         * for write buffers we need to notify the fabric driver first
+         * and let it call back once the write buffers are ready.
          */
-        if (cmd->data_direction == DMA_TO_DEVICE) {
-                target_add_to_state_list(cmd);
-                return transport_generic_write_pending(cmd);
+        target_add_to_state_list(cmd);
+        if (cmd->data_direction != DMA_TO_DEVICE) {
+                target_execute_cmd(cmd);
+                return 0;
         }
-        /*
-         * Everything else but a WRITE, add the command to the execution queue.
-         */
-        transport_execute_tasks(cmd);
-        return 0;
+
+        spin_lock_irq(&cmd->t_state_lock);
+        cmd->t_state = TRANSPORT_WRITE_PENDING;
+        spin_unlock_irq(&cmd->t_state_lock);
+
+        transport_cmd_check_stop(cmd, false);
+
+        ret = cmd->se_tfo->write_pending(cmd);
+        if (ret == -EAGAIN || ret == -ENOMEM)
+                goto queue_full;
+
+        if (ret < 0)
+                return ret;
+        return 1;
 
 out_fail:
         cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
         cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
         return -EINVAL;
+queue_full:
+        pr_debug("Handling write_pending QUEUE__FULL: se_cmd: %p\n", cmd);
+        cmd->t_state = TRANSPORT_COMPLETE_QF_WP;
+        transport_handle_queue_full(cmd, cmd->se_dev);
+        return 0;
 }
 EXPORT_SYMBOL(transport_generic_new_cmd);
 
-/*      transport_generic_process_write():
- *
- *
- */
-void transport_generic_process_write(struct se_cmd *cmd)
-{
-        transport_execute_tasks(cmd);
-}
-EXPORT_SYMBOL(transport_generic_process_write);
-
 static void transport_write_pending_qf(struct se_cmd *cmd)
 {
         int ret;
@@ -3585,43 +2394,6 @@ static void transport_write_pending_qf(struct se_cmd *cmd)
         }
 }
 
-static int transport_generic_write_pending(struct se_cmd *cmd)
-{
-        unsigned long flags;
-        int ret;
-
-        spin_lock_irqsave(&cmd->t_state_lock, flags);
-        cmd->t_state = TRANSPORT_WRITE_PENDING;
-        spin_unlock_irqrestore(&cmd->t_state_lock, flags);
-
-        /*
-         * Clear the se_cmd for WRITE_PENDING status in order to set
-         * CMD_T_ACTIVE so that transport_generic_handle_data can be called
-         * from HW target mode interrupt code.  This is safe to be called
-         * with transport_off=1 before the cmd->se_tfo->write_pending
-         * because the se_cmd->se_lun pointer is not being cleared.
-         */
-        transport_cmd_check_stop(cmd, 1, 0);
-
-        /*
-         * Call the fabric write_pending function here to let the
-         * frontend know that WRITE buffers are ready.
-         */
-        ret = cmd->se_tfo->write_pending(cmd);
-        if (ret == -EAGAIN || ret == -ENOMEM)
-                goto queue_full;
-        else if (ret < 0)
-                return ret;
-
-        return 1;
-
-queue_full:
-        pr_debug("Handling write_pending QUEUE__FULL: se_cmd: %p\n", cmd);
-        cmd->t_state = TRANSPORT_COMPLETE_QF_WP;
-        transport_handle_queue_full(cmd, cmd->se_dev);
-        return 0;
-}
-
 void transport_generic_free_cmd(struct se_cmd *cmd, int wait_for_tasks)
 {
         if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD)) {
@@ -3648,10 +2420,11 @@ EXPORT_SYMBOL(transport_generic_free_cmd);
  * @se_cmd:     command descriptor to add
  * @ack_kref:   Signal that fabric will perform an ack target_put_sess_cmd()
  */
-void target_get_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd,
-                        bool ack_kref)
+static int target_get_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd,
+                               bool ack_kref)
 {
         unsigned long flags;
+        int ret = 0;
 
         kref_init(&se_cmd->cmd_kref);
         /*
@@ -3665,11 +2438,17 @@ void target_get_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd,
         }
 
         spin_lock_irqsave(&se_sess->sess_cmd_lock, flags);
+        if (se_sess->sess_tearing_down) {
+                ret = -ESHUTDOWN;
+                goto out;
+        }
         list_add_tail(&se_cmd->se_cmd_list, &se_sess->sess_cmd_list);
         se_cmd->check_release = 1;
+
+out:
         spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
+        return ret;
 }
-EXPORT_SYMBOL(target_get_sess_cmd);
 
 static void target_release_cmd_kref(struct kref *kref)
 {
@@ -3704,28 +2483,27 @@ int target_put_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd)
 }
 EXPORT_SYMBOL(target_put_sess_cmd);
 
-/* target_splice_sess_cmd_list - Split active cmds into sess_wait_list
- * @se_sess:    session to split
+/* target_sess_cmd_list_set_waiting - Flag all commands in
+ *         sess_cmd_list to complete cmd_wait_comp.  Set
+ *         sess_tearing_down so no more commands are queued.
+ * @se_sess:    session to flag
  */
-void target_splice_sess_cmd_list(struct se_session *se_sess)
+void target_sess_cmd_list_set_waiting(struct se_session *se_sess)
 {
         struct se_cmd *se_cmd;
         unsigned long flags;
 
-        WARN_ON(!list_empty(&se_sess->sess_wait_list));
-        INIT_LIST_HEAD(&se_sess->sess_wait_list);
-
         spin_lock_irqsave(&se_sess->sess_cmd_lock, flags);
-        se_sess->sess_tearing_down = 1;
 
-        list_splice_init(&se_sess->sess_cmd_list, &se_sess->sess_wait_list);
+        WARN_ON(se_sess->sess_tearing_down);
+        se_sess->sess_tearing_down = 1;
 
-        list_for_each_entry(se_cmd, &se_sess->sess_wait_list, se_cmd_list)
+        list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list)
                 se_cmd->cmd_wait_set = 1;
 
         spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
 }
-EXPORT_SYMBOL(target_splice_sess_cmd_list);
+EXPORT_SYMBOL(target_sess_cmd_list_set_waiting);
 
 /* target_wait_for_sess_cmds - Wait for outstanding descriptors
  * @se_sess:    session to wait for active I/O
@@ -3739,7 +2517,7 @@ void target_wait_for_sess_cmds(
         bool rc = false;
 
         list_for_each_entry_safe(se_cmd, tmp_cmd,
-                                &se_sess->sess_wait_list, se_cmd_list) {
+                                &se_sess->sess_cmd_list, se_cmd_list) {
                 list_del(&se_cmd->se_cmd_list);
 
                 pr_debug("Waiting for se_cmd: %p t_state: %d, fabric state:"
@@ -3791,26 +2569,20 @@ static int transport_lun_wait_for_tasks(struct se_cmd *cmd, struct se_lun *lun)
                 pr_debug("ConfigFS ITT[0x%08x] - CMD_T_STOP, skipping\n",
                          cmd->se_tfo->get_task_tag(cmd));
                 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
-                transport_cmd_check_stop(cmd, 1, 0);
+                transport_cmd_check_stop(cmd, false);
                 return -EPERM;
         }
         cmd->transport_state |= CMD_T_LUN_FE_STOP;
         spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
-        wake_up_interruptible(&cmd->se_dev->dev_queue_obj.thread_wq);
-
         // XXX: audit task_flags checks.
         spin_lock_irqsave(&cmd->t_state_lock, flags);
         if ((cmd->transport_state & CMD_T_BUSY) &&
             (cmd->transport_state & CMD_T_SENT)) {
                 if (!target_stop_cmd(cmd, &flags))
                         ret++;
-                spin_unlock_irqrestore(&cmd->t_state_lock, flags);
-        } else {
-                spin_unlock_irqrestore(&cmd->t_state_lock,
-                                flags);
-                target_remove_from_execute_list(cmd);
         }
+        spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
         pr_debug("ConfigFS: cmd: %p stop tasks ret:"
                         " %d\n", cmd, ret);
@@ -3821,7 +2593,6 @@ static int transport_lun_wait_for_tasks(struct se_cmd *cmd, struct se_lun *lun)
                 pr_debug("ConfigFS: ITT[0x%08x] - stopped cmd....\n",
                                 cmd->se_tfo->get_task_tag(cmd));
         }
-        transport_remove_cmd_from_queue(cmd);
 
         return 0;
 }
@@ -3840,11 +2611,6 @@ static void __transport_clear_lun_from_sessions(struct se_lun *lun)
                        struct se_cmd, se_lun_node);
                 list_del_init(&cmd->se_lun_node);
 
-                /*
-                 * This will notify iscsi_target_transport.c:
-                 * transport_cmd_check_stop() that a LUN shutdown is in
-                 * progress for the iscsi_cmd_t.
-                 */
                 spin_lock(&cmd->t_state_lock);
                 pr_debug("SE_LUN[%d] - Setting cmd->transport"
                         "_lun_stop for  ITT: 0x%08x\n",
@@ -3911,7 +2677,7 @@ check_cond:
 
                         spin_unlock_irqrestore(&cmd->t_state_lock,
                                         cmd_flags);
-                        transport_cmd_check_stop(cmd, 1, 0);
+                        transport_cmd_check_stop(cmd, false);
                         complete(&cmd->transport_lun_fe_stop_comp);
                         spin_lock_irqsave(&lun->lun_cmd_lock, lun_flags);
                         continue;
@@ -3967,10 +2733,7 @@ bool transport_wait_for_tasks(struct se_cmd *cmd)
                 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
                 return false;
         }
-        /*
-         * Only perform a possible wait_for_tasks if SCF_SUPPORTED_SAM_OPCODE
-         * has been set in transport_set_supported_SAM_opcode().
-         */
+
         if (!(cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE) &&
             !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) {
                 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
@@ -4028,8 +2791,6 @@ bool transport_wait_for_tasks(struct se_cmd *cmd)
 
         spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
-        wake_up_interruptible(&cmd->se_dev->dev_queue_obj.thread_wq);
-
         wait_for_completion(&cmd->t_transport_stop_comp);
 
         spin_lock_irqsave(&cmd->t_state_lock, flags);
@@ -4212,6 +2973,15 @@ int transport_send_check_condition_and_sense(
                 /* WRITE PROTECTED */
                 buffer[offset+SPC_ASC_KEY_OFFSET] = 0x27;
                 break;
+        case TCM_ADDRESS_OUT_OF_RANGE:
+                /* CURRENT ERROR */
+                buffer[offset] = 0x70;
+                buffer[offset+SPC_ADD_SENSE_LEN_OFFSET] = 10;
+                /* ILLEGAL REQUEST */
+                buffer[offset+SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST;
+                /* LOGICAL BLOCK ADDRESS OUT OF RANGE */
+                buffer[offset+SPC_ASC_KEY_OFFSET] = 0x21;
+                break;
         case TCM_CHECK_CONDITION_UNIT_ATTENTION:
                 /* CURRENT ERROR */
                 buffer[offset] = 0x70;
@@ -4312,8 +3082,9 @@ void transport_send_task_abort(struct se_cmd *cmd)
         cmd->se_tfo->queue_status(cmd);
 }
 
-static int transport_generic_do_tmr(struct se_cmd *cmd)
+static void target_tmr_work(struct work_struct *work)
 {
+        struct se_cmd *cmd = container_of(work, struct se_cmd, work);
         struct se_device *dev = cmd->se_dev;
         struct se_tmr_req *tmr = cmd->se_tmr_req;
         int ret;
@@ -4349,80 +3120,13 @@ static int transport_generic_do_tmr(struct se_cmd *cmd)
         cmd->se_tfo->queue_tm_rsp(cmd);
 
         transport_cmd_check_stop_to_fabric(cmd);
-        return 0;
 }
 
-/*      transport_processing_thread():
- *
- *
- */
-static int transport_processing_thread(void *param)
+int transport_generic_handle_tmr(
+        struct se_cmd *cmd)
 {
-        int ret;
-        struct se_cmd *cmd;
-        struct se_device *dev = param;
-
-        while (!kthread_should_stop()) {
-                ret = wait_event_interruptible(dev->dev_queue_obj.thread_wq,
-                                atomic_read(&dev->dev_queue_obj.queue_cnt) ||
-                                kthread_should_stop());
-                if (ret < 0)
-                        goto out;
-
-get_cmd:
-                cmd = transport_get_cmd_from_queue(&dev->dev_queue_obj);
-                if (!cmd)
-                        continue;
-
-                switch (cmd->t_state) {
-                case TRANSPORT_NEW_CMD:
-                        BUG();
-                        break;
-                case TRANSPORT_NEW_CMD_MAP:
-                        if (!cmd->se_tfo->new_cmd_map) {
-                                pr_err("cmd->se_tfo->new_cmd_map is"
-                                        " NULL for TRANSPORT_NEW_CMD_MAP\n");
-                                BUG();
-                        }
-                        ret = cmd->se_tfo->new_cmd_map(cmd);
-                        if (ret < 0) {
-                                transport_generic_request_failure(cmd);
-                                break;
-                        }
-                        ret = transport_generic_new_cmd(cmd);
-                        if (ret < 0) {
-                                transport_generic_request_failure(cmd);
-                                break;
-                        }
-                        break;
-                case TRANSPORT_PROCESS_WRITE:
-                        transport_generic_process_write(cmd);
-                        break;
-                case TRANSPORT_PROCESS_TMR:
-                        transport_generic_do_tmr(cmd);
-                        break;
-                case TRANSPORT_COMPLETE_QF_WP:
-                        transport_write_pending_qf(cmd);
-                        break;
-                case TRANSPORT_COMPLETE_QF_OK:
-                        transport_complete_qf(cmd);
-                        break;
-                default:
-                        pr_err("Unknown t_state: %d  for ITT: 0x%08x "
-                                "i_state: %d on SE LUN: %u\n",
-                                cmd->t_state,
-                                cmd->se_tfo->get_task_tag(cmd),
-                                cmd->se_tfo->get_cmd_state(cmd),
-                                cmd->se_lun->unpacked_lun);
-                        BUG();
-                }
-
-                goto get_cmd;
-        }
-
-out:
-        WARN_ON(!list_empty(&dev->state_list));
-        WARN_ON(!list_empty(&dev->dev_queue_obj.qobj_list));
-        dev->process_thread = NULL;
+        INIT_WORK(&cmd->work, target_tmr_work);
+        queue_work(cmd->se_dev->tmr_wq, &cmd->work);
         return 0;
 }
+EXPORT_SYMBOL(transport_generic_handle_tmr);
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index f03fb9730f5b..b9cb5006177e 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -215,7 +215,7 @@ int ft_write_pending(struct se_cmd *se_cmd)
                  */
                 if ((ep->xid <= lport->lro_xid) &&
                     (fh->fh_r_ctl == FC_RCTL_DD_DATA_DESC)) {
-                        if ((se_cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) &&
+                        if ((se_cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) &&
                             lport->tt.ddp_target(lport, ep->xid,
                                                  se_cmd->t_data_sg,
                                                  se_cmd->t_data_nents))
@@ -230,6 +230,8 @@ u32 ft_get_task_tag(struct se_cmd *se_cmd)
 {
         struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
 
+        if (cmd->aborted)
+                return ~0;
         return fc_seq_exch(cmd->seq)->rxid;
 }
 
@@ -541,9 +543,11 @@ static void ft_send_work(struct work_struct *work)
          * Use a single se_cmd->cmd_kref as we expect to release se_cmd
          * directly from ft_check_stop_free callback in response path.
          */
-        target_submit_cmd(&cmd->se_cmd, cmd->sess->se_sess, fcp->fc_cdb,
-                        &cmd->ft_sense_buffer[0], scsilun_to_int(&fcp->fc_lun),
-                        ntohl(fcp->fc_dl), task_attr, data_dir, 0);
+        if (target_submit_cmd(&cmd->se_cmd, cmd->sess->se_sess, fcp->fc_cdb,
+                              &cmd->ft_sense_buffer[0], scsilun_to_int(&fcp->fc_lun),
+                              ntohl(fcp->fc_dl), task_attr, data_dir, 0))
+                goto err;
+
         pr_debug("r_ctl %x alloc target_submit_cmd\n", fh->fh_r_ctl);
         return;
 
diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
index 071a505f98fc..ad36ede1a1ea 100644
--- a/drivers/target/tcm_fc/tfc_io.c
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -183,6 +183,13 @@ int ft_queue_data_in(struct se_cmd *se_cmd)
         return ft_queue_status(se_cmd);
 }
 
+static void ft_execute_work(struct work_struct *work)
+{
+        struct ft_cmd *cmd = container_of(work, struct ft_cmd, work);
+
+        target_execute_cmd(&cmd->se_cmd);
+}
+
 /*
  * Receive write data frame.
  */
@@ -307,8 +314,10 @@ void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
                 cmd->write_data_len += tlen;
         }
 last_frame:
-        if (cmd->write_data_len == se_cmd->data_length)
-                transport_generic_handle_data(se_cmd);
+        if (cmd->write_data_len == se_cmd->data_length) {
+                INIT_WORK(&cmd->work, ft_execute_work);
+                queue_work(cmd->sess->tport->tpg->workqueue, &cmd->work);
+        }
 drop:
         fc_frame_free(fp);
 }
diff --git a/drivers/target/tcm_fc/tfc_sess.c b/drivers/target/tcm_fc/tfc_sess.c
index cb99da920068..87901fa74dd7 100644
--- a/drivers/target/tcm_fc/tfc_sess.c
+++ b/drivers/target/tcm_fc/tfc_sess.c
@@ -58,7 +58,8 @@ static struct ft_tport *ft_tport_create(struct fc_lport *lport)
         struct ft_tport *tport;
         int i;
 
-        tport = rcu_dereference(lport->prov[FC_TYPE_FCP]);
+        tport = rcu_dereference_protected(lport->prov[FC_TYPE_FCP],
+                                          lockdep_is_held(&ft_lport_lock));
         if (tport && tport->tpg)
                 return tport;
 
diff --git a/drivers/tty/hvc/hvc_opal.c b/drivers/tty/hvc/hvc_opal.c
index ced26c8ccd57..0d2ea0c224c3 100644
--- a/drivers/tty/hvc/hvc_opal.c
+++ b/drivers/tty/hvc/hvc_opal.c
@@ -401,7 +401,7 @@ out:
 }
 
 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL_RAW
-void __init udbg_init_debug_opal(void)
+void __init udbg_init_debug_opal_raw(void)
 {
         u32 index = CONFIG_PPC_EARLY_DEBUG_OPAL_VTERMNO;
         hvc_opal_privs[index] = &hvc_opal_boot_priv;
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index 8fd398dffced..ee469274a3fe 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -500,6 +500,8 @@ retry:
                         goto retry;
                 }
                 if (!desc->reslength) { /* zero length read */
+                        dev_dbg(&desc->intf->dev, "%s: zero length - clearing WDM_READ\n", __func__);
+                        clear_bit(WDM_READ, &desc->flags);
                         spin_unlock_irq(&desc->iuspin);
                         goto retry;
                 }
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 25a7422ee657..8fb484984c86 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -2324,12 +2324,16 @@ static unsigned hub_is_wusb(struct usb_hub *hub)
 static int hub_port_reset(struct usb_hub *hub, int port1,
                         struct usb_device *udev, unsigned int delay, bool warm);
 
-/* Is a USB 3.0 port in the Inactive state? */
-static bool hub_port_inactive(struct usb_hub *hub, u16 portstatus)
+/* Is a USB 3.0 port in the Inactive or Complinance Mode state?
+ * Port worm reset is required to recover
+ */
+static bool hub_port_warm_reset_required(struct usb_hub *hub, u16 portstatus)
 {
         return hub_is_superspeed(hub->hdev) &&
-                (portstatus & USB_PORT_STAT_LINK_STATE) ==
-                USB_SS_PORT_LS_SS_INACTIVE;
+                (((portstatus & USB_PORT_STAT_LINK_STATE) ==
+                  USB_SS_PORT_LS_SS_INACTIVE) ||
+                 ((portstatus & USB_PORT_STAT_LINK_STATE) ==
+                  USB_SS_PORT_LS_COMP_MOD)) ;
 }
 
 static int hub_port_wait_reset(struct usb_hub *hub, int port1,
@@ -2365,7 +2369,7 @@ static int hub_port_wait_reset(struct usb_hub *hub, int port1,
                          *
                          * See https://bugzilla.kernel.org/show_bug.cgi?id=41752
                          */
-                        if (hub_port_inactive(hub, portstatus)) {
+                        if (hub_port_warm_reset_required(hub, portstatus)) {
                                 int ret;
 
                                 if ((portchange & USB_PORT_STAT_C_CONNECTION))
@@ -4408,9 +4412,7 @@ static void hub_events(void)
                         /* Warm reset a USB3 protocol port if it's in
                          * SS.Inactive state.
                          */
-                        if (hub_is_superspeed(hub->hdev) &&
-                                (portstatus & USB_PORT_STAT_LINK_STATE)
-                                        == USB_SS_PORT_LS_SS_INACTIVE) {
+                        if (hub_port_warm_reset_required(hub, portstatus)) {
                                 dev_dbg(hub_dev, "warm reset port %d\n", i);
                                 hub_port_reset(hub, i, NULL,
                                                 HUB_BH_RESET_TIME, true);
diff --git a/drivers/usb/gadget/tcm_usb_gadget.c b/drivers/usb/gadget/tcm_usb_gadget.c
index c46439c8dd74..5444866e13ef 100644
--- a/drivers/usb/gadget/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/tcm_usb_gadget.c
@@ -294,7 +294,7 @@ static int bot_send_write_request(struct usbg_cmd *cmd)
                 pr_err("%s(%d)\n", __func__, __LINE__);
 
         wait_for_completion(&cmd->write_complete);
-        transport_generic_process_write(se_cmd);
+        target_execute_cmd(se_cmd);
 cleanup:
         return ret;
 }
@@ -725,7 +725,7 @@ static int uasp_send_write_request(struct usbg_cmd *cmd)
         }
 
         wait_for_completion(&cmd->write_complete);
-        transport_generic_process_write(se_cmd);
+        target_execute_cmd(se_cmd);
 cleanup:
         return ret;
 }
@@ -1065,16 +1065,20 @@ static void usbg_cmd_work(struct work_struct *work)
                                 tv_nexus->tvn_se_sess->se_tpg->se_tpg_tfo,
                                 tv_nexus->tvn_se_sess, cmd->data_len, DMA_NONE,
                                 cmd->prio_attr, cmd->sense_iu.sense);
-
-                transport_send_check_condition_and_sense(se_cmd,
-                                TCM_UNSUPPORTED_SCSI_OPCODE, 1);
-                usbg_cleanup_cmd(cmd);
-                return;
+                goto out;
         }
 
-        target_submit_cmd(se_cmd, tv_nexus->tvn_se_sess,
+        if (target_submit_cmd(se_cmd, tv_nexus->tvn_se_sess,
                         cmd->cmd_buf, cmd->sense_iu.sense, cmd->unpacked_lun,
-                        0, cmd->prio_attr, dir, TARGET_SCF_UNKNOWN_SIZE);
+                        0, cmd->prio_attr, dir, TARGET_SCF_UNKNOWN_SIZE) < 0)
+                goto out;
+
+        return;
+
+out:
+        transport_send_check_condition_and_sense(se_cmd,
+                        TCM_UNSUPPORTED_SCSI_OPCODE, 1);
+        usbg_cleanup_cmd(cmd);
 }
 
 static int usbg_submit_command(struct f_uas *fu,
@@ -1177,16 +1181,20 @@ static void bot_cmd_work(struct work_struct *work)
                                 tv_nexus->tvn_se_sess->se_tpg->se_tpg_tfo,
                                 tv_nexus->tvn_se_sess, cmd->data_len, DMA_NONE,
                                 cmd->prio_attr, cmd->sense_iu.sense);
-
-                transport_send_check_condition_and_sense(se_cmd,
-                                TCM_UNSUPPORTED_SCSI_OPCODE, 1);
-                usbg_cleanup_cmd(cmd);
-                return;
+                goto out;
         }
 
-        target_submit_cmd(se_cmd, tv_nexus->tvn_se_sess,
+        if (target_submit_cmd(se_cmd, tv_nexus->tvn_se_sess,
                         cmd->cmd_buf, cmd->sense_iu.sense, cmd->unpacked_lun,
-                        cmd->data_len, cmd->prio_attr, dir, 0);
+                        cmd->data_len, cmd->prio_attr, dir, 0) < 0)
+                goto out;
+
+        return;
+
+out:
+        transport_send_check_condition_and_sense(se_cmd,
+                                TCM_UNSUPPORTED_SCSI_OPCODE, 1);
+        usbg_cleanup_cmd(cmd);
 }
 
 static int bot_submit_command(struct f_uas *fu,
@@ -1400,19 +1408,6 @@ static u32 usbg_tpg_get_inst_index(struct se_portal_group *se_tpg)
         return 1;
 }
 
-static int usbg_new_cmd(struct se_cmd *se_cmd)
-{
-        struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,
-                        se_cmd);
-        int ret;
-
-        ret = target_setup_cmd_from_cdb(se_cmd, cmd->cmd_buf);
-        if (ret)
-                return ret;
-
-        return transport_generic_map_mem_to_cmd(se_cmd, NULL, 0, NULL, 0);
-}
-
 static void usbg_cmd_release(struct kref *ref)
 {
         struct usbg_cmd *cmd = container_of(ref, struct usbg_cmd,
@@ -1902,7 +1897,6 @@ static struct target_core_fabric_ops usbg_ops = {
         .tpg_alloc_fabric_acl           = usbg_alloc_fabric_acl,
         .tpg_release_fabric_acl         = usbg_release_fabric_acl,
         .tpg_get_inst_index             = usbg_tpg_get_inst_index,
-        .new_cmd_map                    = usbg_new_cmd,
         .release_cmd                    = usbg_release_cmd,
         .shutdown_session               = usbg_shutdown_session,
         .close_session                  = usbg_close_session,
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 17cfb8a1131c..c30435499a02 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -281,14 +281,13 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
                 }
         }
 
+        /* Hold PHYs in reset while initializing EHCI controller */
         if (pdata->phy_reset) {
                 if (gpio_is_valid(pdata->reset_gpio_port[0]))
-                        gpio_request_one(pdata->reset_gpio_port[0],
-                                         GPIOF_OUT_INIT_LOW, "USB1 PHY reset");
+                        gpio_set_value_cansleep(pdata->reset_gpio_port[0], 0);
 
                 if (gpio_is_valid(pdata->reset_gpio_port[1]))
-                        gpio_request_one(pdata->reset_gpio_port[1],
-                                         GPIOF_OUT_INIT_LOW, "USB2 PHY reset");
+                        gpio_set_value_cansleep(pdata->reset_gpio_port[1], 0);
 
                 /* Hold the PHY in RESET for enough time till DIR is high */
                 udelay(10);
@@ -330,6 +329,11 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
         omap_ehci->hcs_params = readl(&omap_ehci->caps->hcs_params);
 
         ehci_reset(omap_ehci);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        if (ret) {
+                dev_err(dev, "failed to add hcd with err %d\n", ret);
+                goto err_add_hcd;
+        }
 
         if (pdata->phy_reset) {
                 /* Hold the PHY in RESET for enough time till
@@ -344,12 +348,6 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
                         gpio_set_value_cansleep(pdata->reset_gpio_port[1], 1);
         }
 
-        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
-        if (ret) {
-                dev_err(dev, "failed to add hcd with err %d\n", ret);
-                goto err_add_hcd;
-        }
-
         /* root ports should always stay powered */
         ehci_port_power(omap_ehci, 1);
 
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 2732ef660c5c..7b01094d7993 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -462,6 +462,42 @@ void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array,
         }
 }
 
+/* Updates Link Status for super Speed port */
+static void xhci_hub_report_link_state(u32 *status, u32 status_reg)
+{
+        u32 pls = status_reg & PORT_PLS_MASK;
+
+        /* resume state is a xHCI internal state.
+         * Do not report it to usb core.
+         */
+        if (pls == XDEV_RESUME)
+                return;
+
+        /* When the CAS bit is set then warm reset
+         * should be performed on port
+         */
+        if (status_reg & PORT_CAS) {
+                /* The CAS bit can be set while the port is
+                 * in any link state.
+                 * Only roothubs have CAS bit, so we
+                 * pretend to be in compliance mode
+                 * unless we're already in compliance
+                 * or the inactive state.
+                 */
+                if (pls != USB_SS_PORT_LS_COMP_MOD &&
+                    pls != USB_SS_PORT_LS_SS_INACTIVE) {
+                        pls = USB_SS_PORT_LS_COMP_MOD;
+                }
+                /* Return also connection bit -
+                 * hub state machine resets port
+                 * when this bit is set.
+                 */
+                pls |= USB_PORT_STAT_CONNECTION;
+        }
+        /* update status field */
+        *status |= pls;
+}
+
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 u16 wIndex, char *buf, u16 wLength)
 {
@@ -606,13 +642,9 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         else
                                 status |= USB_PORT_STAT_POWER;
                 }
-                /* Port Link State */
+                /* Update Port Link State for super speed ports*/
                 if (hcd->speed == HCD_USB3) {
-                        /* resume state is a xHCI internal state.
-                         * Do not report it to usb core.
-                         */
-                        if ((temp & PORT_PLS_MASK) != XDEV_RESUME)
-                                status |= (temp & PORT_PLS_MASK);
+                        xhci_hub_report_link_state(&status, temp);
                 }
                 if (bus_state->port_c_suspend & (1 << wIndex))
                         status |= 1 << USB_PORT_FEAT_C_SUSPEND;
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 23b4aefd1036..8275645889da 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -885,6 +885,17 @@ static void update_ring_for_set_deq_completion(struct xhci_hcd *xhci,
         num_trbs_free_temp = ep_ring->num_trbs_free;
         dequeue_temp = ep_ring->dequeue;
 
+        /* If we get two back-to-back stalls, and the first stalled transfer
+         * ends just before a link TRB, the dequeue pointer will be left on
+         * the link TRB by the code in the while loop.  So we have to update
+         * the dequeue pointer one segment further, or we'll jump off
+         * the segment into la-la-land.
+         */
+        if (last_trb(xhci, ep_ring, ep_ring->deq_seg, ep_ring->dequeue)) {
+                ep_ring->deq_seg = ep_ring->deq_seg->next;
+                ep_ring->dequeue = ep_ring->deq_seg->trbs;
+        }
+
         while (ep_ring->dequeue != dev->eps[ep_index].queued_deq_ptr) {
                 /* We have more usable TRBs */
                 ep_ring->num_trbs_free++;
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index de3d6e3e57be..55c0785810c9 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -341,7 +341,11 @@ struct xhci_op_regs {
 #define PORT_PLC        (1 << 22)
 /* port configure error change - port failed to configure its link partner */
 #define PORT_CEC        (1 << 23)
-/* bit 24 reserved */
+/* Cold Attach Status - xHC can set this bit to report device attached during
+ * Sx state. Warm port reset should be perfomed to clear this bit and move port
+ * to connected state.
+ */
+#define PORT_CAS        (1 << 24)
 /* wake on connect (enable) */
 #define PORT_WKCONN_E   (1 << 25)
 /* wake on disconnect (enable) */
diff --git a/drivers/usb/serial/metro-usb.c b/drivers/usb/serial/metro-usb.c
index 81423f7361db..d47eb06fe463 100644
--- a/drivers/usb/serial/metro-usb.c
+++ b/drivers/usb/serial/metro-usb.c
@@ -222,14 +222,6 @@ static int metrousb_open(struct tty_struct *tty, struct usb_serial_port *port)
         metro_priv->throttled = 0;
         spin_unlock_irqrestore(&metro_priv->lock, flags);
 
-        /*
-         * Force low_latency on so that our tty_push actually forces the data
-         * through, otherwise it is scheduled, and with high data rates (like
-         * with OHCI) data can get lost.
-         */
-        if (tty)
-                tty->low_latency = 1;
-
         /* Clear the urb pipe. */
         usb_clear_halt(serial->dev, port->interrupt_in_urb->pipe);
 
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index adf8ce72be50..417ab1b0aa30 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -497,6 +497,15 @@ static void option_instat_callback(struct urb *urb);
 
 /* MediaTek products */
 #define MEDIATEK_VENDOR_ID                      0x0e8d
+#define MEDIATEK_PRODUCT_DC_1COM                0x00a0
+#define MEDIATEK_PRODUCT_DC_4COM                0x00a5
+#define MEDIATEK_PRODUCT_DC_5COM                0x00a4
+#define MEDIATEK_PRODUCT_7208_1COM              0x7101
+#define MEDIATEK_PRODUCT_7208_2COM              0x7102
+#define MEDIATEK_PRODUCT_FP_1COM                0x0003
+#define MEDIATEK_PRODUCT_FP_2COM                0x0023
+#define MEDIATEK_PRODUCT_FPDC_1COM              0x0043
+#define MEDIATEK_PRODUCT_FPDC_2COM              0x0033
 
 /* Cellient products */
 #define CELLIENT_VENDOR_ID                      0x2692
@@ -554,6 +563,10 @@ static const struct option_blacklist_info net_intf1_blacklist = {
         .reserved = BIT(1),
 };
 
+static const struct option_blacklist_info net_intf2_blacklist = {
+        .reserved = BIT(2),
+};
+
 static const struct option_blacklist_info net_intf3_blacklist = {
         .reserved = BIT(3),
 };
@@ -1099,6 +1112,8 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1298, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1299, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1300, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1402, 0xff, 0xff, 0xff),
+                .driver_info = (kernel_ulong_t)&net_intf2_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff,
           0xff, 0xff), .driver_info = (kernel_ulong_t)&zte_k3765_z_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
@@ -1240,6 +1255,17 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a1, 0xff, 0x02, 0x01) },
         { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a2, 0xff, 0x00, 0x00) },
         { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a2, 0xff, 0x02, 0x01) },        /* MediaTek MT6276M modem & app port */
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_1COM, 0x0a, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_5COM, 0xff, 0x02, 0x01) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_5COM, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_4COM, 0xff, 0x02, 0x01) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_4COM, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_7208_1COM, 0x02, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_7208_2COM, 0x02, 0x02, 0x01) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FP_1COM, 0x0a, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FP_2COM, 0x0a, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FPDC_1COM, 0x0a, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FPDC_2COM, 0x0a, 0x00, 0x00) },
         { USB_DEVICE(CELLIENT_VENDOR_ID, CELLIENT_PRODUCT_MEN200) },
         { } /* Terminating entry */
 };
diff --git a/drivers/video/omap2/dss/core.c b/drivers/video/omap2/dss/core.c
index 5066eee10ccf..58bd9c27369d 100644
--- a/drivers/video/omap2/dss/core.c
+++ b/drivers/video/omap2/dss/core.c
@@ -32,6 +32,7 @@
 #include <linux/io.h>
 #include <linux/device.h>
 #include <linux/regulator/consumer.h>
+#include <linux/suspend.h>
 
 #include <video/omapdss.h>
 
@@ -201,6 +202,28 @@ int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *))
 #endif /* CONFIG_DEBUG_FS && CONFIG_OMAP2_DSS_DEBUG_SUPPORT */
 
 /* PLATFORM DEVICE */
+static int omap_dss_pm_notif(struct notifier_block *b, unsigned long v, void *d)
+{
+        DSSDBG("pm notif %lu\n", v);
+
+        switch (v) {
+        case PM_SUSPEND_PREPARE:
+                DSSDBG("suspending displays\n");
+                return dss_suspend_all_devices();
+
+        case PM_POST_SUSPEND:
+                DSSDBG("resuming displays\n");
+                return dss_resume_all_devices();
+
+        default:
+                return 0;
+        }
+}
+
+static struct notifier_block omap_dss_pm_notif_block = {
+        .notifier_call = omap_dss_pm_notif,
+};
+
 static int __init omap_dss_probe(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
@@ -224,6 +247,8 @@ static int __init omap_dss_probe(struct platform_device *pdev)
         else if (pdata->default_device)
                 core.default_display_name = pdata->default_device->name;
 
+        register_pm_notifier(&omap_dss_pm_notif_block);
+
         return 0;
 
 err_debugfs:
@@ -233,6 +258,8 @@ err_debugfs:
 
 static int omap_dss_remove(struct platform_device *pdev)
 {
+        unregister_pm_notifier(&omap_dss_pm_notif_block);
+
         dss_uninitialize_debugfs();
 
         dss_uninit_overlays(pdev);
@@ -247,25 +274,9 @@ static void omap_dss_shutdown(struct platform_device *pdev)
         dss_disable_all_devices();
 }
 
-static int omap_dss_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        DSSDBG("suspend %d\n", state.event);
-
-        return dss_suspend_all_devices();
-}
-
-static int omap_dss_resume(struct platform_device *pdev)
-{
-        DSSDBG("resume\n");
-
-        return dss_resume_all_devices();
-}
-
 static struct platform_driver omap_dss_driver = {
         .remove         = omap_dss_remove,
         .shutdown       = omap_dss_shutdown,
-        .suspend        = omap_dss_suspend,
-        .resume         = omap_dss_resume,
         .driver         = {
                 .name   = "omapdss",
                 .owner  = THIS_MODULE,
diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c
index 4749ac356469..397d4eee11bb 100644
--- a/drivers/video/omap2/dss/dispc.c
+++ b/drivers/video/omap2/dss/dispc.c
@@ -384,7 +384,7 @@ void dispc_runtime_put(void)
         DSSDBG("dispc_runtime_put\n");
 
         r = pm_runtime_put_sync(&dispc.pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 static inline bool dispc_mgr_is_lcd(enum omap_channel channel)
diff --git a/drivers/video/omap2/dss/dsi.c b/drivers/video/omap2/dss/dsi.c
index ca8382d346e9..14ce8cc079e3 100644
--- a/drivers/video/omap2/dss/dsi.c
+++ b/drivers/video/omap2/dss/dsi.c
@@ -1075,7 +1075,7 @@ void dsi_runtime_put(struct platform_device *dsidev)
         DSSDBG("dsi_runtime_put\n");
 
         r = pm_runtime_put_sync(&dsi->pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 /* source clock for DSI PLL. this could also be PCLKFREE */
diff --git a/drivers/video/omap2/dss/dss.c b/drivers/video/omap2/dss/dss.c
index 770632359a17..d2b57197b292 100644
--- a/drivers/video/omap2/dss/dss.c
+++ b/drivers/video/omap2/dss/dss.c
@@ -731,7 +731,7 @@ static void dss_runtime_put(void)
         DSSDBG("dss_runtime_put\n");
 
         r = pm_runtime_put_sync(&dss.pdev->dev);
-        WARN_ON(r < 0 && r != -EBUSY);
+        WARN_ON(r < 0 && r != -ENOSYS && r != -EBUSY);
 }
 
 /* DEBUGFS */
diff --git a/drivers/video/omap2/dss/hdmi.c b/drivers/video/omap2/dss/hdmi.c
index 8195c7166d20..26a2430a7028 100644
--- a/drivers/video/omap2/dss/hdmi.c
+++ b/drivers/video/omap2/dss/hdmi.c
@@ -138,7 +138,7 @@ static void hdmi_runtime_put(void)
         DSSDBG("hdmi_runtime_put\n");
 
         r = pm_runtime_put_sync(&hdmi.pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 static int __init hdmi_init_display(struct omap_dss_device *dssdev)
diff --git a/drivers/video/omap2/dss/rfbi.c b/drivers/video/omap2/dss/rfbi.c
index 3d8c206e90e5..7985fa12b9b4 100644
--- a/drivers/video/omap2/dss/rfbi.c
+++ b/drivers/video/omap2/dss/rfbi.c
@@ -141,7 +141,7 @@ static void rfbi_runtime_put(void)
         DSSDBG("rfbi_runtime_put\n");
 
         r = pm_runtime_put_sync(&rfbi.pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 void rfbi_bus_lock(void)
diff --git a/drivers/video/omap2/dss/venc.c b/drivers/video/omap2/dss/venc.c
index 2b8973931ff4..3907c8b6ecbc 100644
--- a/drivers/video/omap2/dss/venc.c
+++ b/drivers/video/omap2/dss/venc.c
@@ -402,7 +402,7 @@ static void venc_runtime_put(void)
         DSSDBG("venc_runtime_put\n");
 
         r = pm_runtime_put_sync(&venc.pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 static const struct venc_config *venc_timings_to_config(
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index bfbc15ca38dd..0908e6044333 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -47,7 +47,7 @@ struct virtio_balloon
         struct task_struct *thread;
 
         /* Waiting for host to ack the pages we released. */
-        struct completion acked;
+        wait_queue_head_t acked;
 
         /* Number of balloon pages we've told the Host we're not using. */
         unsigned int num_pages;
@@ -89,29 +89,25 @@ static struct page *balloon_pfn_to_page(u32 pfn)
 
 static void balloon_ack(struct virtqueue *vq)
 {
-        struct virtio_balloon *vb;
-        unsigned int len;
+        struct virtio_balloon *vb = vq->vdev->priv;
 
-        vb = virtqueue_get_buf(vq, &len);
-        if (vb)
-                complete(&vb->acked);
+        wake_up(&vb->acked);
 }
 
 static void tell_host(struct virtio_balloon *vb, struct virtqueue *vq)
 {
         struct scatterlist sg;
+        unsigned int len;
 
         sg_init_one(&sg, vb->pfns, sizeof(vb->pfns[0]) * vb->num_pfns);
 
-        init_completion(&vb->acked);
-
         /* We should always be able to add one buffer to an empty queue. */
         if (virtqueue_add_buf(vq, &sg, 1, 0, vb, GFP_KERNEL) < 0)
                 BUG();
         virtqueue_kick(vq);
 
         /* When host has read buffer, this completes via balloon_ack */
-        wait_for_completion(&vb->acked);
+        wait_event(vb->acked, virtqueue_get_buf(vq, &len));
 }
 
 static void set_page_pfns(u32 pfns[], struct page *page)
@@ -231,12 +227,8 @@ static void update_balloon_stats(struct virtio_balloon *vb)
  */
 static void stats_request(struct virtqueue *vq)
 {
-        struct virtio_balloon *vb;
-        unsigned int len;
+        struct virtio_balloon *vb = vq->vdev->priv;
 
-        vb = virtqueue_get_buf(vq, &len);
-        if (!vb)
-                return;
         vb->need_stats_update = 1;
         wake_up(&vb->config_change);
 }
@@ -245,11 +237,14 @@ static void stats_handle_request(struct virtio_balloon *vb)
 {
         struct virtqueue *vq;
         struct scatterlist sg;
+        unsigned int len;
 
         vb->need_stats_update = 0;
         update_balloon_stats(vb);
 
         vq = vb->stats_vq;
+        if (!virtqueue_get_buf(vq, &len))
+                return;
         sg_init_one(&sg, vb->stats, sizeof(vb->stats));
         if (virtqueue_add_buf(vq, &sg, 1, 0, vb, GFP_KERNEL) < 0)
                 BUG();
@@ -358,6 +353,7 @@ static int virtballoon_probe(struct virtio_device *vdev)
         INIT_LIST_HEAD(&vb->pages);
         vb->num_pages = 0;
         init_waitqueue_head(&vb->config_change);
+        init_waitqueue_head(&vb->acked);
         vb->vdev = vdev;
         vb->need_stats_update = 0;