Merge remote-tracking branch 'regulator/topic/drivers' into regulator-next

Conflicts:
	drivers/regulator/88pm8607.c (simple overlap with a bugfix in v3.4)

28 files changed, 428 insertions, 301 deletions

diff --git a/drivers/mfd/tps6586x.c b/drivers/mfd/tps6586x.c
index a5ddf31b60c..c84b5506d5f 100644
--- a/drivers/mfd/tps6586x.c
+++ b/drivers/mfd/tps6586x.c
@@ -23,6 +23,7 @@
 #include <linux/slab.h>
 #include <linux/gpio.h>
 #include <linux/i2c.h>
+#include <linux/regulator/of_regulator.h>
 
 #include <linux/mfd/core.h>
 #include <linux/mfd/tps6586x.h>
@@ -460,6 +461,7 @@ static int __devinit tps6586x_add_subdevs(struct tps6586x *tps6586x,
 
                 pdev->dev.parent = tps6586x->dev;
                 pdev->dev.platform_data = subdev->platform_data;
+                pdev->dev.of_node = subdev->of_node;
 
                 ret = platform_device_add(pdev);
                 if (ret) {
@@ -474,6 +476,86 @@ failed:
         return ret;
 }
 
+#ifdef CONFIG_OF
+static struct of_regulator_match tps6586x_matches[] = {
+        { .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
+        { .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
+        { .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
+        { .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
+        { .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
+        { .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
+        { .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
+        { .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
+        { .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
+        { .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
+        { .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
+        { .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
+        { .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
+        { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
+};
+
+static struct tps6586x_platform_data *tps6586x_parse_dt(struct i2c_client *client)
+{
+        const unsigned int num = ARRAY_SIZE(tps6586x_matches);
+        struct device_node *np = client->dev.of_node;
+        struct tps6586x_platform_data *pdata;
+        struct tps6586x_subdev_info *devs;
+        struct device_node *regs;
+        unsigned int count;
+        unsigned int i, j;
+        int err;
+
+        regs = of_find_node_by_name(np, "regulators");
+        if (!regs)
+                return NULL;
+
+        err = of_regulator_match(&client->dev, regs, tps6586x_matches, num);
+        if (err < 0) {
+                of_node_put(regs);
+                return NULL;
+        }
+
+        of_node_put(regs);
+        count = err;
+
+        devs = devm_kzalloc(&client->dev, count * sizeof(*devs), GFP_KERNEL);
+        if (!devs)
+                return NULL;
+
+        for (i = 0, j = 0; i < num && j < count; i++) {
+                if (!tps6586x_matches[i].init_data)
+                        continue;
+
+                devs[j].name = "tps6586x-regulator";
+                devs[j].platform_data = tps6586x_matches[i].init_data;
+                devs[j].id = (int)tps6586x_matches[i].driver_data;
+                devs[j].of_node = tps6586x_matches[i].of_node;
+                j++;
+        }
+
+        pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL;
+
+        pdata->num_subdevs = count;
+        pdata->subdevs = devs;
+        pdata->gpio_base = -1;
+        pdata->irq_base = -1;
+
+        return pdata;
+}
+
+static struct of_device_id tps6586x_of_match[] = {
+        { .compatible = "ti,tps6586x", },
+        { },
+};
+#else
+static struct tps6586x_platform_data *tps6586x_parse_dt(struct i2c_client *client)
+{
+        return NULL;
+}
+#endif
+
 static int __devinit tps6586x_i2c_probe(struct i2c_client *client,
                                         const struct i2c_device_id *id)
 {
@@ -481,6 +563,9 @@ static int __devinit tps6586x_i2c_probe(struct i2c_client *client,
         struct tps6586x *tps6586x;
         int ret;
 
+        if (!pdata && client->dev.of_node)
+                pdata = tps6586x_parse_dt(client);
+
         if (!pdata) {
                 dev_err(&client->dev, "tps6586x requires platform data\n");
                 return -ENOTSUPP;
@@ -573,6 +658,7 @@ static struct i2c_driver tps6586x_driver = {
         .driver = {
                 .name   = "tps6586x",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(tps6586x_of_match),
         },
         .probe          = tps6586x_i2c_probe,
         .remove         = __devexit_p(tps6586x_i2c_remove),
diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c
index 7c2267e71f8..6fc90befa79 100644
--- a/drivers/mfd/twl-core.c
+++ b/drivers/mfd/twl-core.c
@@ -224,13 +224,6 @@
 #define HIGH_PERF_SQ                    (1 << 3)
 #define CK32K_LOWPWR_EN                 (1 << 7)
 
-
-/* chip-specific feature flags, for i2c_device_id.driver_data */
-#define TWL4030_VAUX2           BIT(0)  /* pre-5030 voltage ranges */
-#define TPS_SUBSET              BIT(1)  /* tps659[23]0 have fewer LDOs */
-#define TWL5031                 BIT(2)  /* twl5031 has different registers */
-#define TWL6030_CLASS           BIT(3)  /* TWL6030 class */
-
 /*----------------------------------------------------------------------*/
 
 /* is driver active, bound to a chip? */
diff --git a/drivers/regulator/aat2870-regulator.c b/drivers/regulator/aat2870-regulator.c
index 7f000d6bb98..06776ca945f 100644
--- a/drivers/regulator/aat2870-regulator.c
+++ b/drivers/regulator/aat2870-regulator.c
@@ -24,7 +24,6 @@
 #include <linux/err.h>
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
index ce6192592ca..e2062ad74e5 100644
--- a/drivers/regulator/ab3100.c
+++ b/drivers/regulator/ab3100.c
@@ -13,7 +13,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/err.h>
-#include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/mfd/abx500.h>
diff --git a/drivers/regulator/da9052-regulator.c b/drivers/regulator/da9052-regulator.c
index 2943ef6bdf4..d2de7fc9808 100644
--- a/drivers/regulator/da9052-regulator.c
+++ b/drivers/regulator/da9052-regulator.c
@@ -20,6 +20,7 @@
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
 #ifdef CONFIG_OF
+#include <linux/of.h>
 #include <linux/regulator/of_regulator.h>
 #endif
 
@@ -393,7 +394,7 @@ static int __devinit da9052_regulator_probe(struct platform_device *pdev)
                 if (!nproot)
                         return -ENODEV;
 
-                for (np = of_get_next_child(nproot, NULL); !np;
+                for (np = of_get_next_child(nproot, NULL); np;
                      np = of_get_next_child(nproot, np)) {
                         if (!of_node_cmp(np->name,
                                          regulator->info->reg_desc.name)) {
diff --git a/drivers/regulator/fixed.c b/drivers/regulator/fixed.c
index b47b005a8d2..f09fe7b20e8 100644
--- a/drivers/regulator/fixed.c
+++ b/drivers/regulator/fixed.c
@@ -25,7 +25,6 @@
 #include <linux/regulator/driver.h>
 #include <linux/regulator/fixed.h>
 #include <linux/gpio.h>
-#include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
@@ -91,6 +90,9 @@ of_get_fixed_voltage_config(struct device *dev)
         if (of_find_property(np, "enable-active-high", NULL))
                 config->enable_high = true;
 
+        if (of_find_property(np, "gpio-open-drain", NULL))
+                config->gpio_is_open_drain = true;
+
         return config;
 }
 
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c
index f93b06b1e7e..9997d7aaca8 100644
--- a/drivers/regulator/gpio-regulator.c
+++ b/drivers/regulator/gpio-regulator.c
@@ -30,7 +30,6 @@
 #include <linux/regulator/machine.h>
 #include <linux/regulator/gpio-regulator.h>
 #include <linux/gpio.h>
-#include <linux/delay.h>
 #include <linux/slab.h>
 
 struct gpio_regulator_data {
diff --git a/drivers/regulator/isl6271a-regulator.c b/drivers/regulator/isl6271a-regulator.c
index 60044c362eb..5caaf1f7754 100644
--- a/drivers/regulator/isl6271a-regulator.c
+++ b/drivers/regulator/isl6271a-regulator.c
@@ -22,7 +22,6 @@
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/i2c.h>
-#include <linux/delay.h>
 #include <linux/slab.h>
 
 #define ISL6271A_VOLTAGE_MIN    850000
diff --git a/drivers/regulator/max8660.c b/drivers/regulator/max8660.c
index 9997cfbc347..5d568175cc2 100644
--- a/drivers/regulator/max8660.c
+++ b/drivers/regulator/max8660.c
@@ -370,7 +370,7 @@ static int __devinit max8660_probe(struct i2c_client *client,
                 return -EINVAL;
         }
 
-        max8660 = kzalloc(sizeof(struct max8660) +
+        max8660 = devm_kzalloc(&client->dev, sizeof(struct max8660) +
                         sizeof(struct regulator_dev *) * MAX8660_V_END,
                         GFP_KERNEL);
         if (!max8660)
diff --git a/drivers/regulator/max8952.c b/drivers/regulator/max8952.c
index c0ab4ddc102..62ae140d8d9 100644
--- a/drivers/regulator/max8952.c
+++ b/drivers/regulator/max8952.c
@@ -69,11 +69,6 @@ static int max8952_write_reg(struct max8952_data *max8952,
         return i2c_smbus_write_byte_data(max8952->client, reg, value);
 }
 
-static int max8952_voltage(struct max8952_data *max8952, u8 mode)
-{
-        return (max8952->pdata->dvs_mode[mode] * 10 + 770) * 1000;
-}
-
 static int max8952_list_voltage(struct regulator_dev *rdev,
                 unsigned int selector)
 {
@@ -82,7 +77,7 @@ static int max8952_list_voltage(struct regulator_dev *rdev,
         if (rdev_get_id(rdev) != 0)
                 return -EINVAL;
 
-        return max8952_voltage(max8952, selector);
+        return (max8952->pdata->dvs_mode[selector] * 10 + 770) * 1000;
 }
 
 static int max8952_is_enabled(struct regulator_dev *rdev)
@@ -117,7 +112,7 @@ static int max8952_disable(struct regulator_dev *rdev)
         return 0;
 }
 
-static int max8952_get_voltage(struct regulator_dev *rdev)
+static int max8952_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct max8952_data *max8952 = rdev_get_drvdata(rdev);
         u8 vid = 0;
@@ -127,7 +122,7 @@ static int max8952_get_voltage(struct regulator_dev *rdev)
         if (max8952->vid1)
                 vid += 2;
 
-        return max8952_voltage(max8952, vid);
+        return vid;
 }
 
 static int max8952_set_voltage_sel(struct regulator_dev *rdev,
@@ -154,7 +149,7 @@ static struct regulator_ops max8952_ops = {
         .is_enabled             = max8952_is_enabled,
         .enable                 = max8952_enable,
         .disable                = max8952_disable,
-        .get_voltage            = max8952_get_voltage,
+        .get_voltage_sel        = max8952_get_voltage_sel,
         .set_voltage_sel        = max8952_set_voltage_sel,
         .set_suspend_disable    = max8952_disable,
 };
diff --git a/drivers/regulator/max8997.c b/drivers/regulator/max8997.c
index db09244bb3e..b88551be452 100644
--- a/drivers/regulator/max8997.c
+++ b/drivers/regulator/max8997.c
@@ -22,7 +22,6 @@
  */
 
 #include <linux/bug.h>
-#include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/gpio.h>
 #include <linux/slab.h>
@@ -278,9 +277,7 @@ static int max8997_reg_is_enabled(struct regulator_dev *rdev)
         u8 val;
 
         ret = max8997_get_enable_register(rdev, &reg, &mask, &pattern);
-        if (ret == -EINVAL)
-                return 1; /* "not controllable" */
-        else if (ret)
+        if (ret)
                 return ret;
 
         ret = max8997_read_reg(i2c, reg, &val);
@@ -382,7 +379,7 @@ static int max8997_get_voltage_register(struct regulator_dev *rdev,
         return 0;
 }
 
-static int max8997_get_voltage(struct regulator_dev *rdev)
+static int max8997_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
         struct i2c_client *i2c = max8997->iodev->i2c;
@@ -400,15 +397,7 @@ static int max8997_get_voltage(struct regulator_dev *rdev)
         val >>= shift;
         val &= mask;
 
-        if (rdev->desc && rdev->desc->ops && rdev->desc->ops->list_voltage)
-                return rdev->desc->ops->list_voltage(rdev, val);
-
-        /*
-         * max8997_list_voltage returns value for any rdev with voltage_map,
-         * which works for "CHARGER" and "CHARGER TOPOFF" that do not have
-         * list_voltage ops (they are current regulators).
-         */
-        return max8997_list_voltage(rdev, val);
+        return val;
 }
 
 static inline int max8997_get_voltage_proper_val(
@@ -497,9 +486,7 @@ static int max8997_set_voltage_ldobuck(struct regulator_dev *rdev,
         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
         const struct voltage_map_desc *desc;
         int rid = rdev_get_id(rdev);
-        int reg, shift = 0, mask, ret;
-        int i;
-        u8 org;
+        int i, reg, shift, mask, ret;
 
         switch (rid) {
         case MAX8997_LDO1 ... MAX8997_LDO21:
@@ -528,21 +515,50 @@ static int max8997_set_voltage_ldobuck(struct regulator_dev *rdev,
         if (ret)
                 return ret;
 
-        max8997_read_reg(i2c, reg, &org);
-        org = (org & mask) >> shift;
-
         ret = max8997_update_reg(i2c, reg, i << shift, mask << shift);
         *selector = i;
 
-        if (rid == MAX8997_BUCK1 || rid == MAX8997_BUCK2 ||
-                        rid == MAX8997_BUCK4 || rid == MAX8997_BUCK5) {
-                /* If the voltage is increasing */
-                if (org < i)
-                        udelay(DIV_ROUND_UP(desc->step * (i - org),
-                                                max8997->ramp_delay));
+        return ret;
+}
+
+static int max8997_set_voltage_ldobuck_time_sel(struct regulator_dev *rdev,
+                                                unsigned int old_selector,
+                                                unsigned int new_selector)
+{
+        struct max8997_data *max8997 = rdev_get_drvdata(rdev);
+        int rid = rdev_get_id(rdev);
+        const struct voltage_map_desc *desc = reg_voltage_map[rid];
+
+        /* Delay is required only if the voltage is increasing */
+        if (old_selector >= new_selector)
+                return 0;
+
+        /* No need to delay if gpio_dvs_mode */
+        switch (rid) {
+        case MAX8997_BUCK1:
+                if (max8997->buck1_gpiodvs)
+                        return 0;
+                break;
+        case MAX8997_BUCK2:
+                if (max8997->buck2_gpiodvs)
+                        return 0;
+                break;
+        case MAX8997_BUCK5:
+                if (max8997->buck5_gpiodvs)
+                        return 0;
+                break;
         }
 
-        return ret;
+        switch (rid) {
+        case MAX8997_BUCK1:
+        case MAX8997_BUCK2:
+        case MAX8997_BUCK4:
+        case MAX8997_BUCK5:
+                return DIV_ROUND_UP(desc->step * (new_selector - old_selector),
+                                    max8997->ramp_delay);
+        }
+
+        return 0;
 }
 
 /*
@@ -749,11 +765,6 @@ static int max8997_set_voltage_safeout(struct regulator_dev *rdev,
         return ret;
 }
 
-static int max8997_reg_enable_suspend(struct regulator_dev *rdev)
-{
-        return 0;
-}
-
 static int max8997_reg_disable_suspend(struct regulator_dev *rdev)
 {
         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
@@ -786,9 +797,9 @@ static struct regulator_ops max8997_ldo_ops = {
         .is_enabled             = max8997_reg_is_enabled,
         .enable                 = max8997_reg_enable,
         .disable                = max8997_reg_disable,
-        .get_voltage            = max8997_get_voltage,
+        .get_voltage_sel        = max8997_get_voltage_sel,
         .set_voltage            = max8997_set_voltage_ldobuck,
-        .set_suspend_enable     = max8997_reg_enable_suspend,
+        .set_voltage_time_sel   = max8997_set_voltage_ldobuck_time_sel,
         .set_suspend_disable    = max8997_reg_disable_suspend,
 };
 
@@ -797,9 +808,9 @@ static struct regulator_ops max8997_buck_ops = {
         .is_enabled             = max8997_reg_is_enabled,
         .enable                 = max8997_reg_enable,
         .disable                = max8997_reg_disable,
-        .get_voltage            = max8997_get_voltage,
+        .get_voltage_sel        = max8997_get_voltage_sel,
         .set_voltage            = max8997_set_voltage_buck,
-        .set_suspend_enable     = max8997_reg_enable_suspend,
+        .set_voltage_time_sel   = max8997_set_voltage_ldobuck_time_sel,
         .set_suspend_disable    = max8997_reg_disable_suspend,
 };
 
@@ -808,7 +819,6 @@ static struct regulator_ops max8997_fixedvolt_ops = {
         .is_enabled             = max8997_reg_is_enabled,
         .enable                 = max8997_reg_enable,
         .disable                = max8997_reg_disable,
-        .set_suspend_enable     = max8997_reg_enable_suspend,
         .set_suspend_disable    = max8997_reg_disable_suspend,
 };
 
@@ -817,39 +827,56 @@ static struct regulator_ops max8997_safeout_ops = {
         .is_enabled             = max8997_reg_is_enabled,
         .enable                 = max8997_reg_enable,
         .disable                = max8997_reg_disable,
-        .get_voltage            = max8997_get_voltage,
+        .get_voltage_sel        = max8997_get_voltage_sel,
         .set_voltage            = max8997_set_voltage_safeout,
-        .set_suspend_enable     = max8997_reg_enable_suspend,
         .set_suspend_disable    = max8997_reg_disable_suspend,
 };
 
 static struct regulator_ops max8997_fixedstate_ops = {
         .list_voltage           = max8997_list_voltage_charger_cv,
-        .get_voltage            = max8997_get_voltage,
+        .get_voltage_sel        = max8997_get_voltage_sel,
         .set_voltage            = max8997_set_voltage_charger_cv,
 };
 
-static int max8997_set_voltage_ldobuck_wrap(struct regulator_dev *rdev,
-                int min_uV, int max_uV)
+static int max8997_set_current_limit(struct regulator_dev *rdev,
+                                     int min_uA, int max_uA)
 {
         unsigned dummy;
+        int rid = rdev_get_id(rdev);
+
+        if (rid != MAX8997_CHARGER && rid != MAX8997_CHARGER_TOPOFF)
+                return -EINVAL;
 
-        return max8997_set_voltage_ldobuck(rdev, min_uV, max_uV, &dummy);
+        /* Reuse max8997_set_voltage_ldobuck to set current_limit. */
+        return max8997_set_voltage_ldobuck(rdev, min_uA, max_uA, &dummy);
 }
 
+static int max8997_get_current_limit(struct regulator_dev *rdev)
+{
+        int sel, rid = rdev_get_id(rdev);
+
+        if (rid != MAX8997_CHARGER && rid != MAX8997_CHARGER_TOPOFF)
+                return -EINVAL;
+
+        sel = max8997_get_voltage_sel(rdev);
+        if (sel < 0)
+                return sel;
+
+        /* Reuse max8997_list_voltage to get current_limit. */
+        return max8997_list_voltage(rdev, sel);
+}
 
 static struct regulator_ops max8997_charger_ops = {
         .is_enabled             = max8997_reg_is_enabled,
         .enable                 = max8997_reg_enable,
         .disable                = max8997_reg_disable,
-        .get_current_limit      = max8997_get_voltage,
-        .set_current_limit      = max8997_set_voltage_ldobuck_wrap,
+        .get_current_limit      = max8997_get_current_limit,
+        .set_current_limit      = max8997_set_current_limit,
 };
 
 static struct regulator_ops max8997_charger_fixedstate_ops = {
-        .is_enabled             = max8997_reg_is_enabled,
-        .get_current_limit      = max8997_get_voltage,
-        .set_current_limit      = max8997_set_voltage_ldobuck_wrap,
+        .get_current_limit      = max8997_get_current_limit,
+        .set_current_limit      = max8997_set_current_limit,
 };
 
 #define MAX8997_VOLTAGE_REGULATOR(_name, _ops) {\
@@ -922,16 +949,15 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        max8997 = kzalloc(sizeof(struct max8997_data), GFP_KERNEL);
+        max8997 = devm_kzalloc(&pdev->dev, sizeof(struct max8997_data),
+                               GFP_KERNEL);
         if (!max8997)
                 return -ENOMEM;
 
         size = sizeof(struct regulator_dev *) * pdata->num_regulators;
-        max8997->rdev = kzalloc(size, GFP_KERNEL);
-        if (!max8997->rdev) {
-                kfree(max8997);
+        max8997->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
+        if (!max8997->rdev)
                 return -ENOMEM;
-        }
 
         rdev = max8997->rdev;
         max8997->dev = &pdev->dev;
@@ -955,7 +981,7 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                                         pdata->buck1_voltage[i] / 1000 +
                                         buck1245_voltage_map_desc.step);
                 if (ret < 0)
-                        goto err_alloc;
+                        goto err_out;
 
                 max8997->buck2_vol[i] = ret =
                         max8997_get_voltage_proper_val(
@@ -964,7 +990,7 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                                         pdata->buck2_voltage[i] / 1000 +
                                         buck1245_voltage_map_desc.step);
                 if (ret < 0)
-                        goto err_alloc;
+                        goto err_out;
 
                 max8997->buck5_vol[i] = ret =
                         max8997_get_voltage_proper_val(
@@ -973,7 +999,7 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                                         pdata->buck5_voltage[i] / 1000 +
                                         buck1245_voltage_map_desc.step);
                 if (ret < 0)
-                        goto err_alloc;
+                        goto err_out;
 
                 if (max_buck1 < max8997->buck1_vol[i])
                         max_buck1 = max8997->buck1_vol[i];
@@ -1006,7 +1032,7 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                                 !gpio_is_valid(pdata->buck125_gpios[2])) {
                         dev_err(&pdev->dev, "GPIO NOT VALID\n");
                         ret = -EINVAL;
-                        goto err_alloc;
+                        goto err_out;
                 }
 
                 ret = gpio_request(pdata->buck125_gpios[0],
@@ -1015,7 +1041,7 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                         dev_warn(&pdev->dev, "Duplicated gpio request"
                                         " on SET1\n");
                 else if (ret)
-                        goto err_alloc;
+                        goto err_out;
                 else
                         gpio1set = true;
 
@@ -1027,7 +1053,7 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                 else if (ret) {
                         if (gpio1set)
                                 gpio_free(pdata->buck125_gpios[0]);
-                        goto err_alloc;
+                        goto err_out;
                 } else
                         gpio2set = true;
 
@@ -1041,7 +1067,7 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                                 gpio_free(pdata->buck125_gpios[0]);
                         if (gpio2set)
                                 gpio_free(pdata->buck125_gpios[1]);
-                        goto err_alloc;
+                        goto err_out;
                 }
 
                 gpio_direction_output(pdata->buck125_gpios[0],
@@ -1110,13 +1136,9 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
 
         return 0;
 err:
-        for (i = 0; i < max8997->num_regulators; i++)
-                if (rdev[i])
-                        regulator_unregister(rdev[i]);
-err_alloc:
-        kfree(max8997->rdev);
-        kfree(max8997);
-
+        while (--i >= 0)
+                regulator_unregister(rdev[i]);
+err_out:
         return ret;
 }
 
@@ -1127,12 +1149,7 @@ static int __devexit max8997_pmic_remove(struct platform_device *pdev)
         int i;
 
         for (i = 0; i < max8997->num_regulators; i++)
-                if (rdev[i])
-                        regulator_unregister(rdev[i]);
-
-        kfree(max8997->rdev);
-        kfree(max8997);
-
+                regulator_unregister(rdev[i]);
         return 0;
 }
 
diff --git a/drivers/regulator/max8998.c b/drivers/regulator/max8998.c
index 4ca22f9b52e..18bb58b9b96 100644
--- a/drivers/regulator/max8998.c
+++ b/drivers/regulator/max8998.c
@@ -28,7 +28,6 @@
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
-#include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/mfd/max8998.h>
@@ -719,16 +718,15 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        max8998 = kzalloc(sizeof(struct max8998_data), GFP_KERNEL);
+        max8998 = devm_kzalloc(&pdev->dev, sizeof(struct max8998_data),
+                               GFP_KERNEL);
         if (!max8998)
                 return -ENOMEM;
 
         size = sizeof(struct regulator_dev *) * pdata->num_regulators;
-        max8998->rdev = kzalloc(size, GFP_KERNEL);
-        if (!max8998->rdev) {
-                kfree(max8998);
+        max8998->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
+        if (!max8998->rdev)
                 return -ENOMEM;
-        }
 
         rdev = max8998->rdev;
         max8998->dev = &pdev->dev;
@@ -752,14 +750,14 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                         printk(KERN_ERR "MAX8998 SET1 GPIO defined as 0 !\n");
                         WARN_ON(!pdata->buck1_set1);
                         ret = -EIO;
-                        goto err_free_mem;
+                        goto err_out;
                 }
                 /* Check if SET2 is not equal to 0 */
                 if (!pdata->buck1_set2) {
                         printk(KERN_ERR "MAX8998 SET2 GPIO defined as 0 !\n");
                         WARN_ON(!pdata->buck1_set2);
                         ret = -EIO;
-                        goto err_free_mem;
+                        goto err_out;
                 }
 
                 gpio_request(pdata->buck1_set1, "MAX8998 BUCK1_SET1");
@@ -779,7 +777,7 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                 max8998->buck1_vol[0] = i;
                 ret = max8998_write_reg(i2c, MAX8998_REG_BUCK1_VOLTAGE1, i);
                 if (ret)
-                        goto err_free_mem;
+                        goto err_out;
 
                 /* Set predefined value for BUCK1 register 2 */
                 i = 0;
@@ -791,7 +789,7 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                 max8998->buck1_vol[1] = i;
                 ret = max8998_write_reg(i2c, MAX8998_REG_BUCK1_VOLTAGE2, i);
                 if (ret)
-                        goto err_free_mem;
+                        goto err_out;
 
                 /* Set predefined value for BUCK1 register 3 */
                 i = 0;
@@ -803,7 +801,7 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                 max8998->buck1_vol[2] = i;
                 ret = max8998_write_reg(i2c, MAX8998_REG_BUCK1_VOLTAGE3, i);
                 if (ret)
-                        goto err_free_mem;
+                        goto err_out;
 
                 /* Set predefined value for BUCK1 register 4 */
                 i = 0;
@@ -815,7 +813,7 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                 max8998->buck1_vol[3] = i;
                 ret = max8998_write_reg(i2c, MAX8998_REG_BUCK1_VOLTAGE4, i);
                 if (ret)
-                        goto err_free_mem;
+                        goto err_out;
 
         }
 
@@ -825,7 +823,7 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                         printk(KERN_ERR "MAX8998 SET3 GPIO defined as 0 !\n");
                         WARN_ON(!pdata->buck2_set3);
                         ret = -EIO;
-                        goto err_free_mem;
+                        goto err_out;
                 }
                 gpio_request(pdata->buck2_set3, "MAX8998 BUCK2_SET3");
                 gpio_direction_output(pdata->buck2_set3,
@@ -840,7 +838,7 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                 max8998->buck2_vol[0] = i;
                 ret = max8998_write_reg(i2c, MAX8998_REG_BUCK2_VOLTAGE1, i);
                 if (ret)
-                        goto err_free_mem;
+                        goto err_out;
 
                 /* BUCK2 register 2 */
                 i = 0;
@@ -851,7 +849,7 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                 max8998->buck2_vol[1] = i;
                 ret = max8998_write_reg(i2c, MAX8998_REG_BUCK2_VOLTAGE2, i);
                 if (ret)
-                        goto err_free_mem;
+                        goto err_out;
         }
 
         for (i = 0; i < pdata->num_regulators; i++) {
@@ -881,14 +879,9 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
 
         return 0;
 err:
-        for (i = 0; i < max8998->num_regulators; i++)
-                if (rdev[i])
-                        regulator_unregister(rdev[i]);
-
-err_free_mem:
-        kfree(max8998->rdev);
-        kfree(max8998);
-
+        while (--i >= 0)
+                regulator_unregister(rdev[i]);
+err_out:
         return ret;
 }
 
@@ -899,12 +892,7 @@ static int __devexit max8998_pmic_remove(struct platform_device *pdev)
         int i;
 
         for (i = 0; i < max8998->num_regulators; i++)
-                if (rdev[i])
-                        regulator_unregister(rdev[i]);
-
-        kfree(max8998->rdev);
-        kfree(max8998);
-
+                regulator_unregister(rdev[i]);
         return 0;
 }
 
diff --git a/drivers/regulator/of_regulator.c b/drivers/regulator/of_regulator.c
index 679734d26a1..56593b75168 100644
--- a/drivers/regulator/of_regulator.c
+++ b/drivers/regulator/of_regulator.c
@@ -14,6 +14,7 @@
 #include <linux/slab.h>
 #include <linux/of.h>
 #include <linux/regulator/machine.h>
+#include <linux/regulator/of_regulator.h>
 
 static void of_get_regulation_constraints(struct device_node *np,
                                         struct regulator_init_data **init_data)
@@ -85,3 +86,49 @@ struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
         return init_data;
 }
 EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
+
+/**
+ * of_regulator_match - extract regulator init data
+ * @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.
+ *
+ * Returns the number of matches found or a negative error code on failure.
+ */
+int of_regulator_match(struct device *dev, struct device_node *node,
+                       struct of_regulator_match *matches,
+                       unsigned int num_matches)
+{
+        unsigned int count = 0;
+        unsigned int i;
+
+        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",
+                                child->name);
+                        return -EINVAL;
+                }
+
+                match->of_node = child;
+                count++;
+        }
+
+        return count;
+}
+EXPORT_SYMBOL_GPL(of_regulator_match);
diff --git a/drivers/regulator/rc5t583-regulator.c b/drivers/regulator/rc5t583-regulator.c
index c4adefe973a..7951260e4cd 100644
--- a/drivers/regulator/rc5t583-regulator.c
+++ b/drivers/regulator/rc5t583-regulator.c
@@ -23,7 +23,6 @@
  */
 
 #include <linux/module.h>
-#include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/err.h>
diff --git a/drivers/regulator/s5m8767.c b/drivers/regulator/s5m8767.c
index cb53187a60d..cf12e635154 100644
--- a/drivers/regulator/s5m8767.c
+++ b/drivers/regulator/s5m8767.c
@@ -12,7 +12,6 @@
  */
 
 #include <linux/bug.h>
-#include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/gpio.h>
 #include <linux/slab.h>
@@ -347,7 +346,10 @@ static int s5m8767_convert_voltage_to_sel(
         if (max_vol < desc->min || min_vol > desc->max)
                 return -EINVAL;
 
-        selector = (min_vol - desc->min) / desc->step;
+        if (min_vol < desc->min)
+                min_vol = desc->min;
+
+        selector = DIV_ROUND_UP(min_vol - desc->min, desc->step);
 
         if (desc->min + desc->step * selector > max_vol)
                 return -EINVAL;
diff --git a/drivers/regulator/tps62360-regulator.c b/drivers/regulator/tps62360-regulator.c
index 0657c98352d..97fd98bad82 100644
--- a/drivers/regulator/tps62360-regulator.c
+++ b/drivers/regulator/tps62360-regulator.c
@@ -32,7 +32,6 @@
 #include <linux/regulator/tps62360.h>
 #include <linux/gpio.h>
 #include <linux/i2c.h>
-#include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/regmap.h>
 
@@ -48,10 +47,10 @@
 
 enum chips {TPS62360, TPS62361, TPS62362, TPS62363};
 
-#define TPS62360_BASE_VOLTAGE   770
+#define TPS62360_BASE_VOLTAGE   770000
 #define TPS62360_N_VOLTAGES     64
 
-#define TPS62361_BASE_VOLTAGE   500
+#define TPS62361_BASE_VOLTAGE   500000
 #define TPS62361_N_VOLTAGES     128
 
 /* tps 62360 chip information */
@@ -72,6 +71,7 @@ struct tps62360_chip {
         int lru_index[4];
         int curr_vset_vsel[4];
         int curr_vset_id;
+        int change_uv_per_us;
 };
 
 /*
@@ -97,6 +97,7 @@ static bool find_voltage_set_register(struct tps62360_chip *tps,
         bool found = false;
         int new_vset_reg = tps->lru_index[3];
         int found_index = 3;
+
         for (i = 0; i < 4; ++i) {
                 if (tps->curr_vset_vsel[tps->lru_index[i]] == req_vsel) {
                         new_vset_reg = tps->lru_index[i];
@@ -115,7 +116,7 @@ update_lru_index:
         return found;
 }
 
-static int tps62360_dcdc_get_voltage(struct regulator_dev *dev)
+static int tps62360_dcdc_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps62360_chip *tps = rdev_get_drvdata(dev);
         int vsel;
@@ -124,12 +125,12 @@ static int tps62360_dcdc_get_voltage(struct regulator_dev *dev)
 
         ret = regmap_read(tps->regmap, REG_VSET0 + tps->curr_vset_id, &data);
         if (ret < 0) {
-                dev_err(tps->dev, "%s: Error in reading register %d\n",
-                        __func__, REG_VSET0 + tps->curr_vset_id);
+                dev_err(tps->dev, "%s(): register %d read failed with err %d\n",
+                        __func__, REG_VSET0 + tps->curr_vset_id, ret);
                 return ret;
         }
         vsel = (int)data & tps->voltage_reg_mask;
-        return (tps->voltage_base + vsel * 10) * 1000;
+        return vsel;
 }
 
 static int tps62360_dcdc_set_voltage(struct regulator_dev *dev,
@@ -141,17 +142,13 @@ static int tps62360_dcdc_set_voltage(struct regulator_dev *dev,
         bool found = false;
         int new_vset_id = tps->curr_vset_id;
 
-        if (max_uV < min_uV)
-                return -EINVAL;
-
-        if (min_uV >
-                ((tps->voltage_base + (tps->desc.n_voltages - 1) * 10) * 1000))
+        if ((max_uV < min_uV) || (max_uV < tps->voltage_base))
                 return -EINVAL;
 
-        if (max_uV < tps->voltage_base * 1000)
+        if (min_uV > (tps->voltage_base + (tps->desc.n_voltages - 1) * 10000))
                 return -EINVAL;
 
-        vsel = DIV_ROUND_UP(min_uV - (tps->voltage_base * 1000), 10000);
+        vsel = DIV_ROUND_UP(min_uV - tps->voltage_base, 10000);
         if (selector)
                 *selector = (vsel & tps->voltage_reg_mask);
 
@@ -166,8 +163,9 @@ static int tps62360_dcdc_set_voltage(struct regulator_dev *dev,
                 ret = regmap_update_bits(tps->regmap, REG_VSET0 + new_vset_id,
                                 tps->voltage_reg_mask, vsel);
                 if (ret < 0) {
-                        dev_err(tps->dev, "%s: Error in updating register %d\n",
-                                 __func__, REG_VSET0 + new_vset_id);
+                        dev_err(tps->dev,
+                                "%s(): register %d update failed with err %d\n",
+                                 __func__, REG_VSET0 + new_vset_id, ret);
                         return ret;
                 }
                 tps->curr_vset_id = new_vset_id;
@@ -176,8 +174,7 @@ static int tps62360_dcdc_set_voltage(struct regulator_dev *dev,
 
         /* Select proper VSET register vio gpios */
         if (tps->valid_gpios) {
-                gpio_set_value_cansleep(tps->vsel0_gpio,
-                                        new_vset_id & 0x1);
+                gpio_set_value_cansleep(tps->vsel0_gpio, new_vset_id & 0x1);
                 gpio_set_value_cansleep(tps->vsel1_gpio,
                                         (new_vset_id >> 1) & 0x1);
         }
@@ -191,57 +188,72 @@ static int tps62360_dcdc_list_voltage(struct regulator_dev *dev,
 
         if (selector >= tps->desc.n_voltages)
                 return -EINVAL;
-        return (tps->voltage_base + selector * 10) * 1000;
+
+        return tps->voltage_base + selector * 10000;
+}
+
+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 = tps62360_dcdc_list_voltage(rdev, old_selector);
+        if (old_uV < 0)
+                return old_uV;
+
+        new_uV = tps62360_dcdc_list_voltage(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 struct regulator_ops tps62360_dcdc_ops = {
-        .get_voltage = tps62360_dcdc_get_voltage,
-        .set_voltage = tps62360_dcdc_set_voltage,
-        .list_voltage = tps62360_dcdc_list_voltage,
+        .get_voltage_sel        = tps62360_dcdc_get_voltage_sel,
+        .set_voltage            = tps62360_dcdc_set_voltage,
+        .list_voltage           = tps62360_dcdc_list_voltage,
+        .set_voltage_time_sel   = tps62360_set_voltage_time_sel,
 };
 
-static int tps62360_init_force_pwm(struct tps62360_chip *tps,
+static int __devinit tps62360_init_force_pwm(struct tps62360_chip *tps,
         struct tps62360_regulator_platform_data *pdata,
         int vset_id)
 {
-        unsigned int data;
         int ret;
-        ret = regmap_read(tps->regmap, REG_VSET0 + vset_id, &data);
-        if (ret < 0) {
-                dev_err(tps->dev, "%s() fails in writing reg %d\n",
-                        __func__, REG_VSET0 + vset_id);
-                return ret;
-        }
-        tps->curr_vset_vsel[vset_id] = data & tps->voltage_reg_mask;
+        int bit = 0;
+
         if (pdata->en_force_pwm)
-                data |= BIT(7);
-        else
-                data &= ~BIT(7);
-        ret = regmap_write(tps->regmap, REG_VSET0 + vset_id, data);
+                bit = BIT(7);
+
+        ret = regmap_update_bits(tps->regmap, REG_VSET0 + vset_id, BIT(7), bit);
         if (ret < 0)
-                dev_err(tps->dev, "%s() fails in writing reg %d\n",
-                                __func__, REG_VSET0 + vset_id);
+                dev_err(tps->dev,
+                        "%s(): register %d update failed with err %d\n",
+                        __func__, REG_VSET0 + vset_id, ret);
         return ret;
 }
 
-static int tps62360_init_dcdc(struct tps62360_chip *tps,
+static int __devinit tps62360_init_dcdc(struct tps62360_chip *tps,
                 struct tps62360_regulator_platform_data *pdata)
 {
         int ret;
         int i;
+        unsigned int ramp_ctrl;
 
-        /* Initailize internal pull up/down control */
+        /* Initialize internal pull up/down control */
         if (tps->en_internal_pulldn)
                 ret = regmap_write(tps->regmap, REG_CONTROL, 0xE0);
         else
                 ret = regmap_write(tps->regmap, REG_CONTROL, 0x0);
         if (ret < 0) {
-                dev_err(tps->dev, "%s() fails in writing reg %d\n",
-                        __func__, REG_CONTROL);
+                dev_err(tps->dev,
+                        "%s(): register %d write failed with err %d\n",
+                        __func__, REG_CONTROL, ret);
                 return ret;
         }
 
-        /* Initailize force PWM mode */
+        /* Initialize force PWM mode */
         if (tps->valid_gpios) {
                 for (i = 0; i < 4; ++i) {
                         ret = tps62360_init_force_pwm(tps, pdata, i);
@@ -256,15 +268,33 @@ static int tps62360_init_dcdc(struct tps62360_chip *tps,
 
         /* Reset output discharge path to reduce power consumption */
         ret = regmap_update_bits(tps->regmap, REG_RAMPCTRL, BIT(2), 0);
-        if (ret < 0)
-                dev_err(tps->dev, "%s() fails in updating reg %d\n",
-                        __func__, REG_RAMPCTRL);
+        if (ret < 0) {
+                dev_err(tps->dev,
+                        "%s(): register %d update failed with err %d\n",
+                        __func__, REG_RAMPCTRL, ret);
+                return ret;
+        }
+
+        /* Get ramp value from ramp control register */
+        ret = regmap_read(tps->regmap, REG_RAMPCTRL, &ramp_ctrl);
+        if (ret < 0) {
+                dev_err(tps->dev,
+                        "%s(): register %d read failed with err %d\n",
+                        __func__, REG_RAMPCTRL, ret);
+                return ret;
+        }
+        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));
         return ret;
 }
 
 static const struct regmap_config tps62360_regmap_config = {
-        .reg_bits = 8,
-        .val_bits = 8,
+        .reg_bits               = 8,
+        .val_bits               = 8,
+        .max_register           = REG_CHIPID,
+        .cache_type             = REGCACHE_RBTREE,
 };
 
 static int __devinit tps62360_probe(struct i2c_client *client,
@@ -279,14 +309,14 @@ static int __devinit tps62360_probe(struct i2c_client *client,
 
         pdata = client->dev.platform_data;
         if (!pdata) {
-                dev_err(&client->dev, "%s() Err: Platform data not found\n",
+                dev_err(&client->dev, "%s(): Platform data not found\n",
                                                 __func__);
                 return -EIO;
         }
 
         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
         if (!tps) {
-                dev_err(&client->dev, "%s() Err: Memory allocation fails\n",
+                dev_err(&client->dev, "%s(): Memory allocation failed\n",
                                                 __func__);
                 return -ENOMEM;
         }
@@ -323,8 +353,9 @@ static int __devinit tps62360_probe(struct i2c_client *client,
         tps->regmap = devm_regmap_init_i2c(client, &tps62360_regmap_config);
         if (IS_ERR(tps->regmap)) {
                 ret = PTR_ERR(tps->regmap);
-                dev_err(&client->dev, "%s() Err: Failed to allocate register"
-                        "map: %d\n", __func__, ret);
+                dev_err(&client->dev,
+                        "%s(): regmap allocation failed with err %d\n",
+                        __func__, ret);
                 return ret;
         }
         i2c_set_clientdata(client, tps);
@@ -335,35 +366,26 @@ static int __devinit tps62360_probe(struct i2c_client *client,
         tps->valid_gpios = false;
 
         if (gpio_is_valid(tps->vsel0_gpio) && gpio_is_valid(tps->vsel1_gpio)) {
-                ret = gpio_request(tps->vsel0_gpio, "tps62360-vsel0");
+                int gpio_flags;
+                gpio_flags = (pdata->vsel0_def_state) ?
+                                GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
+                ret = gpio_request_one(tps->vsel0_gpio,
+                                gpio_flags, "tps62360-vsel0");
                 if (ret) {
                         dev_err(&client->dev,
-                                "Err: Could not obtain vsel0 GPIO %d: %d\n",
-                                                tps->vsel0_gpio, ret);
-                        goto err_gpio0;
-                }
-                ret = gpio_direction_output(tps->vsel0_gpio,
-                                        pdata->vsel0_def_state);
-                if (ret) {
-                        dev_err(&client->dev, "Err: Could not set direction of"
-                                "vsel0 GPIO %d: %d\n", tps->vsel0_gpio, ret);
-                        gpio_free(tps->vsel0_gpio);
+                                "%s(): Could not obtain vsel0 GPIO %d: %d\n",
+                                __func__, tps->vsel0_gpio, ret);
                         goto err_gpio0;
                 }
 
-                ret = gpio_request(tps->vsel1_gpio, "tps62360-vsel1");
+                gpio_flags = (pdata->vsel1_def_state) ?
+                                GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
+                ret = gpio_request_one(tps->vsel1_gpio,
+                                gpio_flags, "tps62360-vsel1");
                 if (ret) {
                         dev_err(&client->dev,
-                                "Err: Could not obtain vsel1 GPIO %d: %d\n",
-                                                tps->vsel1_gpio, ret);
-                        goto err_gpio1;
-                }
-                ret = gpio_direction_output(tps->vsel1_gpio,
-                                        pdata->vsel1_def_state);
-                if (ret) {
-                        dev_err(&client->dev, "Err: Could not set direction of"
-                                "vsel1 GPIO %d: %d\n", tps->vsel1_gpio, ret);
-                        gpio_free(tps->vsel1_gpio);
+                                "%s(): Could not obtain vsel1 GPIO %d: %d\n",
+                                __func__, tps->vsel1_gpio, ret);
                         goto err_gpio1;
                 }
                 tps->valid_gpios = true;
@@ -380,7 +402,7 @@ static int __devinit tps62360_probe(struct i2c_client *client,
 
         ret = tps62360_init_dcdc(tps, pdata);
         if (ret < 0) {
-                dev_err(tps->dev, "%s() Err: Init fails with = %d\n",
+                dev_err(tps->dev, "%s(): Init failed with err = %d\n",
                                 __func__, ret);
                 goto err_init;
         }
@@ -392,8 +414,9 @@ static int __devinit tps62360_probe(struct i2c_client *client,
         /* Register the regulators */
         rdev = regulator_register(&tps->desc, &config);
         if (IS_ERR(rdev)) {
-                dev_err(tps->dev, "%s() Err: Failed to register %s\n",
-                                __func__, id->name);
+                dev_err(tps->dev,
+                        "%s(): regulator register failed with err %s\n",
+                        __func__, id->name);
                 ret = PTR_ERR(rdev);
                 goto err_init;
         }
@@ -442,8 +465,9 @@ static void tps62360_shutdown(struct i2c_client *client)
         /* Configure the output discharge path */
         st = regmap_update_bits(tps->regmap, REG_RAMPCTRL, BIT(2), BIT(2));
         if (st < 0)
-                dev_err(tps->dev, "%s() fails in updating reg %d\n",
-                        __func__, REG_RAMPCTRL);
+                dev_err(tps->dev,
+                        "%s(): register %d update failed with err %d\n",
+                        __func__, REG_RAMPCTRL, st);
 }
 
 static const struct i2c_device_id tps62360_id[] = {
diff --git a/drivers/regulator/tps65023-regulator.c b/drivers/regulator/tps65023-regulator.c
index a1fd65682f4..f841bd0db6a 100644
--- a/drivers/regulator/tps65023-regulator.c
+++ b/drivers/regulator/tps65023-regulator.c
@@ -23,7 +23,6 @@
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
 #include <linux/i2c.h>
-#include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/regmap.h>
 
diff --git a/drivers/regulator/tps6507x-regulator.c b/drivers/regulator/tps6507x-regulator.c
index 8e432004b94..da38be1016a 100644
--- a/drivers/regulator/tps6507x-regulator.c
+++ b/drivers/regulator/tps6507x-regulator.c
@@ -23,7 +23,6 @@
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
 #include <linux/regulator/tps6507x.h>
-#include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/mfd/tps6507x.h>
 
@@ -283,7 +282,7 @@ static int tps6507x_pmic_disable(struct regulator_dev *dev)
                                         1 << shift);
 }
 
-static int tps6507x_pmic_get_voltage(struct regulator_dev *dev)
+static int tps6507x_pmic_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int data, rid = rdev_get_id(dev);
@@ -325,7 +324,7 @@ static int tps6507x_pmic_get_voltage(struct regulator_dev *dev)
                 return data;
 
         data &= mask;
-        return tps->info[rid]->table[data] * 1000;
+        return data;
 }
 
 static int tps6507x_pmic_set_voltage_sel(struct regulator_dev *dev,
@@ -395,7 +394,7 @@ static struct regulator_ops tps6507x_pmic_ops = {
         .is_enabled = tps6507x_pmic_is_enabled,
         .enable = tps6507x_pmic_enable,
         .disable = tps6507x_pmic_disable,
-        .get_voltage = tps6507x_pmic_get_voltage,
+        .get_voltage_sel = tps6507x_pmic_get_voltage_sel,
         .set_voltage_sel = tps6507x_pmic_set_voltage_sel,
         .list_voltage = tps6507x_pmic_list_voltage,
 };
diff --git a/drivers/regulator/tps65090-regulator.c b/drivers/regulator/tps65090-regulator.c
index 661fcecd1ce..001ad554ac6 100644
--- a/drivers/regulator/tps65090-regulator.c
+++ b/drivers/regulator/tps65090-regulator.c
@@ -17,7 +17,6 @@
  */
 
 #include <linux/module.h>
-#include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/err.h>
diff --git a/drivers/regulator/tps6586x-regulator.c b/drivers/regulator/tps6586x-regulator.c
index 9a4029a446d..c0a21457538 100644
--- a/drivers/regulator/tps6586x-regulator.c
+++ b/drivers/regulator/tps6586x-regulator.c
@@ -363,6 +363,7 @@ static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
                 return err;
 
         config.dev = &pdev->dev;
+        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 43bc6c6bc8f..5ee7e4bd8b5 100644
--- a/drivers/regulator/tps65910-regulator.c
+++ b/drivers/regulator/tps65910-regulator.c
@@ -20,7 +20,6 @@
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
-#include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/gpio.h>
 #include <linux/mfd/tps65910.h>
@@ -579,10 +578,10 @@ static int tps65910_get_voltage_dcdc_sel(struct regulator_dev *dev)
         return -EINVAL;
 }
 
-static int tps65910_get_voltage(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), voltage = 0;
+        int reg, value, id = rdev_get_id(dev);
 
         reg = pmic->get_ctrl_reg(id);
         if (reg < 0)
@@ -609,9 +608,7 @@ static int tps65910_get_voltage(struct regulator_dev *dev)
                 return -EINVAL;
         }
 
-        voltage = pmic->info[id]->voltage_table[value] * 1000;
-
-        return voltage;
+        return value;
 }
 
 static int tps65910_get_voltage_vdd3(struct regulator_dev *dev)
@@ -619,10 +616,10 @@ static int tps65910_get_voltage_vdd3(struct regulator_dev *dev)
         return 5 * 1000 * 1000;
 }
 
-static int tps65911_get_voltage(struct regulator_dev *dev)
+static int tps65911_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int step_mv, id = rdev_get_id(dev);
+        int id = rdev_get_id(dev);
         u8 value, reg;
 
         reg = pmic->get_ctrl_reg(id);
@@ -635,13 +632,6 @@ static int tps65911_get_voltage(struct regulator_dev *dev)
         case TPS65911_REG_LDO4:
                 value &= LDO1_SEL_MASK;
                 value >>= LDO_SEL_SHIFT;
-                /* The first 5 values of the selector correspond to 1V */
-                if (value < 5)
-                        value = 0;
-                else
-                        value -= 4;
-
-                step_mv = 50;
                 break;
         case TPS65911_REG_LDO3:
         case TPS65911_REG_LDO5:
@@ -650,23 +640,16 @@ static int tps65911_get_voltage(struct regulator_dev *dev)
         case TPS65911_REG_LDO8:
                 value &= LDO3_SEL_MASK;
                 value >>= LDO_SEL_SHIFT;
-                /* The first 3 values of the selector correspond to 1V */
-                if (value < 3)
-                        value = 0;
-                else
-                        value -= 2;
-
-                step_mv = 100;
                 break;
         case TPS65910_REG_VIO:
                 value &= LDO_SEL_MASK;
                 value >>= LDO_SEL_SHIFT;
-                return pmic->info[id]->voltage_table[value] * 1000;
+                break;
         default:
                 return -EINVAL;
         }
 
-        return (LDO_MIN_VOLT + value * step_mv) * 1000;
+        return value;
 }
 
 static int tps65910_set_voltage_dcdc_sel(struct regulator_dev *dev,
@@ -902,7 +885,7 @@ static struct regulator_ops tps65910_ops = {
         .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
-        .get_voltage            = tps65910_get_voltage,
+        .get_voltage_sel        = tps65910_get_voltage_sel,
         .set_voltage_sel        = tps65910_set_voltage_sel,
         .list_voltage           = tps65910_list_voltage,
 };
@@ -914,7 +897,7 @@ static struct regulator_ops tps65911_ops = {
         .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
-        .get_voltage            = tps65911_get_voltage,
+        .get_voltage_sel        = tps65911_get_voltage_sel,
         .set_voltage_sel        = tps65911_set_voltage_sel,
         .list_voltage           = tps65911_list_voltage,
 };
diff --git a/drivers/regulator/tps65912-regulator.c b/drivers/regulator/tps65912-regulator.c
index af335dd3590..18b2a1dcb4b 100644
--- a/drivers/regulator/tps65912-regulator.c
+++ b/drivers/regulator/tps65912-regulator.c
@@ -20,7 +20,6 @@
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
-#include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/gpio.h>
 #include <linux/mfd/tps65912.h>
@@ -406,7 +405,7 @@ static int tps65912_list_voltage(struct regulator_dev *dev, unsigned selector)
         return voltage;
 }
 
-static int tps65912_get_voltage(struct regulator_dev *dev)
+static int tps65912_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps65912_reg *pmic = rdev_get_drvdata(dev);
         struct tps65912 *mfd = pmic->mfd;
@@ -420,7 +419,7 @@ static int tps65912_get_voltage(struct regulator_dev *dev)
         vsel = tps65912_reg_read(mfd, reg);
         vsel &= 0x3F;
 
-        return tps65912_list_voltage(dev, vsel);
+        return vsel;
 }
 
 static int tps65912_set_voltage_sel(struct regulator_dev *dev,
@@ -445,7 +444,7 @@ static struct regulator_ops tps65912_ops_dcdc = {
         .disable = tps65912_reg_disable,
         .set_mode = tps65912_set_mode,
         .get_mode = tps65912_get_mode,
-        .get_voltage = tps65912_get_voltage,
+        .get_voltage_sel = tps65912_get_voltage_sel,
         .set_voltage_sel = tps65912_set_voltage_sel,
         .list_voltage = tps65912_list_voltage,
 };
@@ -455,7 +454,7 @@ static struct regulator_ops tps65912_ops_ldo = {
         .is_enabled = tps65912_reg_is_enabled,
         .enable = tps65912_reg_enable,
         .disable = tps65912_reg_disable,
-        .get_voltage = tps65912_get_voltage,
+        .get_voltage_sel = tps65912_get_voltage_sel,
         .set_voltage_sel = tps65912_set_voltage_sel,
         .list_voltage = tps65912_list_voltage,
 };
diff --git a/drivers/regulator/twl-regulator.c b/drivers/regulator/twl-regulator.c
index 7385b273a10..c7390711d95 100644
--- a/drivers/regulator/twl-regulator.c
+++ b/drivers/regulator/twl-regulator.c
@@ -12,7 +12,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/err.h>
-#include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
@@ -396,14 +395,12 @@ static int twl6030reg_set_mode(struct regulator_dev *rdev, unsigned mode)
  * VAUX3 at 3V is incorrectly listed in some TI manuals as unsupported.
  * TI are revising the twl5030/tps659x0 specs to support that 3.0V setting.
  */
-#ifdef CONFIG_TWL4030_ALLOW_UNSUPPORTED
-#define UNSUP_MASK      0x0000
-#else
 #define UNSUP_MASK      0x8000
-#endif
 
 #define UNSUP(x)        (UNSUP_MASK | (x))
-#define IS_UNSUP(x)     (UNSUP_MASK & (x))
+#define IS_UNSUP(info, x)                       \
+        ((UNSUP_MASK & (x)) &&                  \
+         !((info)->features & TWL4030_ALLOW_UNSUPPORTED))
 #define LDO_MV(x)       (~UNSUP_MASK & (x))
 
 
@@ -477,7 +474,7 @@ static int twl4030ldo_list_voltage(struct regulator_dev *rdev, unsigned index)
         struct twlreg_info      *info = rdev_get_drvdata(rdev);
         int                     mV = info->table[index];
 
-        return IS_UNSUP(mV) ? 0 : (LDO_MV(mV) * 1000);
+        return IS_UNSUP(info, mV) ? 0 : (LDO_MV(mV) * 1000);
 }
 
 static int
diff --git a/drivers/regulator/userspace-consumer.c b/drivers/regulator/userspace-consumer.c
index 518667ef9a0..a7c8deb5f28 100644
--- a/drivers/regulator/userspace-consumer.c
+++ b/drivers/regulator/userspace-consumer.c
@@ -115,7 +115,9 @@ static int regulator_userspace_consumer_probe(struct platform_device *pdev)
         if (!pdata)
                 return -EINVAL;
 
-        drvdata = kzalloc(sizeof(struct userspace_consumer_data), GFP_KERNEL);
+        drvdata = devm_kzalloc(&pdev->dev,
+                               sizeof(struct userspace_consumer_data),
+                               GFP_KERNEL);
         if (drvdata == NULL)
                 return -ENOMEM;
 
@@ -125,16 +127,16 @@ static int regulator_userspace_consumer_probe(struct platform_device *pdev)
 
         mutex_init(&drvdata->lock);
 
-        ret = regulator_bulk_get(&pdev->dev, drvdata->num_supplies,
-                                 drvdata->supplies);
+        ret = devm_regulator_bulk_get(&pdev->dev, drvdata->num_supplies,
+                                      drvdata->supplies);
         if (ret) {
                 dev_err(&pdev->dev, "Failed to get supplies: %d\n", ret);
-                goto err_alloc_supplies;
+                return ret;
         }
 
         ret = sysfs_create_group(&pdev->dev.kobj, &attr_group);
         if (ret != 0)
-                goto err_create_attrs;
+                return ret;
 
         if (pdata->init_on) {
                 ret = regulator_bulk_enable(drvdata->num_supplies,
@@ -154,11 +156,6 @@ static int regulator_userspace_consumer_probe(struct platform_device *pdev)
 err_enable:
         sysfs_remove_group(&pdev->dev.kobj, &attr_group);
 
-err_create_attrs:
-        regulator_bulk_free(drvdata->num_supplies, drvdata->supplies);
-
-err_alloc_supplies:
-        kfree(drvdata);
         return ret;
 }
 
@@ -171,9 +168,6 @@ static int regulator_userspace_consumer_remove(struct platform_device *pdev)
         if (data->enabled)
                 regulator_bulk_disable(data->num_supplies, data->supplies);
 
-        regulator_bulk_free(data->num_supplies, data->supplies);
-        kfree(data);
-
         return 0;
 }
 
diff --git a/drivers/regulator/virtual.c b/drivers/regulator/virtual.c
index ee0b161c998..c038e742253 100644
--- a/drivers/regulator/virtual.c
+++ b/drivers/regulator/virtual.c
@@ -121,7 +121,7 @@ static ssize_t set_min_uV(struct device *dev, struct device_attribute *attr,
         struct virtual_consumer_data *data = dev_get_drvdata(dev);
         long val;
 
-        if (strict_strtol(buf, 10, &val) != 0)
+        if (kstrtol(buf, 10, &val) != 0)
                 return count;
 
         mutex_lock(&data->lock);
@@ -147,7 +147,7 @@ static ssize_t set_max_uV(struct device *dev, struct device_attribute *attr,
         struct virtual_consumer_data *data = dev_get_drvdata(dev);
         long val;
 
-        if (strict_strtol(buf, 10, &val) != 0)
+        if (kstrtol(buf, 10, &val) != 0)
                 return count;
 
         mutex_lock(&data->lock);
@@ -173,7 +173,7 @@ static ssize_t set_min_uA(struct device *dev, struct device_attribute *attr,
         struct virtual_consumer_data *data = dev_get_drvdata(dev);
         long val;
 
-        if (strict_strtol(buf, 10, &val) != 0)
+        if (kstrtol(buf, 10, &val) != 0)
                 return count;
 
         mutex_lock(&data->lock);
@@ -199,7 +199,7 @@ static ssize_t set_max_uA(struct device *dev, struct device_attribute *attr,
         struct virtual_consumer_data *data = dev_get_drvdata(dev);
         long val;
 
-        if (strict_strtol(buf, 10, &val) != 0)
+        if (kstrtol(buf, 10, &val) != 0)
                 return count;
 
         mutex_lock(&data->lock);
@@ -291,18 +291,19 @@ static int __devinit regulator_virtual_probe(struct platform_device *pdev)
         struct virtual_consumer_data *drvdata;
         int ret;
 
-        drvdata = kzalloc(sizeof(struct virtual_consumer_data), GFP_KERNEL);
+        drvdata = devm_kzalloc(&pdev->dev, sizeof(struct virtual_consumer_data),
+                               GFP_KERNEL);
         if (drvdata == NULL)
                 return -ENOMEM;
 
         mutex_init(&drvdata->lock);
 
-        drvdata->regulator = regulator_get(&pdev->dev, reg_id);
+        drvdata->regulator = devm_regulator_get(&pdev->dev, reg_id);
         if (IS_ERR(drvdata->regulator)) {
                 ret = PTR_ERR(drvdata->regulator);
                 dev_err(&pdev->dev, "Failed to obtain supply '%s': %d\n",
                         reg_id, ret);
-                goto err;
+                return ret;
         }
 
         ret = sysfs_create_group(&pdev->dev.kobj,
@@ -310,7 +311,7 @@ static int __devinit regulator_virtual_probe(struct platform_device *pdev)
         if (ret != 0) {
                 dev_err(&pdev->dev,
                         "Failed to create attribute group: %d\n", ret);
-                goto err_regulator;
+                return ret;
         }
 
         drvdata->mode = regulator_get_mode(drvdata->regulator);
@@ -318,12 +319,6 @@ static int __devinit regulator_virtual_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, drvdata);
 
         return 0;
-
-err_regulator:
-        regulator_put(drvdata->regulator);
-err:
-        kfree(drvdata);
-        return ret;
 }
 
 static int __devexit regulator_virtual_remove(struct platform_device *pdev)
@@ -334,9 +329,6 @@ static int __devexit regulator_virtual_remove(struct platform_device *pdev)
 
         if (drvdata->enabled)
                 regulator_disable(drvdata->regulator);
-        regulator_put(drvdata->regulator);
-
-        kfree(drvdata);
 
         platform_set_drvdata(pdev, NULL);
 
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
index 318b9631155..8710cfb0c19 100644
--- a/drivers/regulator/wm831x-dcdc.c
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -35,7 +35,7 @@
 #define WM831X_DCDC_MODE_IDLE    2
 #define WM831X_DCDC_MODE_STANDBY 3
 
-#define WM831X_DCDC_MAX_NAME 6
+#define WM831X_DCDC_MAX_NAME 9
 
 /* Register offsets in control block */
 #define WM831X_DCDC_CONTROL_1     0
@@ -50,6 +50,7 @@
 
 struct wm831x_dcdc {
         char name[WM831X_DCDC_MAX_NAME];
+        char supply_name[WM831X_DCDC_MAX_NAME];
         struct regulator_desc desc;
         int base;
         struct wm831x *wm831x;
@@ -402,23 +403,17 @@ static __devinit void wm831x_buckv_dvs_init(struct wm831x_dcdc *dcdc,
         if (!pdata || !pdata->dvs_gpio)
                 return;
 
-        ret = gpio_request(pdata->dvs_gpio, "DCDC DVS");
-        if (ret < 0) {
-                dev_err(wm831x->dev, "Failed to get %s DVS GPIO: %d\n",
-                        dcdc->name, ret);
-                return;
-        }
-
         /* gpiolib won't let us read the GPIO status so pick the higher
          * of the two existing voltages so we take it as platform data.
          */
         dcdc->dvs_gpio_state = pdata->dvs_init_state;
 
-        ret = gpio_direction_output(pdata->dvs_gpio, dcdc->dvs_gpio_state);
+        ret = gpio_request_one(pdata->dvs_gpio,
+                               dcdc->dvs_gpio_state ? GPIOF_INIT_HIGH : 0,
+                               "DCDC DVS");
         if (ret < 0) {
-                dev_err(wm831x->dev, "Failed to enable %s DVS GPIO: %d\n",
+                dev_err(wm831x->dev, "Failed to get %s DVS GPIO: %d\n",
                         dcdc->name, ret);
-                gpio_free(pdata->dvs_gpio);
                 return;
         }
 
@@ -496,6 +491,11 @@ static __devinit int wm831x_buckv_probe(struct platform_device *pdev)
 
         snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1);
         dcdc->desc.name = dcdc->name;
+
+        snprintf(dcdc->supply_name, sizeof(dcdc->supply_name),
+                 "DC%dVDD", id + 1);
+        dcdc->desc.supply_name = dcdc->supply_name;
+
         dcdc->desc.id = id;
         dcdc->desc.type = REGULATOR_VOLTAGE;
         dcdc->desc.n_voltages = WM831X_BUCKV_MAX_SELECTOR + 1;
@@ -697,6 +697,11 @@ static __devinit int wm831x_buckp_probe(struct platform_device *pdev)
 
         snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1);
         dcdc->desc.name = dcdc->name;
+
+        snprintf(dcdc->supply_name, sizeof(dcdc->supply_name),
+                 "DC%dVDD", id + 1);
+        dcdc->desc.supply_name = dcdc->supply_name;
+
         dcdc->desc.id = id;
         dcdc->desc.type = REGULATOR_VOLTAGE;
         dcdc->desc.n_voltages = WM831X_BUCKP_MAX_SELECTOR + 1;
diff --git a/drivers/regulator/wm831x-ldo.c b/drivers/regulator/wm831x-ldo.c
index 74cd1f24b89..9fe71dc20c3 100644
--- a/drivers/regulator/wm831x-ldo.c
+++ b/drivers/regulator/wm831x-ldo.c
@@ -25,7 +25,7 @@
 #include <linux/mfd/wm831x/regulator.h>
 #include <linux/mfd/wm831x/pdata.h>
 
-#define WM831X_LDO_MAX_NAME 6
+#define WM831X_LDO_MAX_NAME 9
 
 #define WM831X_LDO_CONTROL       0
 #define WM831X_LDO_ON_CONTROL    1
@@ -36,6 +36,7 @@
 
 struct wm831x_ldo {
         char name[WM831X_LDO_MAX_NAME];
+        char supply_name[WM831X_LDO_MAX_NAME];
         struct regulator_desc desc;
         int base;
         struct wm831x *wm831x;
@@ -291,6 +292,11 @@ static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
 
         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
         ldo->desc.name = ldo->name;
+
+        snprintf(ldo->supply_name, sizeof(ldo->supply_name),
+                 "LDO%dVDD", id + 1);
+        ldo->desc.supply_name = ldo->supply_name;
+
         ldo->desc.id = id;
         ldo->desc.type = REGULATOR_VOLTAGE;
         ldo->desc.n_voltages = WM831X_GP_LDO_MAX_SELECTOR + 1;
@@ -547,6 +553,11 @@ static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
 
         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
         ldo->desc.name = ldo->name;
+
+        snprintf(ldo->supply_name, sizeof(ldo->supply_name),
+                 "LDO%dVDD", id + 1);
+        ldo->desc.supply_name = ldo->supply_name;
+
         ldo->desc.id = id;
         ldo->desc.type = REGULATOR_VOLTAGE;
         ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1;
@@ -733,6 +744,11 @@ static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
 
         snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
         ldo->desc.name = ldo->name;
+
+        snprintf(ldo->supply_name, sizeof(ldo->supply_name),
+                 "LDO%dVDD", id + 1);
+        ldo->desc.supply_name = ldo->supply_name;
+
         ldo->desc.id = id;
         ldo->desc.type = REGULATOR_VOLTAGE;
         ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
diff --git a/drivers/regulator/wm8994-regulator.c b/drivers/regulator/wm8994-regulator.c
index e07972fbf44..7c64ce599d2 100644
--- a/drivers/regulator/wm8994-regulator.c
+++ b/drivers/regulator/wm8994-regulator.c
@@ -182,23 +182,16 @@ static __devinit int wm8994_ldo_probe(struct platform_device *pdev)
         if (pdata->ldo[id].enable && gpio_is_valid(pdata->ldo[id].enable)) {
                 ldo->enable = pdata->ldo[id].enable;
 
-                ret = gpio_request(ldo->enable, "WM8994 LDO 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;
                 }
-
-                ret = gpio_direction_output(ldo->enable, ldo->is_enabled);
-                if (ret < 0) {
-                        dev_err(&pdev->dev, "Failed to set GPIO up: %d\n",
-                                ret);
-                        goto err_gpio;
-                }
         } else
                 ldo->is_enabled = true;
 
-        config.dev = &pdev->dev;
+        config.dev = wm8994->dev;
         config.init_data = pdata->ldo[id].init_data;
         config.driver_data = ldo;
         config.regmap = wm8994->regmap;