32 files changed, 1363 insertions, 518 deletions

diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index 9bc774904631..e98a5e7827df 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -109,6 +109,17 @@ config REGULATOR_DA9052
           This driver supports the voltage regulators of DA9052-BC and
           DA9053-AA/Bx PMIC.
 
+config REGULATOR_FAN53555
+        tristate "Fairchild FAN53555 Regulator"
+        depends on I2C
+        select REGMAP_I2C
+        help
+          This driver supports Fairchild FAN53555 Digitally Programmable
+          TinyBuck Regulator. The FAN53555 is a step-down switching voltage
+          regulator that delivers a digitally programmable output from an
+          input voltage supply of 2.5V to 5.5V. The output voltage is
+          programmed through an I2C interface.
+
 config REGULATOR_ANATOP
         tristate "Freescale i.MX on-chip ANATOP LDO regulators"
         depends on MFD_ANATOP
@@ -171,6 +182,14 @@ config REGULATOR_MAX8660
           This driver controls a Maxim 8660/8661 voltage output
           regulator via I2C bus.
 
+config REGULATOR_MAX8907
+        tristate "Maxim 8907 voltage regulator"
+        depends on MFD_MAX8907
+        help
+          This driver controls a Maxim 8907 voltage output regulator
+          via I2C bus. The provided regulator is suitable for Tegra
+          chip to control Step-Down DC-DC and LDOs.
+
 config REGULATOR_MAX8925
         tristate "Maxim MAX8925 Power Management IC"
         depends on MFD_MAX8925
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 3342615cf25e..e431eed8a878 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_REGULATOR_DA903X)	+= da903x.o
 obj-$(CONFIG_REGULATOR_DA9052)  += da9052-regulator.o
 obj-$(CONFIG_REGULATOR_DBX500_PRCMU) += dbx500-prcmu.o
 obj-$(CONFIG_REGULATOR_DB8500_PRCMU) += db8500-prcmu.o
+obj-$(CONFIG_REGULATOR_FAN53555) += fan53555.o
 obj-$(CONFIG_REGULATOR_GPIO) += gpio-regulator.o
 obj-$(CONFIG_REGULATOR_ISL6271A) += isl6271a-regulator.o
 obj-$(CONFIG_REGULATOR_LP3971) += lp3971.o
@@ -30,6 +31,7 @@ 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
+obj-$(CONFIG_REGULATOR_MAX8907) += max8907-regulator.o
 obj-$(CONFIG_REGULATOR_MAX8925) += max8925-regulator.o
 obj-$(CONFIG_REGULATOR_MAX8952) += max8952.o
 obj-$(CONFIG_REGULATOR_MAX8997) += max8997.o
diff --git a/drivers/regulator/aat2870-regulator.c b/drivers/regulator/aat2870-regulator.c
index 6f45bfd22e83..167c93f21981 100644
--- a/drivers/regulator/aat2870-regulator.c
+++ b/drivers/regulator/aat2870-regulator.c
@@ -162,7 +162,7 @@ static struct aat2870_regulator *aat2870_get_regulator(int id)
 static int aat2870_regulator_probe(struct platform_device *pdev)
 {
         struct aat2870_regulator *ri;
-        struct regulator_config config = { 0 };
+        struct regulator_config config = { };
         struct regulator_dev *rdev;
 
         ri = aat2870_get_regulator(pdev->id);
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
index 182b553059c9..65ad2b36ce36 100644
--- a/drivers/regulator/ab3100.c
+++ b/drivers/regulator/ab3100.c
@@ -347,17 +347,11 @@ static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
         return abreg->plfdata->external_voltage;
 }
 
-static int ab3100_get_fixed_voltage_regulator(struct regulator_dev *reg)
-{
-        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_fixed_voltage_regulator,
 };
 
 static struct regulator_ops regulator_ops_variable = {
@@ -486,6 +480,7 @@ ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
                 .id   = AB3100_BUCK,
                 .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 = 1000,
diff --git a/drivers/regulator/ab8500.c b/drivers/regulator/ab8500.c
index 10f2f4d4d190..e3d1d063025a 100644
--- a/drivers/regulator/ab8500.c
+++ b/drivers/regulator/ab8500.c
@@ -37,6 +37,7 @@
  * @voltage_bank: bank to control regulator voltage
  * @voltage_reg: register to control regulator voltage
  * @voltage_mask: mask to control regulator voltage
+ * @voltage_shift: shift to control regulator voltage
  * @delay: startup/set voltage delay in us
  */
 struct ab8500_regulator_info {
@@ -50,6 +51,7 @@ struct ab8500_regulator_info {
         u8 voltage_bank;
         u8 voltage_reg;
         u8 voltage_mask;
+        u8 voltage_shift;
         unsigned int delay;
 };
 
@@ -195,17 +197,14 @@ static int ab8500_regulator_get_voltage_sel(struct regulator_dev *rdev)
         }
 
         dev_vdbg(rdev_get_dev(rdev),
-                "%s-get_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
-                " 0x%x\n",
-                info->desc.name, info->voltage_bank, info->voltage_reg,
-                info->voltage_mask, regval);
+                "%s-get_voltage (bank, reg, mask, shift, value): "
+                "0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
+                info->desc.name, info->voltage_bank,
+                info->voltage_reg, info->voltage_mask,
+                info->voltage_shift, regval);
 
-        /* vintcore has a different layout */
         val = regval & info->voltage_mask;
-        if (info->desc.id == AB8500_LDO_INTCORE)
-                return val >> 0x3;
-        else
-                return val;
+        return val >> info->voltage_shift;
 }
 
 static int ab8500_regulator_set_voltage_sel(struct regulator_dev *rdev,
@@ -221,7 +220,7 @@ static int ab8500_regulator_set_voltage_sel(struct regulator_dev *rdev,
         }
 
         /* set the registers for the request */
-        regval = (u8)selector;
+        regval = (u8)selector << info->voltage_shift;
         ret = abx500_mask_and_set_register_interruptible(info->dev,
                         info->voltage_bank, info->voltage_reg,
                         info->voltage_mask, regval);
@@ -238,13 +237,6 @@ static int ab8500_regulator_set_voltage_sel(struct regulator_dev *rdev,
         return ret;
 }
 
-static int ab8500_regulator_enable_time(struct regulator_dev *rdev)
-{
-        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
-
-        return info->delay;
-}
-
 static int ab8500_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
                                              unsigned int old_sel,
                                              unsigned int new_sel)
@@ -261,22 +253,14 @@ static struct regulator_ops ab8500_regulator_ops = {
         .get_voltage_sel = ab8500_regulator_get_voltage_sel,
         .set_voltage_sel = ab8500_regulator_set_voltage_sel,
         .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)
-{
-        return rdev->desc->min_uV;
-}
-
 static struct regulator_ops ab8500_regulator_fixed_ops = {
         .enable         = ab8500_regulator_enable,
         .disable        = ab8500_regulator_disable,
         .is_enabled     = ab8500_regulator_is_enabled,
-        .get_voltage    = ab8500_fixed_get_voltage,
         .list_voltage   = regulator_list_voltage_linear,
-        .enable_time    = ab8500_regulator_enable_time,
 };
 
 static struct ab8500_regulator_info
@@ -358,6 +342,7 @@ static struct ab8500_regulator_info
                 .voltage_bank           = 0x03,
                 .voltage_reg            = 0x80,
                 .voltage_mask           = 0x38,
+                .voltage_shift          = 3,
         },
 
         /*
@@ -374,6 +359,7 @@ static struct ab8500_regulator_info
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
                         .min_uV         = 2000000,
+                        .enable_time    = 10000,
                 },
                 .delay                  = 10000,
                 .update_bank            = 0x03,
diff --git a/drivers/regulator/anatop-regulator.c b/drivers/regulator/anatop-regulator.c
index e9c2085f9dfb..ce0fe72a428e 100644
--- a/drivers/regulator/anatop-regulator.c
+++ b/drivers/regulator/anatop-regulator.c
@@ -64,14 +64,15 @@ static int anatop_set_voltage_sel(struct regulator_dev *reg, unsigned selector)
 static int anatop_get_voltage_sel(struct regulator_dev *reg)
 {
         struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
-        u32 val;
+        u32 val, mask;
 
         if (!anatop_reg->control_reg)
                 return -ENOTSUPP;
 
         val = anatop_read_reg(anatop_reg->mfd, anatop_reg->control_reg);
-        val = (val & ((1 << anatop_reg->vol_bit_width) - 1)) >>
+        mask = ((1 << anatop_reg->vol_bit_width) - 1) <<
                 anatop_reg->vol_bit_shift;
+        val = (val & mask) >> anatop_reg->vol_bit_shift;
 
         return val - anatop_reg->min_bit_val;
 }
diff --git a/drivers/regulator/arizona-ldo1.c b/drivers/regulator/arizona-ldo1.c
index c8f95c07adb6..d184aa35abcb 100644
--- a/drivers/regulator/arizona-ldo1.c
+++ b/drivers/regulator/arizona-ldo1.c
@@ -39,6 +39,8 @@ static struct regulator_ops arizona_ldo1_ops = {
         .map_voltage = regulator_map_voltage_linear,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_bypass = regulator_get_bypass_regmap,
+        .set_bypass = regulator_set_bypass_regmap,
 };
 
 static const struct regulator_desc arizona_ldo1 = {
@@ -49,9 +51,11 @@ static const struct regulator_desc arizona_ldo1 = {
 
         .vsel_reg = ARIZONA_LDO1_CONTROL_1,
         .vsel_mask = ARIZONA_LDO1_VSEL_MASK,
+        .bypass_reg = ARIZONA_LDO1_CONTROL_1,
+        .bypass_mask = ARIZONA_LDO1_BYPASS,
         .min_uV = 900000,
         .uV_step = 50000,
-        .n_voltages = 7,
+        .n_voltages = 6,
 
         .owner = THIS_MODULE,
 };
diff --git a/drivers/regulator/arizona-micsupp.c b/drivers/regulator/arizona-micsupp.c
index 450a069aa9b6..d9b1f82cc5bd 100644
--- a/drivers/regulator/arizona-micsupp.c
+++ b/drivers/regulator/arizona-micsupp.c
@@ -82,6 +82,9 @@ static struct regulator_ops arizona_micsupp_ops = {
 
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = regulator_set_voltage_sel_regmap,
+
+        .get_bypass = regulator_get_bypass_regmap,
+        .set_bypass = regulator_set_bypass_regmap,
 };
 
 static const struct regulator_desc arizona_micsupp = {
@@ -95,6 +98,8 @@ static const struct regulator_desc arizona_micsupp = {
         .vsel_mask = ARIZONA_LDO2_VSEL_MASK,
         .enable_reg = ARIZONA_MIC_CHARGE_PUMP_1,
         .enable_mask = ARIZONA_CPMIC_ENA,
+        .bypass_reg = ARIZONA_MIC_CHARGE_PUMP_1,
+        .bypass_mask = ARIZONA_CPMIC_BYPASS,
 
         .owner = THIS_MODULE,
 };
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index 03fad8153476..2e0352dc26bd 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -77,6 +77,7 @@ struct regulator {
         struct device *dev;
         struct list_head list;
         unsigned int always_on:1;
+        unsigned int bypass:1;
         int uA_load;
         int min_uV;
         int max_uV;
@@ -394,6 +395,9 @@ static ssize_t regulator_status_show(struct device *dev,
         case REGULATOR_STATUS_STANDBY:
                 label = "standby";
                 break;
+        case REGULATOR_STATUS_BYPASS:
+                label = "bypass";
+                break;
         case REGULATOR_STATUS_UNDEFINED:
                 label = "undefined";
                 break;
@@ -585,6 +589,27 @@ static ssize_t regulator_suspend_standby_state_show(struct device *dev,
 static DEVICE_ATTR(suspend_standby_state, 0444,
                 regulator_suspend_standby_state_show, NULL);
 
+static ssize_t regulator_bypass_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct regulator_dev *rdev = dev_get_drvdata(dev);
+        const char *report;
+        bool bypass;
+        int ret;
+
+        ret = rdev->desc->ops->get_bypass(rdev, &bypass);
+
+        if (ret != 0)
+                report = "unknown";
+        else if (bypass)
+                report = "enabled";
+        else
+                report = "disabled";
+
+        return sprintf(buf, "%s\n", report);
+}
+static DEVICE_ATTR(bypass, 0444,
+                   regulator_bypass_show, NULL);
 
 /*
  * These are the only attributes are present for all regulators.
@@ -2686,6 +2711,100 @@ out:
 EXPORT_SYMBOL_GPL(regulator_set_optimum_mode);
 
 /**
+ * regulator_set_bypass_regmap - Default set_bypass() using regmap
+ *
+ * @rdev: device to operate on.
+ * @enable: state to set.
+ */
+int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
+{
+        unsigned int val;
+
+        if (enable)
+                val = rdev->desc->bypass_mask;
+        else
+                val = 0;
+
+        return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
+                                  rdev->desc->bypass_mask, val);
+}
+EXPORT_SYMBOL_GPL(regulator_set_bypass_regmap);
+
+/**
+ * regulator_get_bypass_regmap - Default get_bypass() using regmap
+ *
+ * @rdev: device to operate on.
+ * @enable: current state.
+ */
+int regulator_get_bypass_regmap(struct regulator_dev *rdev, bool *enable)
+{
+        unsigned int val;
+        int ret;
+
+        ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val);
+        if (ret != 0)
+                return ret;
+
+        *enable = val & rdev->desc->bypass_mask;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(regulator_get_bypass_regmap);
+
+/**
+ * regulator_allow_bypass - allow the regulator to go into bypass mode
+ *
+ * @regulator: Regulator to configure
+ * @allow: enable or disable bypass mode
+ *
+ * Allow the regulator to go into bypass mode if all other consumers
+ * for the regulator also enable bypass mode and the machine
+ * constraints allow this.  Bypass mode means that the regulator is
+ * simply passing the input directly to the output with no regulation.
+ */
+int regulator_allow_bypass(struct regulator *regulator, bool enable)
+{
+        struct regulator_dev *rdev = regulator->rdev;
+        int ret = 0;
+
+        if (!rdev->desc->ops->set_bypass)
+                return 0;
+
+        if (rdev->constraints &&
+            !(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_BYPASS))
+                return 0;
+
+        mutex_lock(&rdev->mutex);
+
+        if (enable && !regulator->bypass) {
+                rdev->bypass_count++;
+
+                if (rdev->bypass_count == rdev->open_count) {
+                        ret = rdev->desc->ops->set_bypass(rdev, enable);
+                        if (ret != 0)
+                                rdev->bypass_count--;
+                }
+
+        } else if (!enable && regulator->bypass) {
+                rdev->bypass_count--;
+
+                if (rdev->bypass_count != rdev->open_count) {
+                        ret = rdev->desc->ops->set_bypass(rdev, enable);
+                        if (ret != 0)
+                                rdev->bypass_count++;
+                }
+        }
+
+        if (ret == 0)
+                regulator->bypass = enable;
+
+        mutex_unlock(&rdev->mutex);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(regulator_allow_bypass);
+
+/**
  * regulator_register_notifier - register regulator event notifier
  * @regulator: regulator source
  * @nb: notifier block
@@ -3049,6 +3168,11 @@ static int add_regulator_attributes(struct regulator_dev *rdev)
                 if (status < 0)
                         return status;
         }
+        if (ops->get_bypass) {
+                status = device_create_file(dev, &dev_attr_bypass);
+                if (status < 0)
+                        return status;
+        }
 
         /* some attributes are type-specific */
         if (rdev->desc->type == REGULATOR_CURRENT) {
@@ -3137,6 +3261,8 @@ static void rdev_init_debugfs(struct regulator_dev *rdev)
                            &rdev->use_count);
         debugfs_create_u32("open_count", 0444, rdev->debugfs,
                            &rdev->open_count);
+        debugfs_create_u32("bypass_count", 0444, rdev->debugfs,
+                           &rdev->bypass_count);
 }
 
 /**
@@ -3232,7 +3358,7 @@ regulator_register(const struct regulator_desc *regulator_desc,
 
         dev_set_drvdata(&rdev->dev, rdev);
 
-        if (config->ena_gpio) {
+        if (config->ena_gpio && gpio_is_valid(config->ena_gpio)) {
                 ret = gpio_request_one(config->ena_gpio,
                                        GPIOF_DIR_OUT | config->ena_gpio_flags,
                                        rdev_get_name(rdev));
diff --git a/drivers/regulator/da9052-regulator.c b/drivers/regulator/da9052-regulator.c
index 903299cf15cf..27355b1199e5 100644
--- a/drivers/regulator/da9052-regulator.c
+++ b/drivers/regulator/da9052-regulator.c
@@ -133,8 +133,8 @@ static int da9052_dcdc_set_current_limit(struct regulator_dev *rdev, int min_uA,
             max_uA < da9052_current_limits[row][DA9052_MIN_UA])
                 return -EINVAL;
 
-        for (i = 0; i < DA9052_CURRENT_RANGE; i++) {
-                if (min_uA <= da9052_current_limits[row][i]) {
+        for (i = DA9052_CURRENT_RANGE - 1; i >= 0; i--) {
+                if (da9052_current_limits[row][i] <= max_uA) {
                         reg_val = i;
                         break;
                 }
diff --git a/drivers/regulator/fan53555.c b/drivers/regulator/fan53555.c
new file mode 100644
index 000000000000..339f4d732e97
--- /dev/null
+++ b/drivers/regulator/fan53555.c
@@ -0,0 +1,322 @@
+/*
+ * FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver.
+ *
+ * Supported Part Numbers:
+ * FAN53555UC00X/01X/03X/04X/05X
+ *
+ * Copyright (c) 2012 Marvell Technology Ltd.
+ * Yunfan Zhang <yfzhang@marvell.com>
+ *
+ * This package 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/param.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/regmap.h>
+#include <linux/regulator/fan53555.h>
+
+/* Voltage setting */
+#define FAN53555_VSEL0          0x00
+#define FAN53555_VSEL1          0x01
+/* Control register */
+#define FAN53555_CONTROL        0x02
+/* IC Type */
+#define FAN53555_ID1            0x03
+/* IC mask version */
+#define FAN53555_ID2            0x04
+/* Monitor register */
+#define FAN53555_MONITOR        0x05
+
+/* VSEL bit definitions */
+#define VSEL_BUCK_EN    (1 << 7)
+#define VSEL_MODE               (1 << 6)
+#define VSEL_NSEL_MASK  0x3F
+/* Chip ID and Verison */
+#define DIE_ID          0x0F    /* ID1 */
+#define DIE_REV         0x0F    /* ID2 */
+/* Control bit definitions */
+#define CTL_OUTPUT_DISCHG       (1 << 7)
+#define CTL_SLEW_MASK           (0x7 << 4)
+#define CTL_SLEW_SHIFT          4
+#define CTL_RESET                       (1 << 2)
+
+#define FAN53555_NVOLTAGES      64      /* Numbers of voltages */
+
+/* IC Type */
+enum {
+        FAN53555_CHIP_ID_00 = 0,
+        FAN53555_CHIP_ID_01,
+        FAN53555_CHIP_ID_02,
+        FAN53555_CHIP_ID_03,
+        FAN53555_CHIP_ID_04,
+        FAN53555_CHIP_ID_05,
+};
+
+struct fan53555_device_info {
+        struct regmap *regmap;
+        struct device *dev;
+        struct regulator_desc desc;
+        struct regulator_dev *rdev;
+        struct regulator_init_data *regulator;
+        /* IC Type and Rev */
+        int chip_id;
+        int chip_rev;
+        /* Voltage setting register */
+        unsigned int vol_reg;
+        unsigned int sleep_reg;
+        /* Voltage range and step(linear) */
+        unsigned int vsel_min;
+        unsigned int vsel_step;
+        /* Voltage slew rate limiting */
+        unsigned int slew_rate;
+        /* Sleep voltage cache */
+        unsigned int sleep_vol_cache;
+};
+
+static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)
+{
+        struct fan53555_device_info *di = rdev_get_drvdata(rdev);
+        int ret;
+
+        if (di->sleep_vol_cache == uV)
+                return 0;
+        ret = regulator_map_voltage_linear(rdev, uV, uV);
+        if (ret < 0)
+                return -EINVAL;
+        ret = regmap_update_bits(di->regmap, di->sleep_reg,
+                                        VSEL_NSEL_MASK, ret);
+        if (ret < 0)
+                return -EINVAL;
+        /* Cache the sleep voltage setting.
+         * Might not be the real voltage which is rounded */
+        di->sleep_vol_cache = uV;
+
+        return 0;
+}
+
+static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode)
+{
+        struct fan53555_device_info *di = rdev_get_drvdata(rdev);
+
+        switch (mode) {
+        case REGULATOR_MODE_FAST:
+                regmap_update_bits(di->regmap, di->vol_reg,
+                                VSEL_MODE, VSEL_MODE);
+                break;
+        case REGULATOR_MODE_NORMAL:
+                regmap_update_bits(di->regmap, di->vol_reg, VSEL_MODE, 0);
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static unsigned int fan53555_get_mode(struct regulator_dev *rdev)
+{
+        struct fan53555_device_info *di = rdev_get_drvdata(rdev);
+        unsigned int val;
+        int ret = 0;
+
+        ret = regmap_read(di->regmap, di->vol_reg, &val);
+        if (ret < 0)
+                return ret;
+        if (val & VSEL_MODE)
+                return REGULATOR_MODE_FAST;
+        else
+                return REGULATOR_MODE_NORMAL;
+}
+
+static struct regulator_ops fan53555_regulator_ops = {
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .map_voltage = regulator_map_voltage_linear,
+        .list_voltage = regulator_list_voltage_linear,
+        .set_suspend_voltage = fan53555_set_suspend_voltage,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .set_mode = fan53555_set_mode,
+        .get_mode = fan53555_get_mode,
+};
+
+/* For 00,01,03,05 options:
+ * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V.
+ * For 04 option:
+ * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V.
+ * */
+static int fan53555_device_setup(struct fan53555_device_info *di,
+                                struct fan53555_platform_data *pdata)
+{
+        unsigned int reg, data, mask;
+
+        /* Setup voltage control register */
+        switch (pdata->sleep_vsel_id) {
+        case FAN53555_VSEL_ID_0:
+                di->sleep_reg = FAN53555_VSEL0;
+                di->vol_reg = FAN53555_VSEL1;
+                break;
+        case FAN53555_VSEL_ID_1:
+                di->sleep_reg = FAN53555_VSEL1;
+                di->vol_reg = FAN53555_VSEL0;
+                break;
+        default:
+                dev_err(di->dev, "Invalid VSEL ID!\n");
+                return -EINVAL;
+        }
+        /* Init voltage range and step */
+        switch (di->chip_id) {
+        case FAN53555_CHIP_ID_00:
+        case FAN53555_CHIP_ID_01:
+        case FAN53555_CHIP_ID_03:
+        case FAN53555_CHIP_ID_05:
+                di->vsel_min = 600000;
+                di->vsel_step = 10000;
+                break;
+        case FAN53555_CHIP_ID_04:
+                di->vsel_min = 603000;
+                di->vsel_step = 12826;
+                break;
+        default:
+                dev_err(di->dev,
+                        "Chip ID[%d]\n not supported!\n", di->chip_id);
+                return -EINVAL;
+        }
+        /* Init slew rate */
+        if (pdata->slew_rate & 0x7)
+                di->slew_rate = pdata->slew_rate;
+        else
+                di->slew_rate = FAN53555_SLEW_RATE_64MV;
+        reg = FAN53555_CONTROL;
+        data = di->slew_rate << CTL_SLEW_SHIFT;
+        mask = CTL_SLEW_MASK;
+        return regmap_update_bits(di->regmap, reg, mask, data);
+}
+
+static int fan53555_regulator_register(struct fan53555_device_info *di,
+                        struct regulator_config *config)
+{
+        struct regulator_desc *rdesc = &di->desc;
+
+        rdesc->name = "fan53555-reg";
+        rdesc->ops = &fan53555_regulator_ops;
+        rdesc->type = REGULATOR_VOLTAGE;
+        rdesc->n_voltages = FAN53555_NVOLTAGES;
+        rdesc->enable_reg = di->vol_reg;
+        rdesc->enable_mask = VSEL_BUCK_EN;
+        rdesc->min_uV = di->vsel_min;
+        rdesc->uV_step = di->vsel_step;
+        rdesc->vsel_reg = di->vol_reg;
+        rdesc->vsel_mask = VSEL_NSEL_MASK;
+        rdesc->owner = THIS_MODULE;
+
+        di->rdev = regulator_register(&di->desc, config);
+        if (IS_ERR(di->rdev))
+                return PTR_ERR(di->rdev);
+        return 0;
+
+}
+
+static struct regmap_config fan53555_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+};
+
+static int __devinit fan53555_regulator_probe(struct i2c_client *client,
+                                const struct i2c_device_id *id)
+{
+        struct fan53555_device_info *di;
+        struct fan53555_platform_data *pdata;
+        struct regulator_config config = { };
+        unsigned int val;
+        int ret;
+
+        pdata = client->dev.platform_data;
+        if (!pdata || !pdata->regulator) {
+                dev_err(&client->dev, "Platform data not found!\n");
+                return -ENODEV;
+        }
+
+        di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
+                                        GFP_KERNEL);
+        if (!di) {
+                dev_err(&client->dev, "Failed to allocate device info data!\n");
+                return -ENOMEM;
+        }
+        di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
+        if (IS_ERR(di->regmap)) {
+                dev_err(&client->dev, "Failed to allocate regmap!\n");
+                return PTR_ERR(di->regmap);
+        }
+        di->dev = &client->dev;
+        di->regulator = pdata->regulator;
+        i2c_set_clientdata(client, di);
+        /* Get chip ID */
+        ret = regmap_read(di->regmap, FAN53555_ID1, &val);
+        if (ret < 0) {
+                dev_err(&client->dev, "Failed to get chip ID!\n");
+                return -ENODEV;
+        }
+        di->chip_id = val & DIE_ID;
+        /* Get chip revision */
+        ret = regmap_read(di->regmap, FAN53555_ID2, &val);
+        if (ret < 0) {
+                dev_err(&client->dev, "Failed to get chip Rev!\n");
+                return -ENODEV;
+        }
+        di->chip_rev = val & DIE_REV;
+        dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n",
+                                di->chip_id, di->chip_rev);
+        /* Device init */
+        ret = fan53555_device_setup(di, pdata);
+        if (ret < 0) {
+                dev_err(&client->dev, "Failed to setup device!\n");
+                return ret;
+        }
+        /* Register regulator */
+        config.dev = di->dev;
+        config.init_data = di->regulator;
+        config.regmap = di->regmap;
+        config.driver_data = di;
+        ret = fan53555_regulator_register(di, &config);
+        if (ret < 0)
+                dev_err(&client->dev, "Failed to register regulator!\n");
+        return ret;
+
+}
+
+static int __devexit fan53555_regulator_remove(struct i2c_client *client)
+{
+        struct fan53555_device_info *di = i2c_get_clientdata(client);
+
+        regulator_unregister(di->rdev);
+        return 0;
+}
+
+static const struct i2c_device_id fan53555_id[] = {
+        {"fan53555", -1},
+        { },
+};
+
+static struct i2c_driver fan53555_regulator_driver = {
+        .driver = {
+                .name = "fan53555-regulator",
+        },
+        .probe = fan53555_regulator_probe,
+        .remove = __devexit_p(fan53555_regulator_remove),
+        .id_table = fan53555_id,
+};
+
+module_i2c_driver(fan53555_regulator_driver);
+
+MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>");
+MODULE_DESCRIPTION("FAN53555 regulator driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c
index 34b67bee9323..8b5944f2d7d1 100644
--- a/drivers/regulator/gpio-regulator.c
+++ b/drivers/regulator/gpio-regulator.c
@@ -57,16 +57,17 @@ static int gpio_regulator_get_value(struct regulator_dev *dev)
         return -EINVAL;
 }
 
-static int gpio_regulator_set_value(struct regulator_dev *dev,
-                                        int min, int max, unsigned *selector)
+static int gpio_regulator_set_voltage(struct regulator_dev *dev,
+                                        int min_uV, int max_uV,
+                                        unsigned *selector)
 {
         struct gpio_regulator_data *data = rdev_get_drvdata(dev);
         int ptr, target = 0, state, best_val = INT_MAX;
 
         for (ptr = 0; ptr < data->nr_states; ptr++)
                 if (data->states[ptr].value < best_val &&
-                    data->states[ptr].value >= min &&
-                    data->states[ptr].value <= max) {
+                    data->states[ptr].value >= min_uV &&
+                    data->states[ptr].value <= max_uV) {
                         target = data->states[ptr].gpios;
                         best_val = data->states[ptr].value;
                         if (selector)
@@ -85,13 +86,6 @@ static int gpio_regulator_set_value(struct regulator_dev *dev,
         return 0;
 }
 
-static int gpio_regulator_set_voltage(struct regulator_dev *dev,
-                                        int min_uV, int max_uV,
-                                        unsigned *selector)
-{
-        return gpio_regulator_set_value(dev, min_uV, max_uV, selector);
-}
-
 static int gpio_regulator_list_voltage(struct regulator_dev *dev,
                                       unsigned selector)
 {
@@ -106,7 +100,27 @@ static int gpio_regulator_list_voltage(struct regulator_dev *dev,
 static int gpio_regulator_set_current_limit(struct regulator_dev *dev,
                                         int min_uA, int max_uA)
 {
-        return gpio_regulator_set_value(dev, min_uA, max_uA, NULL);
+        struct gpio_regulator_data *data = rdev_get_drvdata(dev);
+        int ptr, target = 0, state, best_val = 0;
+
+        for (ptr = 0; ptr < data->nr_states; ptr++)
+                if (data->states[ptr].value > best_val &&
+                    data->states[ptr].value >= min_uA &&
+                    data->states[ptr].value <= max_uA) {
+                        target = data->states[ptr].gpios;
+                        best_val = data->states[ptr].value;
+                }
+
+        if (best_val == 0)
+                return -EINVAL;
+
+        for (ptr = 0; ptr < data->nr_gpios; ptr++) {
+                state = (target & (1 << ptr)) >> ptr;
+                gpio_set_value(data->gpios[ptr].gpio, state);
+        }
+        data->state = target;
+
+        return 0;
 }
 
 static struct regulator_ops gpio_regulator_voltage_ops = {
diff --git a/drivers/regulator/isl6271a-regulator.c b/drivers/regulator/isl6271a-regulator.c
index 1d145a07ada9..d8ecf49a5777 100644
--- a/drivers/regulator/isl6271a-regulator.c
+++ b/drivers/regulator/isl6271a-regulator.c
@@ -73,13 +73,7 @@ static struct regulator_ops isl_core_ops = {
         .map_voltage    = regulator_map_voltage_linear,
 };
 
-static int isl6271a_get_fixed_voltage(struct regulator_dev *dev)
-{
-        return dev->desc->min_uV;
-}
-
 static struct regulator_ops isl_fixed_ops = {
-        .get_voltage    = isl6271a_get_fixed_voltage,
         .list_voltage   = regulator_list_voltage_linear,
 };
 
diff --git a/drivers/regulator/lp872x.c b/drivers/regulator/lp872x.c
index 212c38eaba70..708f4b6a17dc 100644
--- a/drivers/regulator/lp872x.c
+++ b/drivers/regulator/lp872x.c
@@ -86,6 +86,10 @@
 #define EXTERN_DVS_USED                 0
 #define MAX_DELAY                       6
 
+/* Default DVS Mode */
+#define LP8720_DEFAULT_DVS              0
+#define LP8725_DEFAULT_DVS              BIT(2)
+
 /* dump registers in regmap-debugfs */
 #define MAX_REGISTERS                   0x0F
 
@@ -269,9 +273,9 @@ static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
         return val > MAX_DELAY ? 0 : val * time_step_us;
 }
 
-static void lp872x_set_dvs(struct lp872x *lp, int gpio)
+static void lp872x_set_dvs(struct lp872x *lp, enum lp872x_dvs_sel dvs_sel,
+                        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;
@@ -339,10 +343,10 @@ static int lp872x_buck_set_voltage_sel(struct regulator_dev *rdev,
         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;
+        struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
 
         if (dvs && gpio_is_valid(dvs->gpio))
-                lp872x_set_dvs(lp, dvs->gpio);
+                lp872x_set_dvs(lp, dvs->vsel, dvs->gpio);
 
         addr = lp872x_select_buck_vout_addr(lp, buck);
         if (!lp872x_is_valid_buck_addr(addr))
@@ -374,8 +378,8 @@ static int lp8725_buck_set_current_limit(struct regulator_dev *rdev,
 {
         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;
+        int i;
+        u8 addr;
 
         switch (buck) {
         case LP8725_ID_BUCK1:
@@ -388,17 +392,15 @@ static int lp8725_buck_set_current_limit(struct regulator_dev *rdev,
                 return -EINVAL;
         }
 
-        for (i = 0 ; i < max ; i++)
+        for (i = ARRAY_SIZE(lp8725_buck_uA) - 1 ; i >= 0; 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,
+                                                  i << LP8725_BUCK_CL_S);
+        }
 
-        return lp872x_update_bits(lp, addr, LP8725_BUCK_CL_M, val);
+        return -EINVAL;
 }
 
 static int lp8725_buck_get_current_limit(struct regulator_dev *rdev)
@@ -727,39 +729,16 @@ static struct regulator_desc lp8725_regulator_desc[] = {
         },
 };
 
-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;
+        struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
         enum lp872x_dvs_state pinstate;
+        u8 mask[] = { LP8720_EXT_DVS_M, LP8725_DVS1_M | LP8725_DVS2_M };
+        u8 default_dvs_mode[] = { LP8720_DEFAULT_DVS, LP8725_DEFAULT_DVS };
 
-        ret = lp872x_check_dvs_validity(lp);
-        if (ret) {
-                dev_warn(lp->dev, "invalid dvs data: %d\n", ret);
-                return ret;
-        }
+        if (!dvs)
+                goto set_default_dvs_mode;
 
         gpio = dvs->gpio;
         if (!gpio_is_valid(gpio)) {
@@ -778,6 +757,10 @@ static int lp872x_init_dvs(struct lp872x *lp)
         lp->dvs_gpio = gpio;
 
         return 0;
+
+set_default_dvs_mode:
+        return lp872x_update_bits(lp, LP872X_GENERAL_CFG, mask[lp->chipid],
+                                default_dvs_mode[lp->chipid]);
 }
 
 static int lp872x_config(struct lp872x *lp)
@@ -785,24 +768,29 @@ static int lp872x_config(struct lp872x *lp)
         struct lp872x_platform_data *pdata = lp->pdata;
         int ret;
 
-        if (!pdata->update_config)
-                return 0;
+        if (!pdata || !pdata->update_config)
+                goto init_dvs;
 
         ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
         if (ret)
                 return ret;
 
+init_dvs:
         return lp872x_init_dvs(lp);
 }
 
 static struct regulator_init_data
 *lp872x_find_regulator_init_data(int id, struct lp872x *lp)
 {
+        struct lp872x_platform_data *pdata = lp->pdata;
         int i;
 
+        if (!pdata)
+                return NULL;
+
         for (i = 0; i < lp->num_regulators; i++) {
-                if (lp->pdata->regulator_data[i].id == id)
-                        return lp->pdata->regulator_data[i].init_data;
+                if (pdata->regulator_data[i].id == id)
+                        return pdata->regulator_data[i].init_data;
         }
 
         return NULL;
@@ -863,18 +851,12 @@ static const struct regmap_config lp872x_regmap_config = {
 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;
@@ -894,7 +876,7 @@ static int lp872x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
         }
 
         lp->dev = &cl->dev;
-        lp->pdata = pdata;
+        lp->pdata = cl->dev.platform_data;
         lp->chipid = id->driver_data;
         lp->num_regulators = num_regulators;
         i2c_set_clientdata(cl, lp);
diff --git a/drivers/regulator/lp8788-buck.c b/drivers/regulator/lp8788-buck.c
index 6356e821400f..ba3e0aa402de 100644
--- a/drivers/regulator/lp8788-buck.c
+++ b/drivers/regulator/lp8788-buck.c
@@ -69,6 +69,9 @@
 #define PIN_HIGH                        1
 #define ENABLE_TIME_USEC                32
 
+#define BUCK_FPWM_MASK(x)               (1 << (x))
+#define BUCK_FPWM_SHIFT(x)              (x)
+
 enum lp8788_dvs_state {
         DVS_LOW  = GPIOF_OUT_INIT_LOW,
         DVS_HIGH = GPIOF_OUT_INIT_HIGH,
@@ -86,15 +89,9 @@ enum lp8788_buck_id {
         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;
 };
 
@@ -106,29 +103,6 @@ static const int lp8788_buck_vtbl[] = {
         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,
@@ -347,41 +321,37 @@ static int lp8788_buck_enable_time(struct regulator_dev *rdev)
 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;
+        enum lp8788_buck_id id = rdev_get_id(rdev);
+        u8 mask, val;
 
+        mask = BUCK_FPWM_MASK(id);
         switch (mode) {
         case REGULATOR_MODE_FAST:
-                val = LP8788_FORCE_PWM << pmap->shift;
+                val = LP8788_FORCE_PWM << BUCK_FPWM_SHIFT(id);
                 break;
         case REGULATOR_MODE_NORMAL:
-                val = LP8788_AUTO_PWM << pmap->shift;
+                val = LP8788_AUTO_PWM << BUCK_FPWM_SHIFT(id);
                 break;
         default:
                 return -EINVAL;
         }
 
-        return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, pmap->mask, val);
+        return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, 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;
+        enum lp8788_buck_id id = rdev_get_id(rdev);
         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;
+        return val & BUCK_FPWM_MASK(id) ?
+                                REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
 }
 
 static struct regulator_ops lp8788_buck12_ops = {
@@ -459,27 +429,6 @@ static struct regulator_desc lp8788_buck_desc[] = {
         },
 };
 
-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;
@@ -530,6 +479,7 @@ 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 };
+        u8 default_dvs_mode[] = { LP8788_BUCK1_DVS_I2C, LP8788_BUCK2_DVS_I2C };
 
         /* no dvs for buck3, 4 */
         if (id == BUCK3 || id == BUCK4)
@@ -550,7 +500,8 @@ static int lp8788_init_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
                                 val[id]);
 
 set_default_dvs_mode:
-        return lp8788_set_default_dvs_ctrl_mode(buck->lp, id);
+        return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
+                                  default_dvs_mode[id]);
 }
 
 static __devinit int lp8788_buck_probe(struct platform_device *pdev)
@@ -567,7 +518,6 @@ static __devinit int lp8788_buck_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         buck->lp = lp;
-        buck->pmap = &buck_pmap[id];
 
         ret = lp8788_init_dvs(buck, id);
         if (ret)
diff --git a/drivers/regulator/lp8788-ldo.c b/drivers/regulator/lp8788-ldo.c
index d2122e41a96d..6796eeb47dc6 100644
--- a/drivers/regulator/lp8788-ldo.c
+++ b/drivers/regulator/lp8788-ldo.c
@@ -496,6 +496,7 @@ static struct regulator_desc lp8788_dldo_desc[] = {
                 .name = "dldo12",
                 .id = DLDO12,
                 .ops = &lp8788_ldo_voltage_fixed_ops,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
                 .enable_reg = LP8788_EN_LDO_B,
@@ -521,6 +522,7 @@ static struct regulator_desc lp8788_aldo_desc[] = {
                 .name = "aldo2",
                 .id = ALDO2,
                 .ops = &lp8788_ldo_voltage_fixed_ops,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
                 .enable_reg = LP8788_EN_LDO_B,
@@ -530,6 +532,7 @@ static struct regulator_desc lp8788_aldo_desc[] = {
                 .name = "aldo3",
                 .id = ALDO3,
                 .ops = &lp8788_ldo_voltage_fixed_ops,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
                 .enable_reg = LP8788_EN_LDO_B,
@@ -539,6 +542,7 @@ static struct regulator_desc lp8788_aldo_desc[] = {
                 .name = "aldo4",
                 .id = ALDO4,
                 .ops = &lp8788_ldo_voltage_fixed_ops,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
                 .enable_reg = LP8788_EN_LDO_B,
@@ -548,6 +552,7 @@ static struct regulator_desc lp8788_aldo_desc[] = {
                 .name = "aldo5",
                 .id = ALDO5,
                 .ops = &lp8788_ldo_voltage_fixed_ops,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
                 .enable_reg = LP8788_EN_LDO_C,
@@ -583,6 +588,7 @@ static struct regulator_desc lp8788_aldo_desc[] = {
                 .name = "aldo8",
                 .id = ALDO8,
                 .ops = &lp8788_ldo_voltage_fixed_ops,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
                 .enable_reg = LP8788_EN_LDO_C,
@@ -592,6 +598,7 @@ static struct regulator_desc lp8788_aldo_desc[] = {
                 .name = "aldo9",
                 .id = ALDO9,
                 .ops = &lp8788_ldo_voltage_fixed_ops,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
                 .enable_reg = LP8788_EN_LDO_C,
@@ -601,6 +608,7 @@ static struct regulator_desc lp8788_aldo_desc[] = {
                 .name = "aldo10",
                 .id = ALDO10,
                 .ops = &lp8788_ldo_voltage_fixed_ops,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
                 .enable_reg = LP8788_EN_LDO_C,
diff --git a/drivers/regulator/max77686.c b/drivers/regulator/max77686.c
index c564af6f05a3..2a67d08658ad 100644
--- a/drivers/regulator/max77686.c
+++ b/drivers/regulator/max77686.c
@@ -66,7 +66,7 @@ enum max77686_ramp_rate {
 };
 
 struct max77686_data {
-        struct regulator_dev **rdev;
+        struct regulator_dev *rdev[MAX77686_REGULATORS];
 };
 
 static int max77686_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
@@ -265,6 +265,7 @@ static int max77686_pmic_dt_parse_pdata(struct max77686_dev *iodev,
                 rmatch.of_node = NULL;
                 of_regulator_match(iodev->dev, regulators_np, &rmatch, 1);
                 rdata[i].initdata = rmatch.init_data;
+                rdata[i].of_node = rmatch.of_node;
         }
 
         pdata->regulators = rdata;
@@ -283,10 +284,8 @@ 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;
+        int i, ret = 0;
         struct regulator_config config = { };
 
         dev_dbg(&pdev->dev, "%s\n", __func__);
@@ -313,45 +312,38 @@ static __devinit int max77686_pmic_probe(struct platform_device *pdev)
         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;
+                config.of_node = pdata->regulators[i].of_node;
 
-                rdev[i] = regulator_register(&regulators[i], &config);
-                if (IS_ERR(rdev[i])) {
-                        ret = PTR_ERR(rdev[i]);
+                max77686->rdev[i] = regulator_register(&regulators[i], &config);
+                if (IS_ERR(max77686->rdev[i])) {
+                        ret = PTR_ERR(max77686->rdev[i]);
                         dev_err(&pdev->dev,
                                 "regulator init failed for %d\n", i);
-                                rdev[i] = NULL;
-                                goto err;
+                        max77686->rdev[i] = NULL;
+                        goto err;
                 }
         }
 
         return 0;
 err:
         while (--i >= 0)
-                regulator_unregister(rdev[i]);
+                regulator_unregister(max77686->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]);
+                regulator_unregister(max77686->rdev[i]);
 
         return 0;
 }
diff --git a/drivers/regulator/max8907-regulator.c b/drivers/regulator/max8907-regulator.c
new file mode 100644
index 000000000000..af7607515ab9
--- /dev/null
+++ b/drivers/regulator/max8907-regulator.c
@@ -0,0 +1,408 @@
+/*
+ * max8907-regulator.c -- support regulators in max8907
+ *
+ * Copyright (C) 2010 Gyungoh Yoo <jack.yoo@maxim-ic.com>
+ * Copyright (C) 2010-2012, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Portions based on drivers/regulator/tps65910-regulator.c,
+ *     Copyright 2010 Texas Instruments Inc.
+ *     Author: Graeme Gregory <gg@slimlogic.co.uk>
+ *     Author: Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>
+ *
+ * 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/init.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/max8907.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/regulator/of_regulator.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+
+#define MAX8907_II2RR_VERSION_MASK      0xF0
+#define MAX8907_II2RR_VERSION_REV_A     0x00
+#define MAX8907_II2RR_VERSION_REV_B     0x10
+#define MAX8907_II2RR_VERSION_REV_C     0x30
+
+struct max8907_regulator {
+        struct regulator_desc desc[MAX8907_NUM_REGULATORS];
+        struct regulator_dev *rdev[MAX8907_NUM_REGULATORS];
+};
+
+#define REG_MBATT() \
+        [MAX8907_MBATT] = { \
+                .name = "MBATT", \
+                .supply_name = "mbatt", \
+                .id = MAX8907_MBATT, \
+                .ops = &max8907_mbatt_ops, \
+                .type = REGULATOR_VOLTAGE, \
+                .owner = THIS_MODULE, \
+        }
+
+#define REG_LDO(ids, supply, base, min, max, step) \
+        [MAX8907_##ids] = { \
+                .name = #ids, \
+                .supply_name = supply, \
+                .id = MAX8907_##ids, \
+                .n_voltages = ((max) - (min)) / (step) + 1, \
+                .ops = &max8907_ldo_ops, \
+                .type = REGULATOR_VOLTAGE, \
+                .owner = THIS_MODULE, \
+                .min_uV = (min), \
+                .uV_step = (step), \
+                .vsel_reg = (base) + MAX8907_VOUT, \
+                .vsel_mask = 0x3f, \
+                .enable_reg = (base) + MAX8907_CTL, \
+                .enable_mask = MAX8907_MASK_LDO_EN, \
+        }
+
+#define REG_FIXED(ids, supply, voltage) \
+        [MAX8907_##ids] = { \
+                .name = #ids, \
+                .supply_name = supply, \
+                .id = MAX8907_##ids, \
+                .n_voltages = 1, \
+                .ops = &max8907_fixed_ops, \
+                .type = REGULATOR_VOLTAGE, \
+                .owner = THIS_MODULE, \
+                .min_uV = (voltage), \
+        }
+
+#define REG_OUT5V(ids, supply, base, voltage) \
+        [MAX8907_##ids] = { \
+                .name = #ids, \
+                .supply_name = supply, \
+                .id = MAX8907_##ids, \
+                .n_voltages = 1, \
+                .ops = &max8907_out5v_ops, \
+                .type = REGULATOR_VOLTAGE, \
+                .owner = THIS_MODULE, \
+                .min_uV = (voltage), \
+                .enable_reg = (base), \
+                .enable_mask = MAX8907_MASK_OUT5V_EN, \
+        }
+
+#define REG_BBAT(ids, supply, base, min, max, step) \
+        [MAX8907_##ids] = { \
+                .name = #ids, \
+                .supply_name = supply, \
+                .id = MAX8907_##ids, \
+                .n_voltages = ((max) - (min)) / (step) + 1, \
+                .ops = &max8907_bbat_ops, \
+                .type = REGULATOR_VOLTAGE, \
+                .owner = THIS_MODULE, \
+                .min_uV = (min), \
+                .uV_step = (step), \
+                .vsel_reg = (base), \
+                .vsel_mask = MAX8907_MASK_VBBATTCV, \
+        }
+
+#define LDO_750_50(id, supply, base) REG_LDO(id, supply, (base), \
+                        750000, 3900000, 50000)
+#define LDO_650_25(id, supply, base) REG_LDO(id, supply, (base), \
+                        650000, 2225000, 25000)
+
+static struct regulator_ops max8907_mbatt_ops = {
+};
+
+static struct regulator_ops max8907_ldo_ops = {
+        .list_voltage = regulator_list_voltage_linear,
+        .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,
+};
+
+static struct regulator_ops max8907_ldo_hwctl_ops = {
+        .list_voltage = regulator_list_voltage_linear,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+};
+
+static struct regulator_ops max8907_fixed_ops = {
+        .list_voltage = regulator_list_voltage_linear,
+};
+
+static struct regulator_ops max8907_out5v_ops = {
+        .list_voltage = regulator_list_voltage_linear,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+};
+
+static struct regulator_ops max8907_out5v_hwctl_ops = {
+        .list_voltage = regulator_list_voltage_linear,
+};
+
+static struct regulator_ops max8907_bbat_ops = {
+        .list_voltage = regulator_list_voltage_linear,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+};
+
+static struct regulator_desc max8907_regulators[] = {
+        REG_MBATT(),
+        REG_LDO(SD1, "in-v1", MAX8907_REG_SDCTL1, 650000, 2225000, 25000),
+        REG_LDO(SD2, "in-v2", MAX8907_REG_SDCTL2, 637500, 1425000, 12500),
+        REG_LDO(SD3, "in-v3", MAX8907_REG_SDCTL3, 750000, 3900000, 50000),
+        LDO_750_50(LDO1, "in1", MAX8907_REG_LDOCTL1),
+        LDO_650_25(LDO2, "in2", MAX8907_REG_LDOCTL2),
+        LDO_650_25(LDO3, "in3", MAX8907_REG_LDOCTL3),
+        LDO_750_50(LDO4, "in4", MAX8907_REG_LDOCTL4),
+        LDO_750_50(LDO5, "in5", MAX8907_REG_LDOCTL5),
+        LDO_750_50(LDO6, "in6", MAX8907_REG_LDOCTL6),
+        LDO_750_50(LDO7, "in7", MAX8907_REG_LDOCTL7),
+        LDO_750_50(LDO8, "in8", MAX8907_REG_LDOCTL8),
+        LDO_750_50(LDO9, "in9", MAX8907_REG_LDOCTL9),
+        LDO_750_50(LDO10, "in10", MAX8907_REG_LDOCTL10),
+        LDO_750_50(LDO11, "in11", MAX8907_REG_LDOCTL11),
+        LDO_750_50(LDO12, "in12", MAX8907_REG_LDOCTL12),
+        LDO_750_50(LDO13, "in13", MAX8907_REG_LDOCTL13),
+        LDO_750_50(LDO14, "in14", MAX8907_REG_LDOCTL14),
+        LDO_750_50(LDO15, "in15", MAX8907_REG_LDOCTL15),
+        LDO_750_50(LDO16, "in16", MAX8907_REG_LDOCTL16),
+        LDO_650_25(LDO17, "in17", MAX8907_REG_LDOCTL17),
+        LDO_650_25(LDO18, "in18", MAX8907_REG_LDOCTL18),
+        LDO_750_50(LDO19, "in19", MAX8907_REG_LDOCTL19),
+        LDO_750_50(LDO20, "in20", MAX8907_REG_LDOCTL20),
+        REG_OUT5V(OUT5V, "mbatt", MAX8907_REG_OUT5VEN, 5000000),
+        REG_OUT5V(OUT33V, "mbatt",  MAX8907_REG_OUT33VEN, 3300000),
+        REG_BBAT(BBAT, "MBATT", MAX8907_REG_BBAT_CNFG,
+                                                2400000, 3000000, 200000),
+        REG_FIXED(SDBY, "MBATT", 1200000),
+        REG_FIXED(VRTC, "MBATT", 3300000),
+};
+
+#ifdef CONFIG_OF
+
+#define MATCH(_name, _id) \
+        [MAX8907_##_id] = { \
+                .name = #_name, \
+                .driver_data = (void *)&max8907_regulators[MAX8907_##_id], \
+        }
+
+static struct of_regulator_match max8907_matches[] = {
+        MATCH(mbatt, MBATT),
+        MATCH(sd1, SD1),
+        MATCH(sd2, SD2),
+        MATCH(sd3, SD3),
+        MATCH(ldo1, LDO1),
+        MATCH(ldo2, LDO2),
+        MATCH(ldo3, LDO3),
+        MATCH(ldo4, LDO4),
+        MATCH(ldo5, LDO5),
+        MATCH(ldo6, LDO6),
+        MATCH(ldo7, LDO7),
+        MATCH(ldo8, LDO8),
+        MATCH(ldo9, LDO9),
+        MATCH(ldo10, LDO10),
+        MATCH(ldo11, LDO11),
+        MATCH(ldo12, LDO12),
+        MATCH(ldo13, LDO13),
+        MATCH(ldo14, LDO14),
+        MATCH(ldo15, LDO15),
+        MATCH(ldo16, LDO16),
+        MATCH(ldo17, LDO17),
+        MATCH(ldo18, LDO18),
+        MATCH(ldo19, LDO19),
+        MATCH(ldo20, LDO20),
+        MATCH(out5v, OUT5V),
+        MATCH(out33v, OUT33V),
+        MATCH(bbat, BBAT),
+        MATCH(sdby, SDBY),
+        MATCH(vrtc, VRTC),
+};
+
+static int max8907_regulator_parse_dt(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.parent->of_node;
+        struct device_node *regulators;
+        int ret;
+
+        if (!pdev->dev.parent->of_node)
+                return 0;
+
+        regulators = of_find_node_by_name(np, "regulators");
+        if (!regulators) {
+                dev_err(&pdev->dev, "regulators node not found\n");
+                return -EINVAL;
+        }
+
+        ret = of_regulator_match(pdev->dev.parent, regulators,
+                                 max8907_matches,
+                                 ARRAY_SIZE(max8907_matches));
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Error parsing regulator init data: %d\n",
+                        ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static inline struct regulator_init_data *match_init_data(int index)
+{
+        return max8907_matches[index].init_data;
+}
+
+static inline struct device_node *match_of_node(int index)
+{
+        return max8907_matches[index].of_node;
+}
+#else
+static int max8907_regulator_parse_dt(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static inline struct regulator_init_data *match_init_data(int index)
+{
+        return NULL;
+}
+
+static inline struct device_node *match_of_node(int index)
+{
+        return NULL;
+}
+#endif
+
+static __devinit int max8907_regulator_probe(struct platform_device *pdev)
+{
+        struct max8907 *max8907 = dev_get_drvdata(pdev->dev.parent);
+        struct max8907_platform_data *pdata = dev_get_platdata(max8907->dev);
+        int ret;
+        struct max8907_regulator *pmic;
+        unsigned int val;
+        int i;
+        struct regulator_config config = {};
+        struct regulator_init_data *idata;
+        const char *mbatt_rail_name = NULL;
+
+        ret = max8907_regulator_parse_dt(pdev);
+        if (ret)
+                return ret;
+
+        pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
+        if (!pmic) {
+                dev_err(&pdev->dev, "Failed to alloc pmic\n");
+                return -ENOMEM;
+        }
+        platform_set_drvdata(pdev, pmic);
+
+        memcpy(pmic->desc, max8907_regulators, sizeof(pmic->desc));
+
+        /* Backwards compatibility with MAX8907B; SD1 uses different voltages */
+        regmap_read(max8907->regmap_gen, MAX8907_REG_II2RR, &val);
+        if ((val & MAX8907_II2RR_VERSION_MASK) ==
+            MAX8907_II2RR_VERSION_REV_B) {
+                pmic->desc[MAX8907_SD1].min_uV = 637500;
+                pmic->desc[MAX8907_SD1].uV_step = 12500;
+                pmic->desc[MAX8907_SD1].n_voltages =
+                                                (1425000 - 637500) / 12500 + 1;
+        }
+
+        for (i = 0; i < MAX8907_NUM_REGULATORS; i++) {
+                config.dev = pdev->dev.parent;
+                if (pdata)
+                        idata = pdata->init_data[i];
+                else
+                        idata = match_init_data(i);
+                config.init_data = idata;
+                config.driver_data = pmic;
+                config.regmap = max8907->regmap_gen;
+                config.of_node = match_of_node(i);
+
+                switch (pmic->desc[i].id) {
+                case MAX8907_MBATT:
+                        if (idata && idata->constraints.name)
+                                mbatt_rail_name = idata->constraints.name;
+                        else
+                                mbatt_rail_name = pmic->desc[i].name;
+                        break;
+                case MAX8907_BBAT:
+                case MAX8907_SDBY:
+                case MAX8907_VRTC:
+                        idata->supply_regulator = mbatt_rail_name;
+                        break;
+                }
+
+                if (pmic->desc[i].ops == &max8907_ldo_ops) {
+                        regmap_read(config.regmap, pmic->desc[i].enable_reg,
+                                    &val);
+                        if ((val & MAX8907_MASK_LDO_SEQ) !=
+                            MAX8907_MASK_LDO_SEQ)
+                                pmic->desc[i].ops = &max8907_ldo_hwctl_ops;
+                } else if (pmic->desc[i].ops == &max8907_out5v_ops) {
+                        regmap_read(config.regmap, pmic->desc[i].enable_reg,
+                                    &val);
+                        if ((val & (MAX8907_MASK_OUT5V_VINEN |
+                                                MAX8907_MASK_OUT5V_ENSRC)) !=
+                            MAX8907_MASK_OUT5V_ENSRC)
+                                pmic->desc[i].ops = &max8907_out5v_hwctl_ops;
+                }
+
+                pmic->rdev[i] = regulator_register(&pmic->desc[i], &config);
+                if (IS_ERR(pmic->rdev[i])) {
+                        dev_err(&pdev->dev,
+                                "failed to register %s regulator\n",
+                                pmic->desc[i].name);
+                        ret = PTR_ERR(pmic->rdev[i]);
+                        goto err_unregister_regulator;
+                }
+        }
+
+        return 0;
+
+err_unregister_regulator:
+        while (--i >= 0)
+                regulator_unregister(pmic->rdev[i]);
+        return ret;
+}
+
+static __devexit int max8907_regulator_remove(struct platform_device *pdev)
+{
+        struct max8907_regulator *pmic = platform_get_drvdata(pdev);
+        int i;
+
+        for (i = 0; i < MAX8907_NUM_REGULATORS; i++)
+                regulator_unregister(pmic->rdev[i]);
+
+        return 0;
+}
+
+static struct platform_driver max8907_regulator_driver = {
+        .driver = {
+                   .name = "max8907-regulator",
+                   .owner = THIS_MODULE,
+                   },
+        .probe = max8907_regulator_probe,
+        .remove = __devexit_p(max8907_regulator_remove),
+};
+
+static int __init max8907_regulator_init(void)
+{
+        return platform_driver_register(&max8907_regulator_driver);
+}
+
+subsys_initcall(max8907_regulator_init);
+
+static void __exit max8907_reg_exit(void)
+{
+        platform_driver_unregister(&max8907_regulator_driver);
+}
+
+module_exit(max8907_reg_exit);
+
+MODULE_DESCRIPTION("MAX8907 regulator driver");
+MODULE_AUTHOR("Gyungoh Yoo <jack.yoo@maxim-ic.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:max8907-regulator");
diff --git a/drivers/regulator/mc13783-regulator.c b/drivers/regulator/mc13783-regulator.c
index 4932e3449fe1..0801a6d0c122 100644
--- a/drivers/regulator/mc13783-regulator.c
+++ b/drivers/regulator/mc13783-regulator.c
@@ -21,6 +21,30 @@
 #include <linux/module.h>
 #include "mc13xxx.h"
 
+#define MC13783_REG_SWITCHERS0                  24
+/* Enable does not exist for SW1A */
+#define MC13783_REG_SWITCHERS0_SW1AEN                   0
+#define MC13783_REG_SWITCHERS0_SW1AVSEL                 0
+#define MC13783_REG_SWITCHERS0_SW1AVSEL_M               (63 << 0)
+
+#define MC13783_REG_SWITCHERS1                  25
+/* Enable does not exist for SW1B */
+#define MC13783_REG_SWITCHERS1_SW1BEN                   0
+#define MC13783_REG_SWITCHERS1_SW1BVSEL                 0
+#define MC13783_REG_SWITCHERS1_SW1BVSEL_M               (63 << 0)
+
+#define MC13783_REG_SWITCHERS2                  26
+/* Enable does not exist for SW2A */
+#define MC13783_REG_SWITCHERS2_SW2AEN                   0
+#define MC13783_REG_SWITCHERS2_SW2AVSEL                 0
+#define MC13783_REG_SWITCHERS2_SW2AVSEL_M               (63 << 0)
+
+#define MC13783_REG_SWITCHERS3                  27
+/* Enable does not exist for SW2B */
+#define MC13783_REG_SWITCHERS3_SW2BEN                   0
+#define MC13783_REG_SWITCHERS3_SW2BVSEL                 0
+#define MC13783_REG_SWITCHERS3_SW2BVSEL_M               (63 << 0)
+
 #define MC13783_REG_SWITCHERS5                  29
 #define MC13783_REG_SWITCHERS5_SW3EN                    (1 << 20)
 #define MC13783_REG_SWITCHERS5_SW3VSEL                  18
@@ -93,6 +117,44 @@
 
 
 /* Voltage Values */
+static const int mc13783_sw1x_val[] = {
+        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, 1575000,
+        1600000, 1625000, 1650000, 1675000,
+        1700000, 1700000, 1700000, 1700000,
+        1800000, 1800000, 1800000, 1800000,
+        1850000, 1850000, 1850000, 1850000,
+        2000000, 2000000, 2000000, 2000000,
+        2100000, 2100000, 2100000, 2100000,
+        2200000, 2200000, 2200000, 2200000,
+        2200000, 2200000, 2200000, 2200000,
+        2200000, 2200000, 2200000, 2200000,
+};
+
+static const int mc13783_sw2x_val[] = {
+        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, 1575000,
+        1600000, 1625000, 1650000, 1675000,
+        1700000, 1700000, 1700000, 1700000,
+        1800000, 1800000, 1800000, 1800000,
+        1900000, 1900000, 1900000, 1900000,
+        2000000, 2000000, 2000000, 2000000,
+        2100000, 2100000, 2100000, 2100000,
+        2200000, 2200000, 2200000, 2200000,
+        2200000, 2200000, 2200000, 2200000,
+        2200000, 2200000, 2200000, 2200000,
+};
+
 static const unsigned int mc13783_sw3_val[] = {
         5000000, 5000000, 5000000, 5500000,
 };
@@ -188,6 +250,10 @@ static struct regulator_ops mc13783_gpo_regulator_ops;
         MC13783_DEFINE(REG, _name, _reg, _vsel_reg, _voltages)
 
 static struct mc13xxx_regulator mc13783_regulators[] = {
+        MC13783_DEFINE_SW(SW1A, SWITCHERS0, SWITCHERS0, mc13783_sw1x_val),
+        MC13783_DEFINE_SW(SW1B, SWITCHERS1, SWITCHERS1, mc13783_sw1x_val),
+        MC13783_DEFINE_SW(SW2A, SWITCHERS2, SWITCHERS2, mc13783_sw2x_val),
+        MC13783_DEFINE_SW(SW2B, SWITCHERS3, SWITCHERS3, mc13783_sw2x_val),
         MC13783_DEFINE_SW(SW3, SWITCHERS5, SWITCHERS5, mc13783_sw3_val),
 
         MC13783_FIXED_DEFINE(REG, VAUDIO, REGULATORMODE0, mc13783_vaudio_val),
@@ -238,9 +304,10 @@ static int mc13783_powermisc_rmw(struct mc13xxx_regulator_priv *priv, u32 mask,
 
         BUG_ON(val & ~mask);
 
+        mc13xxx_lock(priv->mc13xxx);
         ret = mc13xxx_reg_read(mc13783, MC13783_REG_POWERMISC, &valread);
         if (ret)
-                return ret;
+                goto out;
 
         /* Update the stored state for Power Gates. */
         priv->powermisc_pwgt_state =
@@ -253,7 +320,10 @@ static int mc13783_powermisc_rmw(struct mc13xxx_regulator_priv *priv, u32 mask,
         valread = (valread & ~MC13783_REG_POWERMISC_PWGTSPI_M) |
                                                 priv->powermisc_pwgt_state;
 
-        return mc13xxx_reg_write(mc13783, MC13783_REG_POWERMISC, valread);
+        ret = mc13xxx_reg_write(mc13783, MC13783_REG_POWERMISC, valread);
+out:
+        mc13xxx_unlock(priv->mc13xxx);
+        return ret;
 }
 
 static int mc13783_gpo_regulator_enable(struct regulator_dev *rdev)
@@ -261,7 +331,6 @@ static int mc13783_gpo_regulator_enable(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);
-        int ret;
         u32 en_val = mc13xxx_regulators[id].enable_bit;
 
         dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
@@ -271,12 +340,8 @@ static int mc13783_gpo_regulator_enable(struct regulator_dev *rdev)
             id == MC13783_REG_PWGT2SPI)
                 en_val = 0;
 
-        mc13xxx_lock(priv->mc13xxx);
-        ret = mc13783_powermisc_rmw(priv, mc13xxx_regulators[id].enable_bit,
+        return mc13783_powermisc_rmw(priv, mc13xxx_regulators[id].enable_bit,
                                         en_val);
-        mc13xxx_unlock(priv->mc13xxx);
-
-        return ret;
 }
 
 static int mc13783_gpo_regulator_disable(struct regulator_dev *rdev)
@@ -284,7 +349,6 @@ static int mc13783_gpo_regulator_disable(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);
-        int ret;
         u32 dis_val = 0;
 
         dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
@@ -294,12 +358,8 @@ static int mc13783_gpo_regulator_disable(struct regulator_dev *rdev)
             id == MC13783_REG_PWGT2SPI)
                 dis_val = mc13xxx_regulators[id].enable_bit;
 
-        mc13xxx_lock(priv->mc13xxx);
-        ret = mc13783_powermisc_rmw(priv, mc13xxx_regulators[id].enable_bit,
+        return mc13783_powermisc_rmw(priv, mc13xxx_regulators[id].enable_bit,
                                         dis_val);
-        mc13xxx_unlock(priv->mc13xxx);
-
-        return ret;
 }
 
 static int mc13783_gpo_regulator_is_enabled(struct regulator_dev *rdev)
@@ -330,7 +390,6 @@ static struct regulator_ops mc13783_gpo_regulator_ops = {
         .is_enabled = mc13783_gpo_regulator_is_enabled,
         .list_voltage = regulator_list_voltage_table,
         .set_voltage = mc13xxx_fixed_regulator_set_voltage,
-        .get_voltage = mc13xxx_fixed_regulator_get_voltage,
 };
 
 static int __devinit mc13783_regulator_probe(struct platform_device *pdev)
diff --git a/drivers/regulator/mc13892-regulator.c b/drivers/regulator/mc13892-regulator.c
index b388b746452e..1fa63812f7ac 100644
--- a/drivers/regulator/mc13892-regulator.c
+++ b/drivers/regulator/mc13892-regulator.c
@@ -305,9 +305,10 @@ static int mc13892_powermisc_rmw(struct mc13xxx_regulator_priv *priv, u32 mask,
 
         BUG_ON(val & ~mask);
 
+        mc13xxx_lock(priv->mc13xxx);
         ret = mc13xxx_reg_read(mc13892, MC13892_POWERMISC, &valread);
         if (ret)
-                return ret;
+                goto out;
 
         /* Update the stored state for Power Gates. */
         priv->powermisc_pwgt_state =
@@ -320,14 +321,16 @@ static int mc13892_powermisc_rmw(struct mc13xxx_regulator_priv *priv, u32 mask,
         valread = (valread & ~MC13892_POWERMISC_PWGTSPI_M) |
                 priv->powermisc_pwgt_state;
 
-        return mc13xxx_reg_write(mc13892, MC13892_POWERMISC, valread);
+        ret = mc13xxx_reg_write(mc13892, MC13892_POWERMISC, valread);
+out:
+        mc13xxx_unlock(priv->mc13xxx);
+        return ret;
 }
 
 static int mc13892_gpo_regulator_enable(struct regulator_dev *rdev)
 {
         struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
         int id = rdev_get_id(rdev);
-        int ret;
         u32 en_val = mc13892_regulators[id].enable_bit;
         u32 mask = mc13892_regulators[id].enable_bit;
 
@@ -340,18 +343,13 @@ static int mc13892_gpo_regulator_enable(struct regulator_dev *rdev)
         if (id == MC13892_GPO4)
                 mask |= MC13892_POWERMISC_GPO4ADINEN;
 
-        mc13xxx_lock(priv->mc13xxx);
-        ret = mc13892_powermisc_rmw(priv, mask, en_val);
-        mc13xxx_unlock(priv->mc13xxx);
-
-        return ret;
+        return mc13892_powermisc_rmw(priv, mask, en_val);
 }
 
 static int mc13892_gpo_regulator_disable(struct regulator_dev *rdev)
 {
         struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
         int id = rdev_get_id(rdev);
-        int ret;
         u32 dis_val = 0;
 
         dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
@@ -360,12 +358,8 @@ static int mc13892_gpo_regulator_disable(struct regulator_dev *rdev)
         if (id == MC13892_PWGT1SPI || id == MC13892_PWGT2SPI)
                 dis_val = mc13892_regulators[id].enable_bit;
 
-        mc13xxx_lock(priv->mc13xxx);
-        ret = mc13892_powermisc_rmw(priv, mc13892_regulators[id].enable_bit,
+        return mc13892_powermisc_rmw(priv, mc13892_regulators[id].enable_bit,
                 dis_val);
-        mc13xxx_unlock(priv->mc13xxx);
-
-        return ret;
 }
 
 static int mc13892_gpo_regulator_is_enabled(struct regulator_dev *rdev)
@@ -396,14 +390,13 @@ static struct regulator_ops mc13892_gpo_regulator_ops = {
         .is_enabled = mc13892_gpo_regulator_is_enabled,
         .list_voltage = regulator_list_voltage_table,
         .set_voltage = mc13xxx_fixed_regulator_set_voltage,
-        .get_voltage = mc13xxx_fixed_regulator_get_voltage,
 };
 
-static int mc13892_sw_regulator_get_voltage(struct regulator_dev *rdev)
+static int mc13892_sw_regulator_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
         int ret, id = rdev_get_id(rdev);
-        unsigned int val, hi;
+        unsigned int val;
 
         dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
 
@@ -414,17 +407,11 @@ static int mc13892_sw_regulator_get_voltage(struct regulator_dev *rdev)
         if (ret)
                 return ret;
 
-        hi  = val & MC13892_SWITCHERS0_SWxHI;
         val = (val & mc13892_regulators[id].vsel_mask)
                 >> mc13892_regulators[id].vsel_shift;
 
         dev_dbg(rdev_get_dev(rdev), "%s id: %d val: %d\n", __func__, id, val);
 
-        if (hi)
-                val = (25000 * val) + 1100000;
-        else
-                val = (25000 * val) + 600000;
-
         return val;
 }
 
@@ -432,37 +419,25 @@ static int mc13892_sw_regulator_set_voltage_sel(struct regulator_dev *rdev,
                                                 unsigned selector)
 {
         struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
-        int hi, value, mask, id = rdev_get_id(rdev);
-        u32 valread;
+        int volt, mask, id = rdev_get_id(rdev);
+        u32 reg_value;
         int ret;
 
-        value = rdev->desc->volt_table[selector];
+        volt = rdev->desc->volt_table[selector];
+        mask = mc13892_regulators[id].vsel_mask;
+        reg_value = selector << mc13892_regulators[id].vsel_shift;
+
+        if (volt > 1375000) {
+                mask |= MC13892_SWITCHERS0_SWxHI;
+                reg_value |= MC13892_SWITCHERS0_SWxHI;
+        } else if (volt < 1100000) {
+                mask |= MC13892_SWITCHERS0_SWxHI;
+                reg_value &= ~MC13892_SWITCHERS0_SWxHI;
+        }
 
         mc13xxx_lock(priv->mc13xxx);
-        ret = mc13xxx_reg_read(priv->mc13xxx,
-                mc13892_regulators[id].vsel_reg, &valread);
-        if (ret)
-                goto err;
-
-        if (value > 1375000)
-                hi = 1;
-        else if (value < 1100000)
-                hi = 0;
-        else
-                hi = valread & MC13892_SWITCHERS0_SWxHI;
-
-        if (hi) {
-                value = (value - 1100000) / 25000;
-                value |= MC13892_SWITCHERS0_SWxHI;
-        } else
-                value = (value - 600000) / 25000;
-
-        mask = mc13892_regulators[id].vsel_mask | MC13892_SWITCHERS0_SWxHI;
-        valread = (valread & ~mask) |
-                        (value << mc13892_regulators[id].vsel_shift);
-        ret = mc13xxx_reg_write(priv->mc13xxx, mc13892_regulators[id].vsel_reg,
-                        valread);
-err:
+        ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13892_regulators[id].reg, mask,
+                              reg_value);
         mc13xxx_unlock(priv->mc13xxx);
 
         return ret;
@@ -471,7 +446,7 @@ err:
 static struct regulator_ops mc13892_sw_regulator_ops = {
         .list_voltage = regulator_list_voltage_table,
         .set_voltage_sel = mc13892_sw_regulator_set_voltage_sel,
-        .get_voltage = mc13892_sw_regulator_get_voltage,
+        .get_voltage_sel = mc13892_sw_regulator_get_voltage_sel,
 };
 
 static int mc13892_vcam_set_mode(struct regulator_dev *rdev, unsigned int mode)
diff --git a/drivers/regulator/mc13xxx-regulator-core.c b/drivers/regulator/mc13xxx-regulator-core.c
index d6eda28ca5d0..88cbb832d555 100644
--- a/drivers/regulator/mc13xxx-regulator-core.c
+++ b/drivers/regulator/mc13xxx-regulator-core.c
@@ -143,30 +143,21 @@ int mc13xxx_fixed_regulator_set_voltage(struct regulator_dev *rdev, int min_uV,
                 __func__, id, min_uV, max_uV);
 
         if (min_uV <= rdev->desc->volt_table[0] &&
-            rdev->desc->volt_table[0] <= max_uV)
+            rdev->desc->volt_table[0] <= max_uV) {
+                *selector = 0;
                 return 0;
-        else
+        } else {
                 return -EINVAL;
+        }
 }
 EXPORT_SYMBOL_GPL(mc13xxx_fixed_regulator_set_voltage);
 
-int mc13xxx_fixed_regulator_get_voltage(struct regulator_dev *rdev)
-{
-        int id = rdev_get_id(rdev);
-
-        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
-
-        return rdev->desc->volt_table[0];
-}
-EXPORT_SYMBOL_GPL(mc13xxx_fixed_regulator_get_voltage);
-
 struct regulator_ops mc13xxx_fixed_regulator_ops = {
         .enable = mc13xxx_regulator_enable,
         .disable = mc13xxx_regulator_disable,
         .is_enabled = mc13xxx_regulator_is_enabled,
         .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);
 
diff --git a/drivers/regulator/mc13xxx.h b/drivers/regulator/mc13xxx.h
index eaff5510b6df..06c8903f182a 100644
--- a/drivers/regulator/mc13xxx.h
+++ b/drivers/regulator/mc13xxx.h
@@ -34,7 +34,6 @@ struct mc13xxx_regulator_priv {
 
 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);
 
 #ifdef CONFIG_OF
 extern int mc13xxx_get_num_regulators_dt(struct platform_device *pdev);
diff --git a/drivers/regulator/of_regulator.c b/drivers/regulator/of_regulator.c
index 3e4106f2bda9..6f684916fd79 100644
--- a/drivers/regulator/of_regulator.c
+++ b/drivers/regulator/of_regulator.c
@@ -92,16 +92,18 @@ 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 when node
- * property "regulator-compatible" matches with the regulator name.
+ * of_regulator_match - extract multiple regulator init data from device tree.
  * @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  if
- * regulator-compatible matches. Note that the match table is modified
+ * This function uses a match table specified by the regulator driver to
+ * parse regulator init data from the device tree. @node is expected to
+ * contain a set of child nodes, each providing the init data for one
+ * regulator. The data parsed from a child node will be matched to a regulator
+ * based on either the deprecated property regulator-compatible if present,
+ * or otherwise the child node's name. Note that the match table is modified
  * in place.
  *
  * Returns the number of matches found or a negative error code on failure.
@@ -112,26 +114,23 @@ int of_regulator_match(struct device *dev, struct device_node *node,
 {
         unsigned int count = 0;
         unsigned int i;
-        const char *regulator_comp;
+        const char *name;
         struct device_node *child;
 
         if (!dev || !node)
                 return -EINVAL;
 
         for_each_child_of_node(node, child) {
-                regulator_comp = of_get_property(child,
+                name = of_get_property(child,
                                         "regulator-compatible", NULL);
-                if (!regulator_comp) {
-                        dev_err(dev, "regulator-compatible is missing for node %s\n",
-                                child->name);
-                        continue;
-                }
+                if (!name)
+                        name = child->name;
                 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))
+                        if (strcmp(match->name, name))
                                 continue;
 
                         match->init_data =
diff --git a/drivers/regulator/palmas-regulator.c b/drivers/regulator/palmas-regulator.c
index 17d19fbbc490..2ba7502fa3b2 100644
--- a/drivers/regulator/palmas-regulator.c
+++ b/drivers/regulator/palmas-regulator.c
@@ -443,52 +443,17 @@ static int palmas_list_voltage_ldo(struct regulator_dev *dev,
         return  850000 + (selector * 50000);
 }
 
-static int palmas_get_voltage_ldo_sel(struct regulator_dev *dev)
-{
-        struct palmas_pmic *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev);
-        int selector;
-        unsigned int reg;
-        unsigned int addr;
-
-        addr = palmas_regs_info[id].vsel_addr;
-
-        palmas_ldo_read(pmic->palmas, addr, &reg);
-
-        selector = reg & PALMAS_LDO1_VOLTAGE_VSEL_MASK;
-
-        /* Adjust selector to match list_voltage ranges */
-        if (selector > 49)
-                selector = 49;
-
-        return selector;
-}
-
-static int palmas_set_voltage_ldo_sel(struct regulator_dev *dev,
-                unsigned selector)
-{
-        struct palmas_pmic *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev);
-        unsigned int reg = 0;
-        unsigned int addr;
-
-        addr = palmas_regs_info[id].vsel_addr;
-
-        reg = selector;
-
-        palmas_ldo_write(pmic->palmas, addr, reg);
-
-        return 0;
-}
-
 static int palmas_map_voltage_ldo(struct regulator_dev *rdev,
                 int min_uV, int max_uV)
 {
         int ret, voltage;
 
-        ret = ((min_uV - 900000) / 50000) + 1;
-        if (ret < 0)
-                return ret;
+        if (min_uV == 0)
+                return 0;
+
+        if (min_uV < 900000)
+                min_uV = 900000;
+        ret = DIV_ROUND_UP(min_uV - 900000, 50000) + 1;
 
         /* Map back into a voltage to verify we're still in bounds */
         voltage = palmas_list_voltage_ldo(rdev, ret);
@@ -502,8 +467,8 @@ static struct regulator_ops palmas_ops_ldo = {
         .is_enabled             = palmas_is_enabled_ldo,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
-        .get_voltage_sel        = palmas_get_voltage_ldo_sel,
-        .set_voltage_sel        = palmas_set_voltage_ldo_sel,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .list_voltage           = palmas_list_voltage_ldo,
         .map_voltage            = palmas_map_voltage_ldo,
 };
@@ -586,7 +551,7 @@ static int palmas_ldo_init(struct palmas *palmas, int id,
 
         addr = palmas_regs_info[id].ctrl_addr;
 
-        ret = palmas_smps_read(palmas, addr, &reg);
+        ret = palmas_ldo_read(palmas, addr, &reg);
         if (ret)
                 return ret;
 
@@ -596,7 +561,7 @@ static int palmas_ldo_init(struct palmas *palmas, int id,
         if (reg_init->mode_sleep)
                 reg |= PALMAS_LDO1_CTRL_MODE_SLEEP;
 
-        ret = palmas_smps_write(palmas, addr, reg);
+        ret = palmas_ldo_write(palmas, addr, reg);
         if (ret)
                 return ret;
 
@@ -630,7 +595,7 @@ static __devinit int palmas_probe(struct platform_device *pdev)
 
         ret = palmas_smps_read(palmas, PALMAS_SMPS_CTRL, &reg);
         if (ret)
-                goto err_unregister_regulator;
+                return ret;
 
         if (reg & PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN)
                 pmic->smps123 = 1;
@@ -676,7 +641,9 @@ static __devinit int palmas_probe(struct platform_device *pdev)
                 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;
+                        pmic->desc[id].vsel_reg =
+                                        PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
+                                                        PALMAS_SMPS10_CTRL);
                         pmic->desc[id].vsel_mask = SMPS10_VSEL;
                         pmic->desc[id].enable_reg =
                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
@@ -752,6 +719,9 @@ static __devinit int palmas_probe(struct platform_device *pdev)
 
                 pmic->desc[id].type = REGULATOR_VOLTAGE;
                 pmic->desc[id].owner = THIS_MODULE;
+                pmic->desc[id].vsel_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
+                                                palmas_regs_info[id].vsel_addr);
+                pmic->desc[id].vsel_mask = PALMAS_LDO1_VOLTAGE_VSEL_MASK;
                 pmic->desc[id].enable_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
                                                 palmas_regs_info[id].ctrl_addr);
                 pmic->desc[id].enable_mask = PALMAS_LDO1_CTRL_MODE_ACTIVE;
@@ -778,8 +748,10 @@ static __devinit int palmas_probe(struct platform_device *pdev)
                         reg_init = pdata->reg_init[id];
                         if (reg_init) {
                                 ret = palmas_ldo_init(palmas, id, reg_init);
-                                if (ret)
+                                if (ret) {
+                                        regulator_unregister(pmic->rdev[id]);
                                         goto err_unregister_regulator;
+                                }
                         }
                 }
         }
diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
index 4669dc9ac74a..926f9c8f2fac 100644
--- a/drivers/regulator/s2mps11.c
+++ b/drivers/regulator/s2mps11.c
@@ -24,7 +24,7 @@
 #include <linux/mfd/samsung/s2mps11.h>
 
 struct s2mps11_info {
-        struct regulator_dev **rdev;
+        struct regulator_dev *rdev[S2MPS11_REGULATOR_MAX];
 
         int ramp_delay2;
         int ramp_delay34;
@@ -236,9 +236,8 @@ 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;
+        int i, ret;
         unsigned char ramp_enable, ramp_reg = 0;
 
         if (!pdata) {
@@ -251,13 +250,6 @@ static __devinit int s2mps11_pmic_probe(struct platform_device *pdev)
         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;
@@ -297,12 +289,12 @@ static __devinit int s2mps11_pmic_probe(struct platform_device *pdev)
                 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]);
+                s2mps11->rdev[i] = regulator_register(&regulators[i], &config);
+                if (IS_ERR(s2mps11->rdev[i])) {
+                        ret = PTR_ERR(s2mps11->rdev[i]);
                         dev_err(&pdev->dev, "regulator init failed for %d\n",
                                 i);
-                        rdev[i] = NULL;
+                        s2mps11->rdev[i] = NULL;
                         goto err;
                 }
         }
@@ -310,8 +302,7 @@ static __devinit int s2mps11_pmic_probe(struct platform_device *pdev)
         return 0;
 err:
         for (i = 0; i < S2MPS11_REGULATOR_MAX; i++)
-                if (rdev[i])
-                        regulator_unregister(rdev[i]);
+                regulator_unregister(s2mps11->rdev[i]);
 
         return ret;
 }
@@ -319,12 +310,10 @@ err:
 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]);
+                regulator_unregister(s2mps11->rdev[i]);
 
         return 0;
 }
diff --git a/drivers/regulator/tps65217-regulator.c b/drivers/regulator/tps65217-regulator.c
index 6caa222af77a..ab00cab905b7 100644
--- a/drivers/regulator/tps65217-regulator.c
+++ b/drivers/regulator/tps65217-regulator.c
@@ -22,6 +22,7 @@
 #include <linux/err.h>
 #include <linux/platform_device.h>
 
+#include <linux/regulator/of_regulator.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
 #include <linux/mfd/tps65217.h>
@@ -281,37 +282,130 @@ static const struct regulator_desc regulators[] = {
                            NULL),
 };
 
+#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 platform_device *pdev)
+{
+        struct tps65217 *tps = dev_get_drvdata(pdev->dev.parent);
+        struct device_node *node = tps->dev->of_node;
+        struct tps65217_board *pdata;
+        struct device_node *regs;
+        int i, count;
+
+        regs = of_find_node_by_name(node, "regulators");
+        if (!regs)
+                return NULL;
+
+        count = of_regulator_match(pdev->dev.parent, regs,
+                                reg_matches, TPS65217_NUM_REGULATOR);
+        of_node_put(regs);
+        if ((count < 0) || (count > TPS65217_NUM_REGULATOR))
+                return NULL;
+
+        pdata = devm_kzalloc(&pdev->dev, 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;
+}
+#else
+static struct tps65217_board *tps65217_parse_dt(struct platform_device *pdev)
+{
+        return NULL;
+}
+#endif
+
 static int __devinit tps65217_regulator_probe(struct platform_device *pdev)
 {
+        struct tps65217 *tps = dev_get_drvdata(pdev->dev.parent);
+        struct tps65217_board *pdata = dev_get_platdata(tps->dev);
+        struct regulator_init_data *reg_data;
         struct regulator_dev *rdev;
-        struct tps65217 *tps;
-        struct tps_info *info = &tps65217_pmic_regs[pdev->id];
         struct regulator_config config = { };
+        int i, ret;
 
-        /* Already set by core driver */
-        tps = dev_to_tps65217(pdev->dev.parent);
-        tps->info[pdev->id] = info;
+        if (tps->dev->of_node)
+                pdata = tps65217_parse_dt(pdev);
 
-        config.dev = &pdev->dev;
-        config.of_node = pdev->dev.of_node;
-        config.init_data = pdev->dev.platform_data;
-        config.driver_data = tps;
+        if (!pdata) {
+                dev_err(&pdev->dev, "Platform data not found\n");
+                return -EINVAL;
+        }
 
-        rdev = regulator_register(&regulators[pdev->id], &config);
-        if (IS_ERR(rdev))
-                return PTR_ERR(rdev);
+        if (tps65217_chip_id(tps) != TPS65217) {
+                dev_err(&pdev->dev, "Invalid tps chip version\n");
+                return -ENODEV;
+        }
 
-        platform_set_drvdata(pdev, rdev);
+        platform_set_drvdata(pdev, tps);
 
+        for (i = 0; i < TPS65217_NUM_REGULATOR; i++) {
+
+                reg_data = pdata->tps65217_init_data[i];
+
+                /*
+                 * Regulator API handles empty constraints but not NULL
+                 * constraints
+                 */
+                if (!reg_data)
+                        continue;
+
+                /* Register the regulators */
+                tps->info[i] = &tps65217_pmic_regs[i];
+
+                config.dev = tps->dev;
+                config.init_data = reg_data;
+                config.driver_data = tps;
+                config.regmap = tps->regmap;
+                if (tps->dev->of_node)
+                        config.of_node = pdata->of_node[i];
+
+                rdev = regulator_register(&regulators[i], &config);
+                if (IS_ERR(rdev)) {
+                        dev_err(tps->dev, "failed to register %s regulator\n",
+                                pdev->name);
+                        ret = PTR_ERR(rdev);
+                        goto err_unregister_regulator;
+                }
+
+                /* Save regulator for cleanup */
+                tps->rdev[i] = rdev;
+        }
         return 0;
+
+err_unregister_regulator:
+        while (--i >= 0)
+                regulator_unregister(tps->rdev[i]);
+
+        return ret;
 }
 
 static int __devexit tps65217_regulator_remove(struct platform_device *pdev)
 {
-        struct regulator_dev *rdev = platform_get_drvdata(pdev);
+        struct tps65217 *tps = platform_get_drvdata(pdev);
+        unsigned int i;
+
+        for (i = 0; i < TPS65217_NUM_REGULATOR; i++)
+                regulator_unregister(tps->rdev[i]);
 
         platform_set_drvdata(pdev, NULL);
-        regulator_unregister(rdev);
 
         return 0;
 }
diff --git a/drivers/regulator/tps6524x-regulator.c b/drivers/regulator/tps6524x-regulator.c
index 947ece933d90..058d2f2675e9 100644
--- a/drivers/regulator/tps6524x-regulator.c
+++ b/drivers/regulator/tps6524x-regulator.c
@@ -502,15 +502,13 @@ static int set_current_limit(struct regulator_dev *rdev, int min_uA,
         if (info->n_ilimsels == 1)
                 return -EINVAL;
 
-        for (i = 0; i < info->n_ilimsels; i++)
+        for (i = info->n_ilimsels - 1; i >= 0; i--) {
                 if (min_uA <= info->ilimsels[i] &&
                     max_uA >= info->ilimsels[i])
-                        break;
-
-        if (i >= info->n_ilimsels)
-                return -EINVAL;
+                        return write_field(hw, &info->ilimsel, i);
+        }
 
-        return write_field(hw, &info->ilimsel, i);
+        return -EINVAL;
 }
 
 static int get_current_limit(struct regulator_dev *rdev)
diff --git a/drivers/regulator/tps6586x-regulator.c b/drivers/regulator/tps6586x-regulator.c
index e6da90ab5153..ce1e7cb8d513 100644
--- a/drivers/regulator/tps6586x-regulator.c
+++ b/drivers/regulator/tps6586x-regulator.c
@@ -57,9 +57,6 @@
 struct tps6586x_regulator {
         struct regulator_desc desc;
 
-        int volt_reg;
-        int volt_shift;
-        int volt_nbits;
         int enable_bit[2];
         int enable_reg[2];
 
@@ -81,10 +78,10 @@ static int tps6586x_set_voltage_sel(struct regulator_dev *rdev,
         int ret, val, rid = rdev_get_id(rdev);
         uint8_t mask;
 
-        val = selector << ri->volt_shift;
-        mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
+        val = selector << (ffs(rdev->desc->vsel_mask) - 1);
+        mask = rdev->desc->vsel_mask;
 
-        ret = tps6586x_update(parent, ri->volt_reg, val, mask);
+        ret = tps6586x_update(parent, rdev->desc->vsel_reg, val, mask);
         if (ret)
                 return ret;
 
@@ -100,66 +97,17 @@ static int tps6586x_set_voltage_sel(struct regulator_dev *rdev,
         return ret;
 }
 
-static int tps6586x_get_voltage_sel(struct regulator_dev *rdev)
-{
-        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
-        struct device *parent = to_tps6586x_dev(rdev);
-        uint8_t val, mask;
-        int ret;
-
-        ret = tps6586x_read(parent, ri->volt_reg, &val);
-        if (ret)
-                return ret;
-
-        mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
-        val = (val & mask) >> ri->volt_shift;
-
-        if (val >= ri->desc.n_voltages)
-                BUG();
-
-        return val;
-}
-
-static int tps6586x_regulator_enable(struct regulator_dev *rdev)
-{
-        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
-        struct device *parent = to_tps6586x_dev(rdev);
-
-        return tps6586x_set_bits(parent, ri->enable_reg[0],
-                                 1 << ri->enable_bit[0]);
-}
-
-static int tps6586x_regulator_disable(struct regulator_dev *rdev)
-{
-        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
-        struct device *parent = to_tps6586x_dev(rdev);
-
-        return tps6586x_clr_bits(parent, ri->enable_reg[0],
-                                 1 << ri->enable_bit[0]);
-}
-
-static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev)
-{
-        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
-        struct device *parent = to_tps6586x_dev(rdev);
-        uint8_t reg_val;
-        int ret;
-
-        ret = tps6586x_read(parent, ri->enable_reg[0], &reg_val);
-        if (ret)
-                return ret;
-
-        return !!(reg_val & (1 << ri->enable_bit[0]));
-}
-
 static struct regulator_ops tps6586x_regulator_ops = {
         .list_voltage = regulator_list_voltage_table,
-        .get_voltage_sel = tps6586x_get_voltage_sel,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = tps6586x_set_voltage_sel,
 
-        .is_enabled = tps6586x_regulator_is_enabled,
-        .enable = tps6586x_regulator_enable,
-        .disable = tps6586x_regulator_disable,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+};
+
+static struct regulator_ops tps6586x_sys_regulator_ops = {
 };
 
 static const unsigned int tps6586x_ldo0_voltages[] = {
@@ -202,10 +150,11 @@ static const unsigned int tps6586x_dvm_voltages[] = {
                 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),  \
                 .volt_table = tps6586x_##vdata##_voltages,              \
                 .owner  = THIS_MODULE,                                  \
+                .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
+                .enable_mask = 1 << (ebit0),                            \
+                .vsel_reg = TPS6586X_##vreg,                            \
+                .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
         },                                                              \
-        .volt_reg       = TPS6586X_##vreg,                              \
-        .volt_shift     = (shift),                                      \
-        .volt_nbits     = (nbits),                                      \
         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
         .enable_bit[0]  = (ebit0),                                      \
         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
@@ -230,24 +179,39 @@ static const unsigned int tps6586x_dvm_voltages[] = {
         TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
 }
 
+#define TPS6586X_SYS_REGULATOR()                                        \
+{                                                                       \
+        .desc   = {                                                     \
+                .supply_name = "sys",                                   \
+                .name   = "REG-SYS",                                    \
+                .ops    = &tps6586x_sys_regulator_ops,                  \
+                .type   = REGULATOR_VOLTAGE,                            \
+                .id     = TPS6586X_ID_SYS,                              \
+                .owner  = THIS_MODULE,                                  \
+        },                                                              \
+}
+
 static struct tps6586x_regulator tps6586x_regulator[] = {
+        TPS6586X_SYS_REGULATOR(),
         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_5, "REG-SYS", 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_RTC, "REG-SYS", 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_LDO(SM_2, "vin-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),
+        TPS6586X_DVM(SM_0, "vin-sm0", dvm, SM0V1, 0, 5, ENA, 1,
+                                        ENB, 1, VCC1, 2),
+        TPS6586X_DVM(SM_1, "vin-sm1", dvm, SM1V1, 0, 5, ENA, 0,
+                                        ENB, 0, VCC1, 0),
 };
 
 /*
diff --git a/drivers/regulator/twl-regulator.c b/drivers/regulator/twl-regulator.c
index 242fe90dc565..7eb986a40746 100644
--- a/drivers/regulator/twl-regulator.c
+++ b/drivers/regulator/twl-regulator.c
@@ -10,6 +10,8 @@
  */
 
 #include <linux/module.h>
+#include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
@@ -624,18 +626,9 @@ static int twlfixed_list_voltage(struct regulator_dev *rdev, unsigned index)
         return info->min_mV * 1000;
 }
 
-static int twlfixed_get_voltage(struct regulator_dev *rdev)
-{
-        struct twlreg_info      *info = rdev_get_drvdata(rdev);
-
-        return info->min_mV * 1000;
-}
-
 static struct regulator_ops twl4030fixed_ops = {
         .list_voltage   = twlfixed_list_voltage,
 
-        .get_voltage    = twlfixed_get_voltage,
-
         .enable         = twl4030reg_enable,
         .disable        = twl4030reg_disable,
         .is_enabled     = twl4030reg_is_enabled,
@@ -648,8 +641,6 @@ static struct regulator_ops twl4030fixed_ops = {
 static struct regulator_ops twl6030fixed_ops = {
         .list_voltage   = twlfixed_list_voltage,
 
-        .get_voltage    = twlfixed_get_voltage,
-
         .enable         = twl6030reg_enable,
         .disable        = twl6030reg_disable,
         .is_enabled     = twl6030reg_is_enabled,
@@ -659,13 +650,6 @@ static struct regulator_ops twl6030fixed_ops = {
         .get_status     = twl6030reg_get_status,
 };
 
-static struct regulator_ops twl6030_fixed_resource = {
-        .enable         = twl6030reg_enable,
-        .disable        = twl6030reg_disable,
-        .is_enabled     = twl6030reg_is_enabled,
-        .get_status     = twl6030reg_get_status,
-};
-
 /*
  * SMPS status and control
  */
@@ -757,37 +741,32 @@ static int twl6030smps_list_voltage(struct regulator_dev *rdev, unsigned index)
         return voltage;
 }
 
-static int
-twl6030smps_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
-                        unsigned int *selector)
+static int twl6030smps_map_voltage(struct regulator_dev *rdev, int min_uV,
+                                   int max_uV)
 {
-        struct twlreg_info      *info = rdev_get_drvdata(rdev);
-        int     vsel = 0;
+        struct twlreg_info *info = rdev_get_drvdata(rdev);
+        int vsel = 0;
 
         switch (info->flags) {
         case 0:
                 if (min_uV == 0)
                         vsel = 0;
                 else if ((min_uV >= 600000) && (min_uV <= 1300000)) {
-                        int calc_uV;
                         vsel = DIV_ROUND_UP(min_uV - 600000, 12500);
                         vsel++;
-                        calc_uV = twl6030smps_list_voltage(rdev, vsel);
-                        if (calc_uV > max_uV)
-                                return -EINVAL;
                 }
                 /* Values 1..57 for vsel are linear and can be calculated
                  * values 58..62 are non linear.
                  */
-                else if ((min_uV > 1900000) && (max_uV >= 2100000))
+                else if ((min_uV > 1900000) && (min_uV <= 2100000))
                         vsel = 62;
-                else if ((min_uV > 1800000) && (max_uV >= 1900000))
+                else if ((min_uV > 1800000) && (min_uV <= 1900000))
                         vsel = 61;
-                else if ((min_uV > 1500000) && (max_uV >= 1800000))
+                else if ((min_uV > 1500000) && (min_uV <= 1800000))
                         vsel = 60;
-                else if ((min_uV > 1350000) && (max_uV >= 1500000))
+                else if ((min_uV > 1350000) && (min_uV <= 1500000))
                         vsel = 59;
-                else if ((min_uV > 1300000) && (max_uV >= 1350000))
+                else if ((min_uV > 1300000) && (min_uV <= 1350000))
                         vsel = 58;
                 else
                         return -EINVAL;
@@ -796,25 +775,21 @@ twl6030smps_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
                 if (min_uV == 0)
                         vsel = 0;
                 else if ((min_uV >= 700000) && (min_uV <= 1420000)) {
-                        int calc_uV;
                         vsel = DIV_ROUND_UP(min_uV - 700000, 12500);
                         vsel++;
-                        calc_uV = twl6030smps_list_voltage(rdev, vsel);
-                        if (calc_uV > max_uV)
-                                return -EINVAL;
                 }
                 /* Values 1..57 for vsel are linear and can be calculated
                  * values 58..62 are non linear.
                  */
-                else if ((min_uV > 1900000) && (max_uV >= 2100000))
+                else if ((min_uV > 1900000) && (min_uV <= 2100000))
                         vsel = 62;
-                else if ((min_uV > 1800000) && (max_uV >= 1900000))
+                else if ((min_uV > 1800000) && (min_uV <= 1900000))
                         vsel = 61;
-                else if ((min_uV > 1350000) && (max_uV >= 1800000))
+                else if ((min_uV > 1350000) && (min_uV <= 1800000))
                         vsel = 60;
-                else if ((min_uV > 1350000) && (max_uV >= 1500000))
+                else if ((min_uV > 1350000) && (min_uV <= 1500000))
                         vsel = 59;
-                else if ((min_uV > 1300000) && (max_uV >= 1350000))
+                else if ((min_uV > 1300000) && (min_uV <= 1350000))
                         vsel = 58;
                 else
                         return -EINVAL;
@@ -830,17 +805,23 @@ twl6030smps_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
         case SMPS_OFFSET_EN|SMPS_EXTENDED_EN:
                 if (min_uV == 0) {
                         vsel = 0;
-                } else if ((min_uV >= 2161000) && (max_uV <= 4321000)) {
+                } else if ((min_uV >= 2161000) && (min_uV <= 4321000)) {
                         vsel = DIV_ROUND_UP(min_uV - 2161000, 38600);
                         vsel++;
                 }
                 break;
         }
 
-        *selector = vsel;
+        return vsel;
+}
+
+static int twl6030smps_set_voltage_sel(struct regulator_dev *rdev,
+                                       unsigned int selector)
+{
+        struct twlreg_info *info = rdev_get_drvdata(rdev);
 
         return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS,
-                                                        vsel);
+                            selector);
 }
 
 static int twl6030smps_get_voltage_sel(struct regulator_dev *rdev)
@@ -852,8 +833,9 @@ static int twl6030smps_get_voltage_sel(struct regulator_dev *rdev)
 
 static struct regulator_ops twlsmps_ops = {
         .list_voltage           = twl6030smps_list_voltage,
+        .map_voltage            = twl6030smps_map_voltage,
 
-        .set_voltage            = twl6030smps_set_voltage,
+        .set_voltage_sel        = twl6030smps_set_voltage_sel,
         .get_voltage_sel        = twl6030smps_get_voltage_sel,
 
         .enable                 = twl6030reg_enable,
@@ -876,7 +858,7 @@ static struct regulator_ops twlsmps_ops = {
                         0x0, TWL6030, twl6030fixed_ops)
 
 #define TWL4030_ADJUSTABLE_LDO(label, offset, num, turnon_delay, remap_conf) \
-static struct twlreg_info TWL4030_INFO_##label = { \
+static const struct twlreg_info TWL4030_INFO_##label = { \
         .base = offset, \
         .id = num, \
         .table_len = ARRAY_SIZE(label##_VSEL_table), \
@@ -894,7 +876,7 @@ static struct twlreg_info TWL4030_INFO_##label = { \
         }
 
 #define TWL4030_ADJUSTABLE_SMPS(label, offset, num, turnon_delay, remap_conf) \
-static struct twlreg_info TWL4030_INFO_##label = { \
+static const struct twlreg_info TWL4030_INFO_##label = { \
         .base = offset, \
         .id = num, \
         .remap = remap_conf, \
@@ -909,7 +891,7 @@ static struct twlreg_info TWL4030_INFO_##label = { \
         }
 
 #define TWL6030_ADJUSTABLE_SMPS(label) \
-static struct twlreg_info TWL6030_INFO_##label = { \
+static const struct twlreg_info TWL6030_INFO_##label = { \
         .desc = { \
                 .name = #label, \
                 .id = TWL6030_REG_##label, \
@@ -920,7 +902,7 @@ static struct twlreg_info TWL6030_INFO_##label = { \
         }
 
 #define TWL6030_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts) \
-static struct twlreg_info TWL6030_INFO_##label = { \
+static const struct twlreg_info TWL6030_INFO_##label = { \
         .base = offset, \
         .min_mV = min_mVolts, \
         .max_mV = max_mVolts, \
@@ -935,7 +917,7 @@ static struct twlreg_info TWL6030_INFO_##label = { \
         }
 
 #define TWL6025_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts) \
-static struct twlreg_info TWL6025_INFO_##label = { \
+static const struct twlreg_info TWL6025_INFO_##label = { \
         .base = offset, \
         .min_mV = min_mVolts, \
         .max_mV = max_mVolts, \
@@ -951,7 +933,7 @@ static struct twlreg_info TWL6025_INFO_##label = { \
 
 #define TWL_FIXED_LDO(label, offset, mVolts, num, turnon_delay, remap_conf, \
                 family, operations) \
-static struct twlreg_info TWLFIXED_INFO_##label = { \
+static const struct twlreg_info TWLFIXED_INFO_##label = { \
         .base = offset, \
         .id = num, \
         .min_mV = mVolts, \
@@ -981,7 +963,7 @@ static struct twlreg_info TWLRES_INFO_##label = { \
         }
 
 #define TWL6025_ADJUSTABLE_SMPS(label, offset) \
-static struct twlreg_info TWLSMPS_INFO_##label = { \
+static const struct twlreg_info TWLSMPS_INFO_##label = { \
         .base = offset, \
         .min_mV = 600, \
         .max_mV = 2100, \
@@ -1037,7 +1019,7 @@ TWL6025_ADJUSTABLE_LDO(LDO7, 0x74, 1000, 3300);
 TWL6025_ADJUSTABLE_LDO(LDO6, 0x60, 1000, 3300);
 TWL6025_ADJUSTABLE_LDO(LDOLN, 0x64, 1000, 3300);
 TWL6025_ADJUSTABLE_LDO(LDOUSB, 0x70, 1000, 3300);
-TWL4030_FIXED_LDO(VINTANA2, 0x3f, 1500, 11, 100, 0x08);
+TWL4030_FIXED_LDO(VINTANA1, 0x3f, 1500, 11, 100, 0x08);
 TWL4030_FIXED_LDO(VINTDIG, 0x47, 1500, 13, 100, 0x08);
 TWL4030_FIXED_LDO(VUSB1V5, 0x71, 1500, 17, 100, 0x08);
 TWL4030_FIXED_LDO(VUSB1V8, 0x74, 1800, 18, 100, 0x08);
@@ -1048,7 +1030,6 @@ TWL6030_FIXED_LDO(VDAC, 0x64, 1800, 0);
 TWL6030_FIXED_LDO(VUSB, 0x70, 3300, 0);
 TWL6030_FIXED_LDO(V1V8, 0x16, 1800, 0);
 TWL6030_FIXED_LDO(V2V1, 0x1c, 2100, 0);
-TWL6030_FIXED_RESOURCE(CLK32KG, 0x8C, 0);
 TWL6025_ADJUSTABLE_SMPS(SMPS3, 0x34);
 TWL6025_ADJUSTABLE_SMPS(SMPS4, 0x10);
 TWL6025_ADJUSTABLE_SMPS(VIO, 0x16);
@@ -1117,7 +1098,7 @@ static const struct of_device_id twl_of_match[] __devinitconst = {
         TWL6025_OF_MATCH("ti,twl6025-ldo6", LDO6),
         TWL6025_OF_MATCH("ti,twl6025-ldoln", LDOLN),
         TWL6025_OF_MATCH("ti,twl6025-ldousb", LDOUSB),
-        TWLFIXED_OF_MATCH("ti,twl4030-vintana2", VINTANA2),
+        TWLFIXED_OF_MATCH("ti,twl4030-vintana1", VINTANA1),
         TWLFIXED_OF_MATCH("ti,twl4030-vintdig", VINTDIG),
         TWLFIXED_OF_MATCH("ti,twl4030-vusb1v5", VUSB1V5),
         TWLFIXED_OF_MATCH("ti,twl4030-vusb1v8", VUSB1V8),
@@ -1139,6 +1120,7 @@ static int __devinit twlreg_probe(struct platform_device *pdev)
 {
         int                             i, id;
         struct twlreg_info              *info;
+        const struct twlreg_info        *template;
         struct regulator_init_data      *initdata;
         struct regulation_constraints   *c;
         struct regulator_dev            *rdev;
@@ -1148,17 +1130,17 @@ static int __devinit twlreg_probe(struct platform_device *pdev)
 
         match = of_match_device(twl_of_match, &pdev->dev);
         if (match) {
-                info = match->data;
-                id = info->desc.id;
+                template = match->data;
+                id = template->desc.id;
                 initdata = of_get_regulator_init_data(&pdev->dev,
                                                       pdev->dev.of_node);
                 drvdata = NULL;
         } else {
                 id = pdev->id;
                 initdata = pdev->dev.platform_data;
-                for (i = 0, info = NULL; i < ARRAY_SIZE(twl_of_match); i++) {
-                        info = twl_of_match[i].data;
-                        if (info && info->desc.id == id)
+                for (i = 0, template = NULL; i < ARRAY_SIZE(twl_of_match); i++) {
+                        template = twl_of_match[i].data;
+                        if (template && template->desc.id == id)
                                 break;
                 }
                 if (i == ARRAY_SIZE(twl_of_match))
@@ -1169,12 +1151,16 @@ static int __devinit twlreg_probe(struct platform_device *pdev)
                         return -EINVAL;
         }
 
-        if (!info)
+        if (!template)
                 return -ENODEV;
 
         if (!initdata)
                 return -EINVAL;
 
+        info = kmemdup(template, sizeof (*info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
         if (drvdata) {
                 /* copy the driver data into regulator data */
                 info->features = drvdata->features;
@@ -1235,6 +1221,7 @@ static int __devinit twlreg_probe(struct platform_device *pdev)
         if (IS_ERR(rdev)) {
                 dev_err(&pdev->dev, "can't register %s, %ld\n",
                                 info->desc.name, PTR_ERR(rdev));
+                kfree(info);
                 return PTR_ERR(rdev);
         }
         platform_set_drvdata(pdev, rdev);
@@ -1256,7 +1243,11 @@ static int __devinit twlreg_probe(struct platform_device *pdev)
 
 static int __devexit twlreg_remove(struct platform_device *pdev)
 {
-        regulator_unregister(platform_get_drvdata(pdev));
+        struct regulator_dev *rdev = platform_get_drvdata(pdev);
+        struct twlreg_info *info = rdev->reg_data;
+
+        regulator_unregister(rdev);
+        kfree(info);
         return 0;
 }
 
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
index 7413885be01b..90cbcc683704 100644
--- a/drivers/regulator/wm831x-dcdc.c
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -339,16 +339,15 @@ static int wm831x_buckv_set_current_limit(struct regulator_dev *rdev,
         u16 reg = dcdc->base + WM831X_DCDC_CONTROL_2;
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(wm831x_dcdc_ilim); i++) {
+        for (i = ARRAY_SIZE(wm831x_dcdc_ilim) - 1; i >= 0; i--) {
                 if ((min_uA <= wm831x_dcdc_ilim[i]) &&
                     (wm831x_dcdc_ilim[i] <= max_uA))
-                        break;
+                        return wm831x_set_bits(wm831x, reg,
+                                               WM831X_DC1_HC_THR_MASK,
+                                                i << WM831X_DC1_HC_THR_SHIFT);
         }
-        if (i == ARRAY_SIZE(wm831x_dcdc_ilim))
-                return -EINVAL;
 
-        return wm831x_set_bits(wm831x, reg, WM831X_DC1_HC_THR_MASK,
-                               i << WM831X_DC1_HC_THR_SHIFT);
+        return -EINVAL;
 }
 
 static int wm831x_buckv_get_current_limit(struct regulator_dev *rdev)
diff --git a/drivers/regulator/wm831x-ldo.c b/drivers/regulator/wm831x-ldo.c
index 5cb70ca1e98d..9af512672be1 100644
--- a/drivers/regulator/wm831x-ldo.c
+++ b/drivers/regulator/wm831x-ldo.c
@@ -205,6 +205,8 @@ static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
 
         /* Is it reporting under voltage? */
         ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
+        if (ret < 0)
+                return ret;
         if (ret & mask)
                 return REGULATOR_STATUS_ERROR;
 
@@ -237,6 +239,8 @@ static struct regulator_ops wm831x_gp_ldo_ops = {
         .set_mode = wm831x_gp_ldo_set_mode,
         .get_status = wm831x_gp_ldo_get_status,
         .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
+        .get_bypass = regulator_get_bypass_regmap,
+        .set_bypass = regulator_set_bypass_regmap,
 
         .is_enabled = regulator_is_enabled_regmap,
         .enable = regulator_enable_regmap,
@@ -293,6 +297,8 @@ static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
         ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK;
         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
         ldo->desc.enable_mask = 1 << id;
+        ldo->desc.bypass_reg = ldo->base;
+        ldo->desc.bypass_mask = WM831X_LDO1_SWI;
 
         config.dev = pdev->dev.parent;
         if (pdata)
@@ -469,6 +475,8 @@ static int wm831x_aldo_get_status(struct regulator_dev *rdev)
 
         /* Is it reporting under voltage? */
         ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
+        if (ret < 0)
+                return ret;
         if (ret & mask)
                 return REGULATOR_STATUS_ERROR;
 
@@ -488,6 +496,8 @@ static struct regulator_ops wm831x_aldo_ops = {
         .get_mode = wm831x_aldo_get_mode,
         .set_mode = wm831x_aldo_set_mode,
         .get_status = wm831x_aldo_get_status,
+        .set_bypass = regulator_set_bypass_regmap,
+        .get_bypass = regulator_get_bypass_regmap,
 
         .is_enabled = regulator_is_enabled_regmap,
         .enable = regulator_enable_regmap,
@@ -544,6 +554,8 @@ static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
         ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
         ldo->desc.enable_reg = WM831X_LDO_ENABLE;
         ldo->desc.enable_mask = 1 << id;
+        ldo->desc.bypass_reg = ldo->base;
+        ldo->desc.bypass_mask = WM831X_LDO7_SWI;
 
         config.dev = pdev->dev.parent;
         if (pdata)
diff --git a/drivers/regulator/wm8400-regulator.c b/drivers/regulator/wm8400-regulator.c
index 9035dd053611..27c746ef0636 100644
--- a/drivers/regulator/wm8400-regulator.c
+++ b/drivers/regulator/wm8400-regulator.c
@@ -120,13 +120,8 @@ static int wm8400_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 
         case REGULATOR_MODE_IDLE:
                 /* Datasheet: standby */
-                ret = wm8400_set_bits(wm8400, WM8400_DCDC1_CONTROL_1 + offset,
-                                      WM8400_DC1_ACTIVE, 0);
-                if (ret != 0)
-                        return ret;
                 return wm8400_set_bits(wm8400, WM8400_DCDC1_CONTROL_1 + offset,
-                                       WM8400_DC1_SLEEP, 0);
-
+                                       WM8400_DC1_ACTIVE | WM8400_DC1_SLEEP, 0);
         default:
                 return -EINVAL;
         }