51 files changed, 2218 insertions, 672 deletions

diff --git a/drivers/regulator/88pm800.c b/drivers/regulator/88pm800.c
index d333f7eac106..7a721d67e6ac 100644
--- a/drivers/regulator/88pm800.c
+++ b/drivers/regulator/88pm800.c
@@ -310,10 +310,8 @@ static int pm800_regulator_probe(struct platform_device *pdev)
 
         pm800_data = devm_kzalloc(&pdev->dev, sizeof(*pm800_data),
                                         GFP_KERNEL);
-        if (!pm800_data) {
-                dev_err(&pdev->dev, "Failed to allocate pm800_regualtors");
+        if (!pm800_data)
                 return -ENOMEM;
-        }
 
         pm800_data->map = chip->subchip->regmap_power;
         pm800_data->chip = chip;
diff --git a/drivers/regulator/88pm8607.c b/drivers/regulator/88pm8607.c
index f704d83c93c4..337634ad0562 100644
--- a/drivers/regulator/88pm8607.c
+++ b/drivers/regulator/88pm8607.c
@@ -2,7 +2,7 @@
  * Regulators driver for Marvell 88PM8607
  *
  * Copyright (C) 2009 Marvell International Ltd.
- *      Haojian Zhuang <haojian.zhuang@marvell.com>
+ *      Haojian Zhuang <haojian.zhuang@marvell.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -78,7 +78,7 @@ static const unsigned int BUCK2_suspend_table[] = {
 };
 
 static const unsigned int BUCK3_table[] = {
-              0,   25000,   50000,   75000,  100000,  125000,  150000,  175000,
+              0,   25000,   50000,   75000,  100000,  125000,  150000,  175000,
          200000,  225000,  250000,  275000,  300000,  325000,  350000,  375000,
          400000,  425000,  450000,  475000,  500000,  525000,  550000,  575000,
          600000,  625000,  650000,  675000,  700000,  725000,  750000,  775000,
@@ -89,7 +89,7 @@ static const unsigned int BUCK3_table[] = {
 };
 
 static const unsigned int BUCK3_suspend_table[] = {
-              0,   25000,   50000,   75000,  100000,  125000,  150000,  175000,
+              0,   25000,   50000,   75000,  100000,  125000,  150000,  175000,
          200000,  225000,  250000,  275000,  300000,  325000,  350000,  375000,
          400000,  425000,  450000,  475000,  500000,  525000,  550000,  575000,
          600000,  625000,  650000,  675000,  700000,  725000,  750000,  775000,
@@ -322,7 +322,7 @@ static int pm8607_regulator_dt_init(struct platform_device *pdev,
         nproot = of_node_get(pdev->dev.parent->of_node);
         if (!nproot)
                 return -ENODEV;
-        nproot = of_find_node_by_name(nproot, "regulators");
+        nproot = of_get_child_by_name(nproot, "regulators");
         if (!nproot) {
                 dev_err(&pdev->dev, "failed to find regulators node\n");
                 return -ENODEV;
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index 6a7932822e37..8f3866c44a3f 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -139,6 +139,14 @@ config REGULATOR_AS3722
           AS3722 PMIC. This will enable support for all the software
           controllable DCDC/LDO regulators.
 
+config REGULATOR_BCM590XX
+        tristate "Broadcom BCM590xx PMU Regulators"
+        depends on MFD_BCM590XX
+        help
+          This driver provides support for the voltage regulators on the
+          BCM590xx PMUs. This will enable support for the software
+          controllable LDO/Switching regulators.
+
 config REGULATOR_DA903X
         tristate "Dialog Semiconductor DA9030/DA9034 regulators"
         depends on PMIC_DA903X
@@ -399,12 +407,12 @@ config REGULATOR_PCF50633
          on PCF50633
 
 config REGULATOR_PFUZE100
-        tristate "Freescale PFUZE100 regulator driver"
+        tristate "Freescale PFUZE100/PFUZE200 regulator driver"
         depends on I2C
         select REGMAP_I2C
         help
-          Say y here to support the regulators found on the Freescale PFUZE100
-          PMIC.
+          Say y here to support the regulators found on the Freescale
+          PFUZE100/PFUZE200 PMIC.
 
 config REGULATOR_RC5T583
         tristate "RICOH RC5T583 Power regulators"
@@ -416,13 +424,21 @@ config REGULATOR_RC5T583
           through regulator interface. The device supports multiple DCDC/LDO
           outputs which can be controlled by i2c communication.
 
+config REGULATOR_S2MPA01
+        tristate "Samsung S2MPA01 voltage regulator"
+        depends on MFD_SEC_CORE
+        help
+         This driver controls Samsung S2MPA01 voltage output regulator
+         via I2C bus. S2MPA01 has 10 Bucks and 26 LDO outputs.
+
 config REGULATOR_S2MPS11
-        tristate "Samsung S2MPS11 voltage regulator"
+        tristate "Samsung S2MPS11/S2MPS14 voltage regulator"
         depends on MFD_SEC_CORE
         help
-         This driver supports a Samsung S2MPS11 voltage output regulator
-         via I2C bus. S2MPS11 is comprised of high efficient Buck converters
-         including Dual-Phase Buck converter, Buck-Boost converter, various LDOs.
+         This driver supports a Samsung S2MPS11/S2MPS14 voltage output
+         regulator via I2C bus. The chip is comprised of high efficient Buck
+         converters including Dual-Phase Buck converter, Buck-Boost converter,
+         various LDOs.
 
 config REGULATOR_S5M8767
         tristate "Samsung S5M8767A voltage regulator"
@@ -432,6 +448,12 @@ config REGULATOR_S5M8767
          via I2C bus. S5M8767A have 9 Bucks and 28 LDOs output and
          supports DVS mode with 8bits of output voltage control.
 
+config REGULATOR_ST_PWM
+        tristate "STMicroelectronics PWM voltage regulator"
+        depends on ARCH_STI
+        help
+         This driver supports ST's PWM controlled voltage regulators.
+
 config REGULATOR_TI_ABB
         tristate "TI Adaptive Body Bias on-chip LDO"
         depends on ARCH_OMAP
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 979f9ddcf259..0cfca37941ec 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_REGULATOR_ANATOP) += anatop-regulator.o
 obj-$(CONFIG_REGULATOR_ARIZONA) += arizona-micsupp.o arizona-ldo1.o
 obj-$(CONFIG_REGULATOR_AS3711) += as3711-regulator.o
 obj-$(CONFIG_REGULATOR_AS3722) += as3722-regulator.o
+obj-$(CONFIG_REGULATOR_BCM590XX) += bcm590xx-regulator.o
 obj-$(CONFIG_REGULATOR_DA903X)  += da903x.o
 obj-$(CONFIG_REGULATOR_DA9052)  += da9052-regulator.o
 obj-$(CONFIG_REGULATOR_DA9055)  += da9055-regulator.o
@@ -57,8 +58,10 @@ obj-$(CONFIG_REGULATOR_TPS51632) += tps51632-regulator.o
 obj-$(CONFIG_REGULATOR_PCAP) += pcap-regulator.o
 obj-$(CONFIG_REGULATOR_PCF50633) += pcf50633-regulator.o
 obj-$(CONFIG_REGULATOR_RC5T583)  += rc5t583-regulator.o
+obj-$(CONFIG_REGULATOR_S2MPA01) += s2mpa01.o
 obj-$(CONFIG_REGULATOR_S2MPS11) += s2mps11.o
 obj-$(CONFIG_REGULATOR_S5M8767) += s5m8767.o
+obj-$(CONFIG_REGULATOR_ST_PWM) += st-pwm.o
 obj-$(CONFIG_REGULATOR_STW481X_VMMC) += stw481x-vmmc.o
 obj-$(CONFIG_REGULATOR_TI_ABB) += ti-abb-regulator.o
 obj-$(CONFIG_REGULATOR_TPS6105X) += tps6105x-regulator.o
diff --git a/drivers/regulator/aat2870-regulator.c b/drivers/regulator/aat2870-regulator.c
index f70a9bfa5ff2..c873ee0082cf 100644
--- a/drivers/regulator/aat2870-regulator.c
+++ b/drivers/regulator/aat2870-regulator.c
@@ -99,6 +99,7 @@ static int aat2870_ldo_is_enabled(struct regulator_dev *rdev)
 
 static struct regulator_ops aat2870_ldo_ops = {
         .list_voltage = regulator_list_voltage_table,
+        .map_voltage = regulator_map_voltage_ascend,
         .set_voltage_sel = aat2870_ldo_set_voltage_sel,
         .get_voltage_sel = aat2870_ldo_get_voltage_sel,
         .enable = aat2870_ldo_enable,
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
index 77b46d0b37a6..e10febe9ec34 100644
--- a/drivers/regulator/ab3100.c
+++ b/drivers/regulator/ab3100.c
@@ -498,7 +498,7 @@ static int ab3100_regulator_register(struct platform_device *pdev,
                                      struct ab3100_platform_data *plfdata,
                                      struct regulator_init_data *init_data,
                                      struct device_node *np,
-                                     int id)
+                                     unsigned long id)
 {
         struct regulator_desc *desc;
         struct ab3100_regulator *reg;
@@ -646,7 +646,7 @@ ab3100_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
                 err = ab3100_regulator_register(
                         pdev, NULL, ab3100_regulator_matches[i].init_data,
                         ab3100_regulator_matches[i].of_node,
-                        (int) ab3100_regulator_matches[i].driver_data);
+                        (unsigned long)ab3100_regulator_matches[i].driver_data);
                 if (err) {
                         ab3100_regulators_remove(pdev);
                         return err;
diff --git a/drivers/regulator/act8865-regulator.c b/drivers/regulator/act8865-regulator.c
index 084cc0819a52..b92d7dd01a18 100644
--- a/drivers/regulator/act8865-regulator.c
+++ b/drivers/regulator/act8865-regulator.c
@@ -62,7 +62,6 @@
 #define ACT8865_VOLTAGE_NUM     64
 
 struct act8865 {
-        struct regulator_dev *rdev[ACT8865_REG_NUM];
         struct regmap *regmap;
 };
 
@@ -213,7 +212,7 @@ static int act8865_pdata_from_dt(struct device *dev,
         struct device_node *np;
         struct act8865_regulator_data *regulator;
 
-        np = of_find_node_by_name(dev->of_node, "regulators");
+        np = of_get_child_by_name(dev->of_node, "regulators");
         if (!np) {
                 dev_err(dev, "missing 'regulators' subnode in DT\n");
                 return -EINVAL;
@@ -221,17 +220,15 @@ static int act8865_pdata_from_dt(struct device *dev,
 
         matched = of_regulator_match(dev, np,
                                 act8865_matches, ARRAY_SIZE(act8865_matches));
+        of_node_put(np);
         if (matched <= 0)
                 return matched;
 
         pdata->regulators = devm_kzalloc(dev,
                                 sizeof(struct act8865_regulator_data) *
                                 ARRAY_SIZE(act8865_matches), GFP_KERNEL);
-        if (!pdata->regulators) {
-                dev_err(dev, "%s: failed to allocate act8865 registor\n",
-                                                __func__);
+        if (!pdata->regulators)
                 return -ENOMEM;
-        }
 
         pdata->num_regulators = matched;
         regulator = pdata->regulators;
@@ -258,7 +255,7 @@ static inline int act8865_pdata_from_dt(struct device *dev,
 static int act8865_pmic_probe(struct i2c_client *client,
                            const struct i2c_device_id *i2c_id)
 {
-        struct regulator_dev **rdev;
+        struct regulator_dev *rdev;
         struct device *dev = &client->dev;
         struct act8865_platform_data *pdata = dev_get_platdata(dev);
         struct regulator_config config = { };
@@ -292,8 +289,6 @@ static int act8865_pmic_probe(struct i2c_client *client,
         if (!act8865)
                 return -ENOMEM;
 
-        rdev = act8865->rdev;
-
         act8865->regmap = devm_regmap_init_i2c(client, &act8865_regmap_config);
         if (IS_ERR(act8865->regmap)) {
                 error = PTR_ERR(act8865->regmap);
@@ -313,12 +308,12 @@ static int act8865_pmic_probe(struct i2c_client *client,
                 config.driver_data = act8865;
                 config.regmap = act8865->regmap;
 
-                rdev[i] = devm_regulator_register(&client->dev,
-                                                &act8865_reg[i], &config);
-                if (IS_ERR(rdev[i])) {
+                rdev = devm_regulator_register(&client->dev, &act8865_reg[i],
+                                               &config);
+                if (IS_ERR(rdev)) {
                         dev_err(dev, "failed to register %s\n",
                                 act8865_reg[id].name);
-                        return PTR_ERR(rdev[i]);
+                        return PTR_ERR(rdev);
                 }
         }
 
diff --git a/drivers/regulator/anatop-regulator.c b/drivers/regulator/anatop-regulator.c
index 862e63e451d0..7c397bb81e01 100644
--- a/drivers/regulator/anatop-regulator.c
+++ b/drivers/regulator/anatop-regulator.c
@@ -34,6 +34,9 @@
 #define LDO_RAMP_UP_UNIT_IN_CYCLES      64 /* 64 cycles per step */
 #define LDO_RAMP_UP_FREQ_IN_MHZ         24 /* cycle based on 24M OSC */
 
+#define LDO_POWER_GATE                  0x00
+#define LDO_FET_FULL_ON                 0x1f
+
 struct anatop_regulator {
         const char *name;
         u32 control_reg;
@@ -48,19 +51,10 @@ struct anatop_regulator {
         int max_voltage;
         struct regulator_desc rdesc;
         struct regulator_init_data *initdata;
+        bool bypass;
+        int sel;
 };
 
-static int anatop_regmap_set_voltage_sel(struct regulator_dev *reg,
-                                        unsigned selector)
-{
-        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
-
-        if (!anatop_reg->control_reg)
-                return -ENOTSUPP;
-
-        return regulator_set_voltage_sel_regmap(reg, selector);
-}
-
 static int anatop_regmap_set_voltage_time_sel(struct regulator_dev *reg,
         unsigned int old_sel,
         unsigned int new_sel)
@@ -87,22 +81,99 @@ static int anatop_regmap_set_voltage_time_sel(struct regulator_dev *reg,
         return ret;
 }
 
-static int anatop_regmap_get_voltage_sel(struct regulator_dev *reg)
+static int anatop_regmap_enable(struct regulator_dev *reg)
 {
         struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
+        int sel;
 
-        if (!anatop_reg->control_reg)
-                return -ENOTSUPP;
+        sel = anatop_reg->bypass ? LDO_FET_FULL_ON : anatop_reg->sel;
+        return regulator_set_voltage_sel_regmap(reg, sel);
+}
+
+static int anatop_regmap_disable(struct regulator_dev *reg)
+{
+        return regulator_set_voltage_sel_regmap(reg, LDO_POWER_GATE);
+}
+
+static int anatop_regmap_is_enabled(struct regulator_dev *reg)
+{
+        return regulator_get_voltage_sel_regmap(reg) != LDO_POWER_GATE;
+}
+
+static int anatop_regmap_core_set_voltage_sel(struct regulator_dev *reg,
+                                              unsigned selector)
+{
+        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
+        int ret;
+
+        if (anatop_reg->bypass || !anatop_regmap_is_enabled(reg)) {
+                anatop_reg->sel = selector;
+                return 0;
+        }
+
+        ret = regulator_set_voltage_sel_regmap(reg, selector);
+        if (!ret)
+                anatop_reg->sel = selector;
+        return ret;
+}
+
+static int anatop_regmap_core_get_voltage_sel(struct regulator_dev *reg)
+{
+        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
+
+        if (anatop_reg->bypass || !anatop_regmap_is_enabled(reg))
+                return anatop_reg->sel;
 
         return regulator_get_voltage_sel_regmap(reg);
 }
 
+static int anatop_regmap_get_bypass(struct regulator_dev *reg, bool *enable)
+{
+        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
+        int sel;
+
+        sel = regulator_get_voltage_sel_regmap(reg);
+        if (sel == LDO_FET_FULL_ON)
+                WARN_ON(!anatop_reg->bypass);
+        else if (sel != LDO_POWER_GATE)
+                WARN_ON(anatop_reg->bypass);
+
+        *enable = anatop_reg->bypass;
+        return 0;
+}
+
+static int anatop_regmap_set_bypass(struct regulator_dev *reg, bool enable)
+{
+        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
+        int sel;
+
+        if (enable == anatop_reg->bypass)
+                return 0;
+
+        sel = enable ? LDO_FET_FULL_ON : anatop_reg->sel;
+        anatop_reg->bypass = enable;
+
+        return regulator_set_voltage_sel_regmap(reg, sel);
+}
+
 static struct regulator_ops anatop_rops = {
-        .set_voltage_sel = anatop_regmap_set_voltage_sel,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
+};
+
+static struct regulator_ops anatop_core_rops = {
+        .enable = anatop_regmap_enable,
+        .disable = anatop_regmap_disable,
+        .is_enabled = anatop_regmap_is_enabled,
+        .set_voltage_sel = anatop_regmap_core_set_voltage_sel,
         .set_voltage_time_sel = anatop_regmap_set_voltage_time_sel,
-        .get_voltage_sel = anatop_regmap_get_voltage_sel,
+        .get_voltage_sel = anatop_regmap_core_get_voltage_sel,
         .list_voltage = regulator_list_voltage_linear,
         .map_voltage = regulator_map_voltage_linear,
+        .get_bypass = anatop_regmap_get_bypass,
+        .set_bypass = anatop_regmap_set_bypass,
 };
 
 static int anatop_regulator_probe(struct platform_device *pdev)
@@ -116,6 +187,7 @@ static int anatop_regulator_probe(struct platform_device *pdev)
         struct regulator_init_data *initdata;
         struct regulator_config config = { };
         int ret = 0;
+        u32 val;
 
         initdata = of_get_regulator_init_data(dev, np);
         sreg = devm_kzalloc(dev, sizeof(*sreg), GFP_KERNEL);
@@ -125,7 +197,6 @@ static int anatop_regulator_probe(struct platform_device *pdev)
         sreg->name = of_get_property(np, "regulator-name", NULL);
         rdesc = &sreg->rdesc;
         rdesc->name = sreg->name;
-        rdesc->ops = &anatop_rops;
         rdesc->type = REGULATOR_VOLTAGE;
         rdesc->owner = THIS_MODULE;
 
@@ -197,6 +268,25 @@ static int anatop_regulator_probe(struct platform_device *pdev)
         config.of_node = pdev->dev.of_node;
         config.regmap = sreg->anatop;
 
+        /* Only core regulators have the ramp up delay configuration. */
+        if (sreg->control_reg && sreg->delay_bit_width) {
+                rdesc->ops = &anatop_core_rops;
+
+                ret = regmap_read(config.regmap, rdesc->vsel_reg, &val);
+                if (ret) {
+                        dev_err(dev, "failed to read initial state\n");
+                        return ret;
+                }
+
+                sreg->sel = (val & rdesc->vsel_mask) >> sreg->vol_bit_shift;
+                if (sreg->sel == LDO_FET_FULL_ON) {
+                        sreg->sel = 0;
+                        sreg->bypass = true;
+                }
+        } else {
+                rdesc->ops = &anatop_rops;
+        }
+
         /* register regulator */
         rdev = devm_regulator_register(dev, rdesc, &config);
         if (IS_ERR(rdev)) {
diff --git a/drivers/regulator/arizona-ldo1.c b/drivers/regulator/arizona-ldo1.c
index 4f6c2055f6b2..b1033d30b504 100644
--- a/drivers/regulator/arizona-ldo1.c
+++ b/drivers/regulator/arizona-ldo1.c
@@ -153,11 +153,9 @@ 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,
+        .uV_step = 25000,
+        .n_voltages = 13,
         .enable_time = 500,
 
         .owner = THIS_MODULE,
@@ -189,10 +187,8 @@ static int arizona_ldo1_probe(struct platform_device *pdev)
         int ret;
 
         ldo1 = devm_kzalloc(&pdev->dev, sizeof(*ldo1), GFP_KERNEL);
-        if (ldo1 == NULL) {
-                dev_err(&pdev->dev, "Unable to allocate private data\n");
+        if (!ldo1)
                 return -ENOMEM;
-        }
 
         ldo1->arizona = arizona;
 
@@ -203,6 +199,7 @@ static int arizona_ldo1_probe(struct platform_device *pdev)
          */
         switch (arizona->type) {
         case WM5102:
+        case WM8997:
                 desc = &arizona_ldo1_hc;
                 ldo1->init_data = arizona_ldo1_dvfs;
                 break;
diff --git a/drivers/regulator/arizona-micsupp.c b/drivers/regulator/arizona-micsupp.c
index 034ece707083..6fdd9bf6927f 100644
--- a/drivers/regulator/arizona-micsupp.c
+++ b/drivers/regulator/arizona-micsupp.c
@@ -204,10 +204,8 @@ static int arizona_micsupp_probe(struct platform_device *pdev)
         int ret;
 
         micsupp = devm_kzalloc(&pdev->dev, sizeof(*micsupp), GFP_KERNEL);
-        if (micsupp == NULL) {
-                dev_err(&pdev->dev, "Unable to allocate private data\n");
+        if (!micsupp)
                 return -ENOMEM;
-        }
 
         micsupp->arizona = arizona;
         INIT_WORK(&micsupp->check_cp_work, arizona_micsupp_check_cp);
diff --git a/drivers/regulator/as3711-regulator.c b/drivers/regulator/as3711-regulator.c
index c77a58478cca..b47283f91e2d 100644
--- a/drivers/regulator/as3711-regulator.c
+++ b/drivers/regulator/as3711-regulator.c
@@ -191,7 +191,7 @@ static int as3711_regulator_parse_dt(struct device *dev,
 {
         struct as3711_regulator_pdata *pdata = dev_get_platdata(dev);
         struct device_node *regulators =
-                of_find_node_by_name(dev->parent->of_node, "regulators");
+                of_get_child_by_name(dev->parent->of_node, "regulators");
         struct of_regulator_match *match;
         int ret, i;
 
@@ -221,7 +221,6 @@ static int as3711_regulator_probe(struct platform_device *pdev)
 {
         struct as3711_regulator_pdata *pdata = dev_get_platdata(&pdev->dev);
         struct as3711 *as3711 = dev_get_drvdata(pdev->dev.parent);
-        struct regulator_init_data *reg_data;
         struct regulator_config config = {.dev = &pdev->dev,};
         struct as3711_regulator *reg = NULL;
         struct as3711_regulator *regs;
@@ -246,22 +245,14 @@ static int as3711_regulator_probe(struct platform_device *pdev)
 
         regs = devm_kzalloc(&pdev->dev, AS3711_REGULATOR_NUM *
                         sizeof(struct as3711_regulator), GFP_KERNEL);
-        if (!regs) {
-                dev_err(&pdev->dev, "Memory allocation failed exiting..\n");
+        if (!regs)
                 return -ENOMEM;
-        }
 
         for (id = 0, ri = as3711_reg_info; id < AS3711_REGULATOR_NUM; ++id, ri++) {
-                reg_data = pdata->init_data[id];
-
-                /* No need to register if there is no regulator data */
-                if (!reg_data)
-                        continue;
-
                 reg = &regs[id];
                 reg->reg_info = ri;
 
-                config.init_data = reg_data;
+                config.init_data = pdata->init_data[id];
                 config.driver_data = reg;
                 config.regmap = as3711->regmap;
                 config.of_node = of_node[id];
diff --git a/drivers/regulator/as3722-regulator.c b/drivers/regulator/as3722-regulator.c
index 8b17d786cb71..85585219ce82 100644
--- a/drivers/regulator/as3722-regulator.c
+++ b/drivers/regulator/as3722-regulator.c
@@ -719,6 +719,7 @@ static int as3722_get_regulator_dt_data(struct platform_device *pdev,
 
         ret = of_regulator_match(&pdev->dev, np, as3722_regulator_matches,
                         ARRAY_SIZE(as3722_regulator_matches));
+        of_node_put(np);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Parsing of regulator node failed: %d\n",
                         ret);
diff --git a/drivers/regulator/bcm590xx-regulator.c b/drivers/regulator/bcm590xx-regulator.c
new file mode 100644
index 000000000000..ab08ca7cfb08
--- /dev/null
+++ b/drivers/regulator/bcm590xx-regulator.c
@@ -0,0 +1,403 @@
+/*
+ * Broadcom BCM590xx regulator driver
+ *
+ * Copyright 2014 Linaro Limited
+ * Author: Matt Porter <mporter@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under  the terms of the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/mfd/bcm590xx.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/slab.h>
+
+/* Register defs */
+#define BCM590XX_RFLDOPMCTRL1   0x60
+#define BCM590XX_IOSR1PMCTRL1   0x7a
+#define BCM590XX_IOSR2PMCTRL1   0x7c
+#define BCM590XX_CSRPMCTRL1     0x7e
+#define BCM590XX_SDSR1PMCTRL1   0x82
+#define BCM590XX_SDSR2PMCTRL1   0x86
+#define BCM590XX_MSRPMCTRL1     0x8a
+#define BCM590XX_VSRPMCTRL1     0x8e
+#define BCM590XX_REG_ENABLE     BIT(7)
+
+#define BCM590XX_RFLDOCTRL      0x96
+#define BCM590XX_CSRVOUT1       0xc0
+#define BCM590XX_LDO_VSEL_MASK  GENMASK(5, 3)
+#define BCM590XX_SR_VSEL_MASK   GENMASK(5, 0)
+
+/* LDO regulator IDs */
+#define BCM590XX_REG_RFLDO      0
+#define BCM590XX_REG_CAMLDO1    1
+#define BCM590XX_REG_CAMLDO2    2
+#define BCM590XX_REG_SIMLDO1    3
+#define BCM590XX_REG_SIMLDO2    4
+#define BCM590XX_REG_SDLDO      5
+#define BCM590XX_REG_SDXLDO     6
+#define BCM590XX_REG_MMCLDO1    7
+#define BCM590XX_REG_MMCLDO2    8
+#define BCM590XX_REG_AUDLDO     9
+#define BCM590XX_REG_MICLDO     10
+#define BCM590XX_REG_USBLDO     11
+#define BCM590XX_REG_VIBLDO     12
+
+/* DCDC regulator IDs */
+#define BCM590XX_REG_CSR        13
+#define BCM590XX_REG_IOSR1      14
+#define BCM590XX_REG_IOSR2      15
+#define BCM590XX_REG_MSR        16
+#define BCM590XX_REG_SDSR1      17
+#define BCM590XX_REG_SDSR2      18
+#define BCM590XX_REG_VSR        19
+
+#define BCM590XX_NUM_REGS       20
+
+#define BCM590XX_REG_IS_LDO(n)  (n < BCM590XX_REG_CSR)
+
+struct bcm590xx_board {
+        struct regulator_init_data *bcm590xx_pmu_init_data[BCM590XX_NUM_REGS];
+};
+
+/* LDO group A: supported voltages in microvolts */
+static const unsigned int ldo_a_table[] = {
+        1200000, 1800000, 2500000, 2700000, 2800000,
+        2900000, 3000000, 3300000,
+};
+
+/* LDO group C: supported voltages in microvolts */
+static const unsigned int ldo_c_table[] = {
+        3100000, 1800000, 2500000, 2700000, 2800000,
+        2900000, 3000000, 3300000,
+};
+
+/* DCDC group CSR: supported voltages in microvolts */
+static const struct regulator_linear_range dcdc_csr_ranges[] = {
+        REGULATOR_LINEAR_RANGE(860000, 2, 50, 10000),
+        REGULATOR_LINEAR_RANGE(1360000, 51, 55, 20000),
+        REGULATOR_LINEAR_RANGE(900000, 56, 63, 0),
+};
+
+/* DCDC group IOSR1: supported voltages in microvolts */
+static const struct regulator_linear_range dcdc_iosr1_ranges[] = {
+        REGULATOR_LINEAR_RANGE(860000, 2, 51, 10000),
+        REGULATOR_LINEAR_RANGE(1500000, 52, 52, 0),
+        REGULATOR_LINEAR_RANGE(1800000, 53, 53, 0),
+        REGULATOR_LINEAR_RANGE(900000, 54, 63, 0),
+};
+
+/* DCDC group SDSR1: supported voltages in microvolts */
+static const struct regulator_linear_range dcdc_sdsr1_ranges[] = {
+        REGULATOR_LINEAR_RANGE(860000, 2, 50, 10000),
+        REGULATOR_LINEAR_RANGE(1340000, 51, 51, 0),
+        REGULATOR_LINEAR_RANGE(900000, 52, 63, 0),
+};
+
+struct bcm590xx_info {
+        const char *name;
+        const char *vin_name;
+        u8 n_voltages;
+        const unsigned int *volt_table;
+        u8 n_linear_ranges;
+        const struct regulator_linear_range *linear_ranges;
+};
+
+#define BCM590XX_REG_TABLE(_name, _table) \
+        { \
+                .name = #_name, \
+                .n_voltages = ARRAY_SIZE(_table), \
+                .volt_table = _table, \
+        }
+
+#define BCM590XX_REG_RANGES(_name, _ranges) \
+        { \
+                .name = #_name, \
+                .n_linear_ranges = ARRAY_SIZE(_ranges), \
+                .linear_ranges = _ranges, \
+        }
+
+static struct bcm590xx_info bcm590xx_regs[] = {
+        BCM590XX_REG_TABLE(rfldo, ldo_a_table),
+        BCM590XX_REG_TABLE(camldo1, ldo_c_table),
+        BCM590XX_REG_TABLE(camldo2, ldo_c_table),
+        BCM590XX_REG_TABLE(simldo1, ldo_a_table),
+        BCM590XX_REG_TABLE(simldo2, ldo_a_table),
+        BCM590XX_REG_TABLE(sdldo, ldo_c_table),
+        BCM590XX_REG_TABLE(sdxldo, ldo_a_table),
+        BCM590XX_REG_TABLE(mmcldo1, ldo_a_table),
+        BCM590XX_REG_TABLE(mmcldo2, ldo_a_table),
+        BCM590XX_REG_TABLE(audldo, ldo_a_table),
+        BCM590XX_REG_TABLE(micldo, ldo_a_table),
+        BCM590XX_REG_TABLE(usbldo, ldo_a_table),
+        BCM590XX_REG_TABLE(vibldo, ldo_c_table),
+        BCM590XX_REG_RANGES(csr, dcdc_csr_ranges),
+        BCM590XX_REG_RANGES(iosr1, dcdc_iosr1_ranges),
+        BCM590XX_REG_RANGES(iosr2, dcdc_iosr1_ranges),
+        BCM590XX_REG_RANGES(msr, dcdc_iosr1_ranges),
+        BCM590XX_REG_RANGES(sdsr1, dcdc_sdsr1_ranges),
+        BCM590XX_REG_RANGES(sdsr2, dcdc_iosr1_ranges),
+        BCM590XX_REG_RANGES(vsr, dcdc_iosr1_ranges),
+};
+
+struct bcm590xx_reg {
+        struct regulator_desc *desc;
+        struct bcm590xx *mfd;
+        struct bcm590xx_info **info;
+};
+
+static int bcm590xx_get_vsel_register(int id)
+{
+        if (BCM590XX_REG_IS_LDO(id))
+                return BCM590XX_RFLDOCTRL + id;
+        else
+                return BCM590XX_CSRVOUT1 + (id - BCM590XX_REG_CSR) * 3;
+}
+
+static int bcm590xx_get_enable_register(int id)
+{
+        int reg = 0;
+
+        if (BCM590XX_REG_IS_LDO(id))
+                reg = BCM590XX_RFLDOPMCTRL1 + id * 2;
+        else
+                switch (id) {
+                case BCM590XX_REG_CSR:
+                        reg = BCM590XX_CSRPMCTRL1;
+                        break;
+                case BCM590XX_REG_IOSR1:
+                        reg = BCM590XX_IOSR1PMCTRL1;
+                        break;
+                case BCM590XX_REG_IOSR2:
+                        reg = BCM590XX_IOSR2PMCTRL1;
+                        break;
+                case BCM590XX_REG_MSR:
+                        reg = BCM590XX_MSRPMCTRL1;
+                        break;
+                case BCM590XX_REG_SDSR1:
+                        reg = BCM590XX_SDSR1PMCTRL1;
+                        break;
+                case BCM590XX_REG_SDSR2:
+                        reg = BCM590XX_SDSR2PMCTRL1;
+                        break;
+                };
+
+        return reg;
+}
+
+static struct regulator_ops bcm590xx_ops_ldo = {
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .list_voltage           = regulator_list_voltage_table,
+        .map_voltage            = regulator_map_voltage_iterate,
+};
+
+static struct regulator_ops bcm590xx_ops_dcdc = {
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .list_voltage           = regulator_list_voltage_linear_range,
+        .map_voltage            = regulator_map_voltage_linear_range,
+};
+
+#define BCM590XX_MATCH(_name, _id) \
+        { \
+                .name = #_name, \
+                .driver_data = (void *)&bcm590xx_regs[BCM590XX_REG_##_id], \
+        }
+
+static struct of_regulator_match bcm590xx_matches[] = {
+        BCM590XX_MATCH(rfldo, RFLDO),
+        BCM590XX_MATCH(camldo1, CAMLDO1),
+        BCM590XX_MATCH(camldo2, CAMLDO2),
+        BCM590XX_MATCH(simldo1, SIMLDO1),
+        BCM590XX_MATCH(simldo2, SIMLDO2),
+        BCM590XX_MATCH(sdldo, SDLDO),
+        BCM590XX_MATCH(sdxldo, SDXLDO),
+        BCM590XX_MATCH(mmcldo1, MMCLDO1),
+        BCM590XX_MATCH(mmcldo2, MMCLDO2),
+        BCM590XX_MATCH(audldo, AUDLDO),
+        BCM590XX_MATCH(micldo, MICLDO),
+        BCM590XX_MATCH(usbldo, USBLDO),
+        BCM590XX_MATCH(vibldo, VIBLDO),
+        BCM590XX_MATCH(csr, CSR),
+        BCM590XX_MATCH(iosr1, IOSR1),
+        BCM590XX_MATCH(iosr2, IOSR2),
+        BCM590XX_MATCH(msr, MSR),
+        BCM590XX_MATCH(sdsr1, SDSR1),
+        BCM590XX_MATCH(sdsr2, SDSR2),
+        BCM590XX_MATCH(vsr, VSR),
+};
+
+static struct bcm590xx_board *bcm590xx_parse_dt_reg_data(
+                struct platform_device *pdev,
+                struct of_regulator_match **bcm590xx_reg_matches)
+{
+        struct bcm590xx_board *data;
+        struct device_node *np = pdev->dev.parent->of_node;
+        struct device_node *regulators;
+        struct of_regulator_match *matches = bcm590xx_matches;
+        int count = ARRAY_SIZE(bcm590xx_matches);
+        int idx = 0;
+        int ret;
+
+        if (!np) {
+                dev_err(&pdev->dev, "of node not found\n");
+                return NULL;
+        }
+
+        data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+        if (!data) {
+                dev_err(&pdev->dev, "failed to allocate regulator board data\n");
+                return NULL;
+        }
+
+        np = of_node_get(np);
+        regulators = of_get_child_by_name(np, "regulators");
+        if (!regulators) {
+                dev_warn(&pdev->dev, "regulator node not found\n");
+                return NULL;
+        }
+
+        ret = of_regulator_match(&pdev->dev, regulators, matches, count);
+        of_node_put(regulators);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Error parsing regulator init data: %d\n",
+                        ret);
+                return NULL;
+        }
+
+        *bcm590xx_reg_matches = matches;
+
+        for (idx = 0; idx < count; idx++) {
+                if (!matches[idx].init_data || !matches[idx].of_node)
+                        continue;
+
+                data->bcm590xx_pmu_init_data[idx] = matches[idx].init_data;
+        }
+
+        return data;
+}
+
+static int bcm590xx_probe(struct platform_device *pdev)
+{
+        struct bcm590xx *bcm590xx = dev_get_drvdata(pdev->dev.parent);
+        struct bcm590xx_board *pmu_data = NULL;
+        struct bcm590xx_reg *pmu;
+        struct regulator_config config = { };
+        struct bcm590xx_info *info;
+        struct regulator_init_data *reg_data;
+        struct regulator_dev *rdev;
+        struct of_regulator_match *bcm590xx_reg_matches = NULL;
+        int i;
+
+        pmu_data = bcm590xx_parse_dt_reg_data(pdev,
+                                              &bcm590xx_reg_matches);
+
+        pmu = devm_kzalloc(&pdev->dev, sizeof(*pmu), GFP_KERNEL);
+        if (!pmu) {
+                dev_err(&pdev->dev, "Memory allocation failed for pmu\n");
+                return -ENOMEM;
+        }
+
+        pmu->mfd = bcm590xx;
+
+        platform_set_drvdata(pdev, pmu);
+
+        pmu->desc = devm_kzalloc(&pdev->dev, BCM590XX_NUM_REGS *
+                        sizeof(struct regulator_desc), GFP_KERNEL);
+        if (!pmu->desc) {
+                dev_err(&pdev->dev, "Memory alloc fails for desc\n");
+                return -ENOMEM;
+        }
+
+        pmu->info = devm_kzalloc(&pdev->dev, BCM590XX_NUM_REGS *
+                        sizeof(struct bcm590xx_info *), GFP_KERNEL);
+        if (!pmu->info) {
+                dev_err(&pdev->dev, "Memory alloc fails for info\n");
+                return -ENOMEM;
+        }
+
+        info = bcm590xx_regs;
+
+        for (i = 0; i < BCM590XX_NUM_REGS; i++, info++) {
+                if (pmu_data)
+                        reg_data = pmu_data->bcm590xx_pmu_init_data[i];
+                else
+                        reg_data = NULL;
+
+                /* Register the regulators */
+                pmu->info[i] = info;
+
+                pmu->desc[i].name = info->name;
+                pmu->desc[i].supply_name = info->vin_name;
+                pmu->desc[i].id = i;
+                pmu->desc[i].volt_table = info->volt_table;
+                pmu->desc[i].n_voltages = info->n_voltages;
+                pmu->desc[i].linear_ranges = info->linear_ranges;
+                pmu->desc[i].n_linear_ranges = info->n_linear_ranges;
+
+                if (BCM590XX_REG_IS_LDO(i)) {
+                        pmu->desc[i].ops = &bcm590xx_ops_ldo;
+                        pmu->desc[i].vsel_mask = BCM590XX_LDO_VSEL_MASK;
+                } else {
+                        pmu->desc[i].ops = &bcm590xx_ops_dcdc;
+                        pmu->desc[i].vsel_mask = BCM590XX_SR_VSEL_MASK;
+                }
+
+                pmu->desc[i].vsel_reg = bcm590xx_get_vsel_register(i);
+                pmu->desc[i].enable_is_inverted = true;
+                pmu->desc[i].enable_mask = BCM590XX_REG_ENABLE;
+                pmu->desc[i].enable_reg = bcm590xx_get_enable_register(i);
+                pmu->desc[i].type = REGULATOR_VOLTAGE;
+                pmu->desc[i].owner = THIS_MODULE;
+
+                config.dev = bcm590xx->dev;
+                config.init_data = reg_data;
+                config.driver_data = pmu;
+                config.regmap = bcm590xx->regmap;
+
+                if (bcm590xx_reg_matches)
+                        config.of_node = bcm590xx_reg_matches[i].of_node;
+
+                rdev = devm_regulator_register(&pdev->dev, &pmu->desc[i],
+                                               &config);
+                if (IS_ERR(rdev)) {
+                        dev_err(bcm590xx->dev,
+                                "failed to register %s regulator\n",
+                                pdev->name);
+                        return PTR_ERR(rdev);
+                }
+        }
+
+        return 0;
+}
+
+static struct platform_driver bcm590xx_regulator_driver = {
+        .driver = {
+                .name = "bcm590xx-vregs",
+                .owner = THIS_MODULE,
+        },
+        .probe = bcm590xx_probe,
+};
+module_platform_driver(bcm590xx_regulator_driver);
+
+MODULE_AUTHOR("Matt Porter <mporter@linaro.org>");
+MODULE_DESCRIPTION("BCM590xx voltage regulator driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:bcm590xx-vregs");
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index b38a6b669e8c..bac485acc7f3 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -953,6 +953,8 @@ static int machine_constraints_current(struct regulator_dev *rdev,
         return 0;
 }
 
+static int _regulator_do_enable(struct regulator_dev *rdev);
+
 /**
  * set_machine_constraints - sets regulator constraints
  * @rdev: regulator source
@@ -1013,10 +1015,9 @@ static int set_machine_constraints(struct regulator_dev *rdev,
         /* If the constraints say the regulator should be on at this point
          * and we have control then make sure it is enabled.
          */
-        if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
-            ops->enable) {
-                ret = ops->enable(rdev);
-                if (ret < 0) {
+        if (rdev->constraints->always_on || rdev->constraints->boot_on) {
+                ret = _regulator_do_enable(rdev);
+                if (ret < 0 && ret != -EINVAL) {
                         rdev_err(rdev, "failed to enable\n");
                         goto out;
                 }
@@ -1272,6 +1273,8 @@ static struct regulator_dev *regulator_dev_lookup(struct device *dev,
                                 if (r->dev.parent &&
                                         node == r->dev.of_node)
                                         return r;
+                        *ret = -EPROBE_DEFER;
+                        return NULL;
                 } else {
                         /*
                          * If we couldn't even get the node then it's
@@ -1312,7 +1315,7 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
         struct regulator_dev *rdev;
         struct regulator *regulator = ERR_PTR(-EPROBE_DEFER);
         const char *devname = NULL;
-        int ret = -EPROBE_DEFER;
+        int ret;
 
         if (id == NULL) {
                 pr_err("get() with no identifier\n");
@@ -1322,6 +1325,11 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
         if (dev)
                 devname = dev_name(dev);
 
+        if (have_full_constraints())
+                ret = -ENODEV;
+        else
+                ret = -EPROBE_DEFER;
+
         mutex_lock(&regulator_list_mutex);
 
         rdev = regulator_dev_lookup(dev, id, &ret);
@@ -1352,7 +1360,7 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
                 goto found;
         /* Don't log an error when called from regulator_get_optional() */
         } else if (!have_full_constraints() || exclusive) {
-                dev_err(dev, "dummy supplies not allowed\n");
+                dev_warn(dev, "dummy supplies not allowed\n");
         }
 
         mutex_unlock(&regulator_list_mutex);
@@ -1900,8 +1908,6 @@ static int _regulator_do_disable(struct regulator_dev *rdev)
 
         trace_regulator_disable_complete(rdev_get_name(rdev));
 
-        _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
-                             NULL);
         return 0;
 }
 
@@ -1925,6 +1931,8 @@ static int _regulator_disable(struct regulator_dev *rdev)
                                 rdev_err(rdev, "failed to disable\n");
                                 return ret;
                         }
+                        _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
+                                        NULL);
                 }
 
                 rdev->use_count = 0;
@@ -1977,20 +1985,16 @@ static int _regulator_force_disable(struct regulator_dev *rdev)
 {
         int ret = 0;
 
-        /* force disable */
-        if (rdev->desc->ops->disable) {
-                /* ah well, who wants to live forever... */
-                ret = rdev->desc->ops->disable(rdev);
-                if (ret < 0) {
-                        rdev_err(rdev, "failed to force disable\n");
-                        return ret;
-                }
-                /* notify other consumers that power has been forced off */
-                _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
-                        REGULATOR_EVENT_DISABLE, NULL);
+        ret = _regulator_do_disable(rdev);
+        if (ret < 0) {
+                rdev_err(rdev, "failed to force disable\n");
+                return ret;
         }
 
-        return ret;
+        _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
+                        REGULATOR_EVENT_DISABLE, NULL);
+
+        return 0;
 }
 
 /**
@@ -2395,6 +2399,7 @@ int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
         struct regulator_dev *rdev = regulator->rdev;
         int ret = 0;
         int old_min_uV, old_max_uV;
+        int current_uV;
 
         mutex_lock(&rdev->mutex);
 
@@ -2405,6 +2410,19 @@ int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
         if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
                 goto out;
 
+        /* If we're trying to set a range that overlaps the current voltage,
+         * return succesfully even though the regulator does not support
+         * changing the voltage.
+         */
+        if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
+                current_uV = _regulator_get_voltage(rdev);
+                if (min_uV <= current_uV && current_uV <= max_uV) {
+                        regulator->min_uV = min_uV;
+                        regulator->max_uV = max_uV;
+                        goto out;
+                }
+        }
+
         /* sanity check */
         if (!rdev->desc->ops->set_voltage &&
             !rdev->desc->ops->set_voltage_sel) {
@@ -3623,23 +3641,18 @@ int regulator_suspend_finish(void)
 
         mutex_lock(&regulator_list_mutex);
         list_for_each_entry(rdev, &regulator_list, list) {
-                struct regulator_ops *ops = rdev->desc->ops;
-
                 mutex_lock(&rdev->mutex);
-                if ((rdev->use_count > 0  || rdev->constraints->always_on) &&
-                                ops->enable) {
-                        error = ops->enable(rdev);
+                if (rdev->use_count > 0  || rdev->constraints->always_on) {
+                        error = _regulator_do_enable(rdev);
                         if (error)
                                 ret = error;
                 } else {
                         if (!have_full_constraints())
                                 goto unlock;
-                        if (!ops->disable)
-                                goto unlock;
                         if (!_regulator_is_enabled(rdev))
                                 goto unlock;
 
-                        error = ops->disable(rdev);
+                        error = _regulator_do_disable(rdev);
                         if (error)
                                 ret = error;
                 }
@@ -3813,7 +3826,7 @@ static int __init regulator_init_complete(void)
                 ops = rdev->desc->ops;
                 c = rdev->constraints;
 
-                if (!ops->disable || (c && c->always_on))
+                if (c && c->always_on)
                         continue;
 
                 mutex_lock(&rdev->mutex);
@@ -3834,7 +3847,7 @@ static int __init regulator_init_complete(void)
                         /* We log since this may kill the system if it
                          * goes wrong. */
                         rdev_info(rdev, "disabling\n");
-                        ret = ops->disable(rdev);
+                        ret = _regulator_do_disable(rdev);
                         if (ret != 0)
                                 rdev_err(rdev, "couldn't disable: %d\n", ret);
                 } else {
diff --git a/drivers/regulator/da9052-regulator.c b/drivers/regulator/da9052-regulator.c
index 3adeaeffc485..fdb6ea8ae7e6 100644
--- a/drivers/regulator/da9052-regulator.c
+++ b/drivers/regulator/da9052-regulator.c
@@ -240,6 +240,31 @@ static int da9052_regulator_set_voltage_sel(struct regulator_dev *rdev,
         return ret;
 }
 
+static int da9052_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
+                                                 unsigned int old_sel,
+                                                 unsigned int new_sel)
+{
+        struct da9052_regulator *regulator = rdev_get_drvdata(rdev);
+        struct da9052_regulator_info *info = regulator->info;
+        int id = rdev_get_id(rdev);
+        int ret = 0;
+
+        /* The DVC controlled LDOs and DCDCs ramp with 6.25mV/µs after enabling
+         * the activate bit.
+         */
+        switch (id) {
+        case DA9052_ID_BUCK1:
+        case DA9052_ID_BUCK2:
+        case DA9052_ID_BUCK3:
+        case DA9052_ID_LDO2:
+        case DA9052_ID_LDO3:
+                ret = (new_sel - old_sel) * info->step_uV / 6250;
+                break;
+        }
+
+        return ret;
+}
+
 static struct regulator_ops da9052_dcdc_ops = {
         .get_current_limit = da9052_dcdc_get_current_limit,
         .set_current_limit = da9052_dcdc_set_current_limit,
@@ -248,6 +273,7 @@ static struct regulator_ops da9052_dcdc_ops = {
         .map_voltage = da9052_map_voltage,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = da9052_regulator_set_voltage_sel,
+        .set_voltage_time_sel = da9052_regulator_set_voltage_time_sel,
         .is_enabled = regulator_is_enabled_regmap,
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
@@ -258,6 +284,7 @@ static struct regulator_ops da9052_ldo_ops = {
         .map_voltage = da9052_map_voltage,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = da9052_regulator_set_voltage_sel,
+        .set_voltage_time_sel = da9052_regulator_set_voltage_time_sel,
         .is_enabled = regulator_is_enabled_regmap,
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
@@ -401,7 +428,7 @@ static int da9052_regulator_probe(struct platform_device *pdev)
                 if (!nproot)
                         return -ENODEV;
 
-                nproot = of_find_node_by_name(nproot, "regulators");
+                nproot = of_get_child_by_name(nproot, "regulators");
                 if (!nproot)
                         return -ENODEV;
 
diff --git a/drivers/regulator/da9055-regulator.c b/drivers/regulator/da9055-regulator.c
index 7f340206d329..9516317e1a9f 100644
--- a/drivers/regulator/da9055-regulator.c
+++ b/drivers/regulator/da9055-regulator.c
@@ -19,6 +19,8 @@
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
+#include <linux/of.h>
+#include <linux/regulator/of_regulator.h>
 
 #include <linux/mfd/da9055/core.h>
 #include <linux/mfd/da9055/reg.h>
@@ -446,6 +448,9 @@ static int da9055_gpio_init(struct da9055_regulator *regulator,
         struct da9055_regulator_info *info = regulator->info;
         int ret = 0;
 
+        if (!pdata)
+                return 0;
+
         if (pdata->gpio_ren && pdata->gpio_ren[id]) {
                 char name[18];
                 int gpio_mux = pdata->gpio_ren[id];
@@ -530,6 +535,59 @@ static inline struct da9055_regulator_info *find_regulator_info(int id)
         return NULL;
 }
 
+#ifdef CONFIG_OF
+static struct of_regulator_match da9055_reg_matches[] = {
+        { .name = "BUCK1", },
+        { .name = "BUCK2", },
+        { .name = "LDO1", },
+        { .name = "LDO2", },
+        { .name = "LDO3", },
+        { .name = "LDO4", },
+        { .name = "LDO5", },
+        { .name = "LDO6", },
+};
+
+static int da9055_regulator_dt_init(struct platform_device *pdev,
+                                    struct da9055_regulator *regulator,
+                                    struct regulator_config *config,
+                                    int regid)
+{
+        struct device_node *nproot, *np;
+        int ret;
+
+        nproot = of_node_get(pdev->dev.parent->of_node);
+        if (!nproot)
+                return -ENODEV;
+
+        np = of_get_child_by_name(nproot, "regulators");
+        if (!np)
+                return -ENODEV;
+
+        ret = of_regulator_match(&pdev->dev, np, &da9055_reg_matches[regid], 1);
+        of_node_put(nproot);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Error matching regulator: %d\n", ret);
+                return ret;
+        }
+
+        config->init_data = da9055_reg_matches[regid].init_data;
+        config->of_node = da9055_reg_matches[regid].of_node;
+
+        if (!config->of_node)
+                return -ENODEV;
+
+        return 0;
+}
+#else
+static inline int da9055_regulator_dt_init(struct platform_device *pdev,
+                                       struct da9055_regulator *regulator,
+                                       struct regulator_config *config,
+                                       int regid)
+{
+        return -ENODEV;
+}
+#endif /* CONFIG_OF */
+
 static int da9055_regulator_probe(struct platform_device *pdev)
 {
         struct regulator_config config = { };
@@ -538,9 +596,6 @@ static int da9055_regulator_probe(struct platform_device *pdev)
         struct da9055_pdata *pdata = dev_get_platdata(da9055->dev);
         int ret, irq;
 
-        if (pdata == NULL || pdata->regulators[pdev->id] == NULL)
-                return -ENODEV;
-
         regulator = devm_kzalloc(&pdev->dev, sizeof(struct da9055_regulator),
                                  GFP_KERNEL);
         if (!regulator)
@@ -557,8 +612,14 @@ static int da9055_regulator_probe(struct platform_device *pdev)
         config.driver_data = regulator;
         config.regmap = da9055->regmap;
 
-        if (pdata && pdata->regulators)
+        if (pdata && pdata->regulators) {
                 config.init_data = pdata->regulators[pdev->id];
+        } else {
+                ret = da9055_regulator_dt_init(pdev, regulator, &config,
+                                               pdev->id);
+                if (ret < 0)
+                        return ret;
+        }
 
         ret = da9055_gpio_init(regulator, &config, pdata, pdev->id);
         if (ret < 0)
@@ -576,7 +637,9 @@ static int da9055_regulator_probe(struct platform_device *pdev)
         /* Only LDO 5 and 6 has got the over current interrupt */
         if (pdev->id == DA9055_ID_LDO5 || pdev->id ==  DA9055_ID_LDO6) {
                 irq = platform_get_irq_byname(pdev, "REGULATOR");
-                irq = regmap_irq_get_virq(da9055->irq_data, irq);
+                if (irq < 0)
+                        return irq;
+
                 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
                                                 da9055_ldo5_6_oc_irq,
                                                 IRQF_TRIGGER_HIGH |
diff --git a/drivers/regulator/da9063-regulator.c b/drivers/regulator/da9063-regulator.c
index 56727eb745df..7c9461d13313 100644
--- a/drivers/regulator/da9063-regulator.c
+++ b/drivers/regulator/da9063-regulator.c
@@ -1,3 +1,4 @@
+
 /*
  * Regulator driver for DA9063 PMIC series
  *
@@ -60,7 +61,8 @@ struct da9063_regulator_info {
         .desc.ops = &da9063_ldo_ops, \
         .desc.min_uV = (min_mV) * 1000, \
         .desc.uV_step = (step_mV) * 1000, \
-        .desc.n_voltages = (((max_mV) - (min_mV))/(step_mV) + 1), \
+        .desc.n_voltages = (((max_mV) - (min_mV))/(step_mV) + 1 \
+                + (DA9063_V##regl_name##_BIAS)), \
         .desc.enable_reg = DA9063_REG_##regl_name##_CONT, \
         .desc.enable_mask = DA9063_LDO_EN, \
         .desc.vsel_reg = DA9063_REG_V##regl_name##_A, \
@@ -363,7 +365,7 @@ static int da9063_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 
         sel = regulator_map_voltage_linear(rdev, uV, uV);
         if (sel < 0)
-                return -EINVAL;
+                return sel;
 
         sel <<= ffs(rdev->desc->vsel_mask) - 1;
 
@@ -664,7 +666,7 @@ static struct da9063_regulators_pdata *da9063_parse_regulators_dt(
         struct device_node *node;
         int i, n, num;
 
-        node = of_find_node_by_name(pdev->dev.parent->of_node, "regulators");
+        node = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
         if (!node) {
                 dev_err(&pdev->dev, "Regulators device node not found\n");
                 return ERR_PTR(-ENODEV);
@@ -672,6 +674,7 @@ static struct da9063_regulators_pdata *da9063_parse_regulators_dt(
 
         num = of_regulator_match(&pdev->dev, node, da9063_matches,
                                  ARRAY_SIZE(da9063_matches));
+        of_node_put(node);
         if (num < 0) {
                 dev_err(&pdev->dev, "Failed to match regulators\n");
                 return ERR_PTR(-EINVAL);
@@ -708,7 +711,7 @@ static struct da9063_regulators_pdata *da9063_parse_regulators_dt(
                 struct platform_device *pdev,
                 struct of_regulator_match **da9063_reg_matches)
 {
-        da9063_reg_matches = NULL;
+        *da9063_reg_matches = NULL;
         return ERR_PTR(-ENODEV);
 }
 #endif
@@ -754,7 +757,7 @@ static int da9063_regulator_probe(struct platform_device *pdev)
         if (ret < 0) {
                 dev_err(&pdev->dev,
                         "Error while reading BUCKs configuration\n");
-                return -EIO;
+                return ret;
         }
         bcores_merged = val & DA9063_BCORE_MERGE;
         bmem_bio_merged = val & DA9063_BUCK_MERGE;
@@ -773,10 +776,8 @@ static int da9063_regulator_probe(struct platform_device *pdev)
         size = sizeof(struct da9063_regulators) +
                 n_regulators * sizeof(struct da9063_regulator);
         regulators = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
-        if (!regulators) {
-                dev_err(&pdev->dev, "No memory for regulators\n");
+        if (!regulators)
                 return -ENOMEM;
-        }
 
         regulators->n_regulators = n_regulators;
         platform_set_drvdata(pdev, regulators);
diff --git a/drivers/regulator/da9210-regulator.c b/drivers/regulator/da9210-regulator.c
index 6f5ecbe1132e..7a320dd11c46 100644
--- a/drivers/regulator/da9210-regulator.c
+++ b/drivers/regulator/da9210-regulator.c
@@ -134,11 +134,8 @@ static int da9210_i2c_probe(struct i2c_client *i2c,
         int error;
 
         chip = devm_kzalloc(&i2c->dev, sizeof(struct da9210), GFP_KERNEL);
-        if (NULL == chip) {
-                dev_err(&i2c->dev,
-                        "Cannot kzalloc memory for regulator structure\n");
+        if (!chip)
                 return -ENOMEM;
-        }
 
         chip->regmap = devm_regmap_init_i2c(i2c, &da9210_regmap_config);
         if (IS_ERR(chip->regmap)) {
diff --git a/drivers/regulator/db8500-prcmu.c b/drivers/regulator/db8500-prcmu.c
index 846acf240e48..617c1adca816 100644
--- a/drivers/regulator/db8500-prcmu.c
+++ b/drivers/regulator/db8500-prcmu.c
@@ -263,6 +263,8 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = {
                         .ops    = &db8500_regulator_ops,
                         .type   = REGULATOR_VOLTAGE,
                         .owner  = THIS_MODULE,
+                        .fixed_uV = 1800000,
+                        .n_voltages = 1,
                 },
                 .exclude_from_power_state = true,
         },
diff --git a/drivers/regulator/dbx500-prcmu.c b/drivers/regulator/dbx500-prcmu.c
index ce89f7848a57..2d16b9f16de7 100644
--- a/drivers/regulator/dbx500-prcmu.c
+++ b/drivers/regulator/dbx500-prcmu.c
@@ -78,6 +78,7 @@ static struct ux500_regulator_debug {
 void ux500_regulator_suspend_debug(void)
 {
         int i;
+
         for (i = 0; i < rdebug.num_regulators; i++)
                 rdebug.state_before_suspend[i] =
                         rdebug.regulator_array[i].is_enabled;
@@ -86,6 +87,7 @@ void ux500_regulator_suspend_debug(void)
 void ux500_regulator_resume_debug(void)
 {
         int i;
+
         for (i = 0; i < rdebug.num_regulators; i++)
                 rdebug.state_after_suspend[i] =
                         rdebug.regulator_array[i].is_enabled;
@@ -127,9 +129,9 @@ static int ux500_regulator_status_print(struct seq_file *s, void *p)
         int i;
 
         /* print dump header */
-        err = seq_printf(s, "ux500-regulator status:\n");
+        err = seq_puts(s, "ux500-regulator status:\n");
         if (err < 0)
-                dev_err(dev, "seq_printf overflow\n");
+                dev_err(dev, "seq_puts overflow\n");
 
         err = seq_printf(s, "%31s : %8s : %8s\n", "current",
                 "before", "after");
@@ -202,18 +204,12 @@ ux500_regulator_debug_init(struct platform_device *pdev,
         rdebug.num_regulators = num_regulators;
 
         rdebug.state_before_suspend = kzalloc(num_regulators, GFP_KERNEL);
-        if (!rdebug.state_before_suspend) {
-                dev_err(&pdev->dev,
-                        "could not allocate memory for saving state\n");
+        if (!rdebug.state_before_suspend)
                 goto exit_destroy_power_state;
-        }
 
         rdebug.state_after_suspend = kzalloc(num_regulators, GFP_KERNEL);
-        if (!rdebug.state_after_suspend) {
-                dev_err(&pdev->dev,
-                        "could not allocate memory for saving state\n");
+        if (!rdebug.state_after_suspend)
                 goto exit_free;
-        }
 
         dbx500_regulator_testcase(regulator_info, num_regulators);
         return 0;
diff --git a/drivers/regulator/dummy.c b/drivers/regulator/dummy.c
index df9f42524abb..2436db9e2ca3 100644
--- a/drivers/regulator/dummy.c
+++ b/drivers/regulator/dummy.c
@@ -25,7 +25,11 @@
 
 struct regulator_dev *dummy_regulator_rdev;
 
-static struct regulator_init_data dummy_initdata;
+static struct regulator_init_data dummy_initdata = {
+        .constraints = {
+                .always_on = 1,
+        },
+};
 
 static struct regulator_ops dummy_ops;
 
diff --git a/drivers/regulator/fan53555.c b/drivers/regulator/fan53555.c
index 7ca3d9e3b0fe..714fd9a89aa1 100644
--- a/drivers/regulator/fan53555.c
+++ b/drivers/regulator/fan53555.c
@@ -90,11 +90,11 @@ static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)
                 return 0;
         ret = regulator_map_voltage_linear(rdev, uV, uV);
         if (ret < 0)
-                return -EINVAL;
+                return ret;
         ret = regmap_update_bits(di->regmap, di->sleep_reg,
                                         VSEL_NSEL_MASK, ret);
         if (ret < 0)
-                return -EINVAL;
+                return ret;
         /* Cache the sleep voltage setting.
          * Might not be the real voltage which is rounded */
         di->sleep_vol_cache = uV;
@@ -244,10 +244,9 @@ static int fan53555_regulator_probe(struct i2c_client *client,
 
         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");
+        if (!di)
                 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");
@@ -260,14 +259,14 @@ static int fan53555_regulator_probe(struct i2c_client *client,
         ret = regmap_read(di->regmap, FAN53555_ID1, &val);
         if (ret < 0) {
                 dev_err(&client->dev, "Failed to get chip ID!\n");
-                return -ENODEV;
+                return ret;
         }
         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;
+                return ret;
         }
         di->chip_rev = val & DIE_REV;
         dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n",
diff --git a/drivers/regulator/fixed.c b/drivers/regulator/fixed.c
index 5ea64b94341c..c61f7e97e4f8 100644
--- a/drivers/regulator/fixed.c
+++ b/drivers/regulator/fixed.c
@@ -130,17 +130,15 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
 
         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data),
                                GFP_KERNEL);
-        if (drvdata == NULL) {
-                dev_err(&pdev->dev, "Failed to allocate device data\n");
-                ret = -ENOMEM;
-                goto err;
-        }
+        if (!drvdata)
+                return -ENOMEM;
 
-        drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL);
+        drvdata->desc.name = devm_kstrdup(&pdev->dev,
+                                          config->supply_name,
+                                          GFP_KERNEL);
         if (drvdata->desc.name == NULL) {
                 dev_err(&pdev->dev, "Failed to allocate supply name\n");
-                ret = -ENOMEM;
-                goto err;
+                return -ENOMEM;
         }
         drvdata->desc.type = REGULATOR_VOLTAGE;
         drvdata->desc.owner = THIS_MODULE;
@@ -149,13 +147,13 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
         drvdata->desc.enable_time = config->startup_delay;
 
         if (config->input_supply) {
-                drvdata->desc.supply_name = kstrdup(config->input_supply,
-                                                        GFP_KERNEL);
+                drvdata->desc.supply_name = devm_kstrdup(&pdev->dev,
+                                            config->input_supply,
+                                            GFP_KERNEL);
                 if (!drvdata->desc.supply_name) {
                         dev_err(&pdev->dev,
                                 "Failed to allocate input supply\n");
-                        ret = -ENOMEM;
-                        goto err_name;
+                        return -ENOMEM;
                 }
         }
 
@@ -186,11 +184,12 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
         cfg.driver_data = drvdata;
         cfg.of_node = pdev->dev.of_node;
 
-        drvdata->dev = regulator_register(&drvdata->desc, &cfg);
+        drvdata->dev = devm_regulator_register(&pdev->dev, &drvdata->desc,
+                                               &cfg);
         if (IS_ERR(drvdata->dev)) {
                 ret = PTR_ERR(drvdata->dev);
                 dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
-                goto err_input;
+                return ret;
         }
 
         platform_set_drvdata(pdev, drvdata);
@@ -199,24 +198,6 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
                 drvdata->desc.fixed_uV);
 
         return 0;
-
-err_input:
-        kfree(drvdata->desc.supply_name);
-err_name:
-        kfree(drvdata->desc.name);
-err:
-        return ret;
-}
-
-static int reg_fixed_voltage_remove(struct platform_device *pdev)
-{
-        struct fixed_voltage_data *drvdata = platform_get_drvdata(pdev);
-
-        regulator_unregister(drvdata->dev);
-        kfree(drvdata->desc.supply_name);
-        kfree(drvdata->desc.name);
-
-        return 0;
 }
 
 #if defined(CONFIG_OF)
@@ -229,7 +210,6 @@ MODULE_DEVICE_TABLE(of, fixed_of_match);
 
 static struct platform_driver regulator_fixed_voltage_driver = {
         .probe          = reg_fixed_voltage_probe,
-        .remove         = reg_fixed_voltage_remove,
         .driver         = {
                 .name           = "reg-fixed-voltage",
                 .owner          = THIS_MODULE,
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c
index c0a1d00b78c9..989b23b377c0 100644
--- a/drivers/regulator/gpio-regulator.c
+++ b/drivers/regulator/gpio-regulator.c
@@ -136,7 +136,6 @@ static struct gpio_regulator_config *
 of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
 {
         struct gpio_regulator_config *config;
-        struct property *prop;
         const char *regtype;
         int proplen, gpio, i;
         int ret;
@@ -172,22 +171,35 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
         if (!config->gpios)
                 return ERR_PTR(-ENOMEM);
 
+        proplen = of_property_count_u32_elems(np, "gpios-states");
+        /* optional property */
+        if (proplen < 0)
+                proplen = 0;
+
+        if (proplen > 0 && proplen != config->nr_gpios) {
+                dev_warn(dev, "gpios <-> gpios-states mismatch\n");
+                proplen = 0;
+        }
+
         for (i = 0; i < config->nr_gpios; i++) {
                 gpio = of_get_named_gpio(np, "gpios", i);
                 if (gpio < 0)
                         break;
                 config->gpios[i].gpio = gpio;
+                if (proplen > 0) {
+                        of_property_read_u32_index(np, "gpios-states", i, &ret);
+                        if (ret)
+                                config->gpios[i].flags = GPIOF_OUT_INIT_HIGH;
+                }
         }
 
         /* Fetch states. */
-        prop = of_find_property(np, "states", NULL);
-        if (!prop) {
+        proplen = of_property_count_u32_elems(np, "states");
+        if (proplen < 0) {
                 dev_err(dev, "No 'states' property found\n");
                 return ERR_PTR(-EINVAL);
         }
 
-        proplen = prop->length / sizeof(int);
-
         config->states = devm_kzalloc(dev,
                                 sizeof(struct gpio_regulator_state)
                                 * (proplen / 2),
@@ -196,10 +208,10 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
                 return ERR_PTR(-ENOMEM);
 
         for (i = 0; i < proplen / 2; i++) {
-                config->states[i].value =
-                        be32_to_cpup((int *)prop->value + (i * 2));
-                config->states[i].gpios =
-                        be32_to_cpup((int *)prop->value + (i * 2 + 1));
+                of_property_read_u32_index(np, "states", i * 2,
+                                           &config->states[i].value);
+                of_property_read_u32_index(np, "states", i * 2 + 1,
+                                           &config->states[i].gpios);
         }
         config->nr_states = i;
 
@@ -239,10 +251,8 @@ static int gpio_regulator_probe(struct platform_device *pdev)
 
         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct gpio_regulator_data),
                                GFP_KERNEL);
-        if (drvdata == NULL) {
-                dev_err(&pdev->dev, "Failed to allocate device data\n");
+        if (drvdata == NULL)
                 return -ENOMEM;
-        }
 
         drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL);
         if (drvdata->desc.name == NULL) {
diff --git a/drivers/regulator/helpers.c b/drivers/regulator/helpers.c
index e221a271ba56..cbc39096c78d 100644
--- a/drivers/regulator/helpers.c
+++ b/drivers/regulator/helpers.c
@@ -37,10 +37,17 @@ int regulator_is_enabled_regmap(struct regulator_dev *rdev)
         if (ret != 0)
                 return ret;
 
-        if (rdev->desc->enable_is_inverted)
-                return (val & rdev->desc->enable_mask) == 0;
-        else
-                return (val & rdev->desc->enable_mask) != 0;
+        val &= rdev->desc->enable_mask;
+
+        if (rdev->desc->enable_is_inverted) {
+                if (rdev->desc->enable_val)
+                        return val != rdev->desc->enable_val;
+                return val == 0;
+        } else {
+                if (rdev->desc->enable_val)
+                        return val == rdev->desc->enable_val;
+                return val != 0;
+        }
 }
 EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap);
 
@@ -57,10 +64,13 @@ int regulator_enable_regmap(struct regulator_dev *rdev)
 {
         unsigned int val;
 
-        if (rdev->desc->enable_is_inverted)
-                val = 0;
-        else
-                val = rdev->desc->enable_mask;
+        if (rdev->desc->enable_is_inverted) {
+                val = rdev->desc->disable_val;
+        } else {
+                val = rdev->desc->enable_val;
+                if (!val)
+                        val = rdev->desc->enable_mask;
+        }
 
         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
                                   rdev->desc->enable_mask, val);
@@ -80,10 +90,13 @@ int regulator_disable_regmap(struct regulator_dev *rdev)
 {
         unsigned int val;
 
-        if (rdev->desc->enable_is_inverted)
-                val = rdev->desc->enable_mask;
-        else
-                val = 0;
+        if (rdev->desc->enable_is_inverted) {
+                val = rdev->desc->enable_val;
+                if (!val)
+                        val = rdev->desc->enable_mask;
+        } else {
+                val = rdev->desc->disable_val;
+        }
 
         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
                                   rdev->desc->enable_mask, val);
@@ -419,10 +432,13 @@ int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
 {
         unsigned int val;
 
-        if (enable)
-                val = rdev->desc->bypass_mask;
-        else
-                val = 0;
+        if (enable) {
+                val = rdev->desc->bypass_val_on;
+                if (!val)
+                        val = rdev->desc->bypass_mask;
+        } else {
+                val = rdev->desc->bypass_val_off;
+        }
 
         return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
                                   rdev->desc->bypass_mask, val);
diff --git a/drivers/regulator/lp3971.c b/drivers/regulator/lp3971.c
index 3b1102b75071..66fd2330dca0 100644
--- a/drivers/regulator/lp3971.c
+++ b/drivers/regulator/lp3971.c
@@ -327,7 +327,7 @@ static int lp3971_i2c_read(struct i2c_client *i2c, char reg, int count,
                 return -EIO;
         ret = i2c_smbus_read_byte_data(i2c, reg);
         if (ret < 0)
-                return -EIO;
+                return ret;
 
         *dest = ret;
         return 0;
diff --git a/drivers/regulator/lp872x.c b/drivers/regulator/lp872x.c
index 2e4734ff79fc..2e022aabd951 100644
--- a/drivers/regulator/lp872x.c
+++ b/drivers/regulator/lp872x.c
@@ -211,7 +211,7 @@ static int lp872x_get_timestep_usec(struct lp872x *lp)
 
         ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
         if (ret)
-                return -EINVAL;
+                return ret;
 
         val = (val & mask) >> shift;
         if (val >= size)
@@ -229,7 +229,7 @@ static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
         u8 addr, val;
 
         if (time_step_us < 0)
-                return -EINVAL;
+                return time_step_us;
 
         switch (rid) {
         case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
diff --git a/drivers/regulator/max14577.c b/drivers/regulator/max14577.c
index b1078ba3f393..ed60baaeceec 100644
--- a/drivers/regulator/max14577.c
+++ b/drivers/regulator/max14577.c
@@ -1,7 +1,7 @@
 /*
  * max14577.c - Regulator driver for the Maxim 14577
  *
- * Copyright (C) 2013 Samsung Electronics
+ * Copyright (C) 2013,2014 Samsung Electronics
  * Krzysztof Kozlowski <k.kozlowski@samsung.com>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -22,12 +22,6 @@
 #include <linux/mfd/max14577-private.h>
 #include <linux/regulator/of_regulator.h>
 
-struct max14577_regulator {
-        struct device *dev;
-        struct max14577 *max14577;
-        struct regulator_dev **regulators;
-};
-
 static int max14577_reg_is_enabled(struct regulator_dev *rdev)
 {
         int rid = rdev_get_id(rdev);
@@ -166,12 +160,14 @@ static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev)
 
         ret = of_regulator_match(&pdev->dev, np, max14577_regulator_matches,
                         MAX14577_REG_MAX);
-        if (ret < 0) {
+        if (ret < 0)
                 dev_err(&pdev->dev, "Error parsing regulator init data: %d\n", ret);
-                return ret;
-        }
+        else
+                ret = 0;
 
-        return 0;
+        of_node_put(np);
+
+        return ret;
 }
 
 static inline struct regulator_init_data *match_init_data(int index)
diff --git a/drivers/regulator/max1586.c b/drivers/regulator/max1586.c
index e242dd316d36..d23d0577754b 100644
--- a/drivers/regulator/max1586.c
+++ b/drivers/regulator/max1586.c
@@ -46,8 +46,6 @@ struct max1586_data {
 
         unsigned int v3_curr_sel;
         unsigned int v6_curr_sel;
-
-        struct regulator_dev *rdev[0];
 };
 
 /*
@@ -162,14 +160,12 @@ static struct regulator_desc max1586_reg[] = {
 static int max1586_pmic_probe(struct i2c_client *client,
                                         const struct i2c_device_id *i2c_id)
 {
-        struct regulator_dev **rdev;
         struct max1586_platform_data *pdata = dev_get_platdata(&client->dev);
         struct regulator_config config = { };
         struct max1586_data *max1586;
         int i, id;
 
-        max1586 = devm_kzalloc(&client->dev, sizeof(struct max1586_data) +
-                        sizeof(struct regulator_dev *) * (MAX1586_V6 + 1),
+        max1586 = devm_kzalloc(&client->dev, sizeof(struct max1586_data),
                         GFP_KERNEL);
         if (!max1586)
                 return -ENOMEM;
@@ -186,8 +182,9 @@ static int max1586_pmic_probe(struct i2c_client *client,
         max1586->v3_curr_sel = 24; /* 1.3V */
         max1586->v6_curr_sel = 0;
 
-        rdev = max1586->rdev;
         for (i = 0; i < pdata->num_subdevs && i <= MAX1586_V6; i++) {
+                struct regulator_dev *rdev;
+
                 id = pdata->subdevs[i].id;
                 if (!pdata->subdevs[i].platform_data)
                         continue;
@@ -207,12 +204,12 @@ static int max1586_pmic_probe(struct i2c_client *client,
                 config.init_data = pdata->subdevs[i].platform_data;
                 config.driver_data = max1586;
 
-                rdev[i] = devm_regulator_register(&client->dev,
+                rdev = devm_regulator_register(&client->dev,
                                                   &max1586_reg[id], &config);
-                if (IS_ERR(rdev[i])) {
+                if (IS_ERR(rdev)) {
                         dev_err(&client->dev, "failed to register %s\n",
                                 max1586_reg[id].name);
-                        return PTR_ERR(rdev[i]);
+                        return PTR_ERR(rdev);
                 }
         }
 
diff --git a/drivers/regulator/max77686.c b/drivers/regulator/max77686.c
index ae001ccf26f4..ef1af2debbd2 100644
--- a/drivers/regulator/max77686.c
+++ b/drivers/regulator/max77686.c
@@ -65,7 +65,6 @@ enum max77686_ramp_rate {
 };
 
 struct max77686_data {
-        struct regulator_dev *rdev[MAX77686_REGULATORS];
         unsigned int opmode[MAX77686_REGULATORS];
 };
 
@@ -400,7 +399,7 @@ static int max77686_pmic_dt_parse_pdata(struct platform_device *pdev,
         unsigned int i;
 
         pmic_np = iodev->dev->of_node;
-        regulators_np = of_find_node_by_name(pmic_np, "voltage-regulators");
+        regulators_np = of_get_child_by_name(pmic_np, "voltage-regulators");
         if (!regulators_np) {
                 dev_err(&pdev->dev, "could not find regulators sub-node\n");
                 return -EINVAL;
@@ -410,8 +409,7 @@ static int max77686_pmic_dt_parse_pdata(struct platform_device *pdev,
         rdata = devm_kzalloc(&pdev->dev, sizeof(*rdata) *
                              pdata->num_regulators, GFP_KERNEL);
         if (!rdata) {
-                dev_err(&pdev->dev,
-                        "could not allocate memory for regulator data\n");
+                of_node_put(regulators_np);
                 return -ENOMEM;
         }
 
@@ -425,6 +423,7 @@ static int max77686_pmic_dt_parse_pdata(struct platform_device *pdev,
         }
 
         pdata->regulators = rdata;
+        of_node_put(regulators_np);
 
         return 0;
 }
@@ -474,16 +473,18 @@ static int max77686_pmic_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, max77686);
 
         for (i = 0; i < MAX77686_REGULATORS; i++) {
+                struct regulator_dev *rdev;
+
                 config.init_data = pdata->regulators[i].initdata;
                 config.of_node = pdata->regulators[i].of_node;
 
                 max77686->opmode[i] = regulators[i].enable_mask;
-                max77686->rdev[i] = devm_regulator_register(&pdev->dev,
+                rdev = devm_regulator_register(&pdev->dev,
                                                 &regulators[i], &config);
-                if (IS_ERR(max77686->rdev[i])) {
+                if (IS_ERR(rdev)) {
                         dev_err(&pdev->dev,
                                 "regulator init failed for %d\n", i);
-                        return PTR_ERR(max77686->rdev[i]);
+                        return PTR_ERR(rdev);
                 }
         }
 
diff --git a/drivers/regulator/max77693.c b/drivers/regulator/max77693.c
index 5fb899f461d0..653a58b49cdf 100644
--- a/drivers/regulator/max77693.c
+++ b/drivers/regulator/max77693.c
@@ -34,13 +34,6 @@
 
 #define CHGIN_ILIM_STEP_20mA                    20000
 
-struct max77693_pmic_dev {
-        struct device *dev;
-        struct max77693_dev *iodev;
-        int num_regulators;
-        struct regulator_dev **rdev;
-};
-
 /* CHARGER regulator ops */
 /* CHARGER regulator uses two bits for enabling */
 static int max77693_chg_is_enabled(struct regulator_dev *rdev)
@@ -170,19 +163,22 @@ static int max77693_pmic_dt_parse_rdata(struct device *dev,
         struct max77693_regulator_data *tmp;
         int i, matched = 0;
 
-        np = of_find_node_by_name(dev->parent->of_node, "regulators");
+        np = of_get_child_by_name(dev->parent->of_node, "regulators");
         if (!np)
                 return -EINVAL;
 
         rmatch = devm_kzalloc(dev,
                  sizeof(*rmatch) * ARRAY_SIZE(regulators), GFP_KERNEL);
-        if (!rmatch)
+        if (!rmatch) {
+                of_node_put(np);
                 return -ENOMEM;
+        }
 
         for (i = 0; i < ARRAY_SIZE(regulators); i++)
                 rmatch[i].name = regulators[i].name;
 
         matched = of_regulator_match(dev, np, rmatch, ARRAY_SIZE(regulators));
+        of_node_put(np);
         if (matched <= 0)
                 return matched;
         *rdata = devm_kzalloc(dev, sizeof(**rdata) * matched, GFP_KERNEL);
@@ -229,7 +225,6 @@ static int max77693_pmic_init_rdata(struct device *dev,
 static int max77693_pmic_probe(struct platform_device *pdev)
 {
         struct max77693_dev *iodev = dev_get_drvdata(pdev->dev.parent);
-        struct max77693_pmic_dev *max77693_pmic;
         struct max77693_regulator_data *rdata = NULL;
         int num_rdata, i;
         struct regulator_config config;
@@ -240,39 +235,22 @@ static int max77693_pmic_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-        max77693_pmic = devm_kzalloc(&pdev->dev,
-                                sizeof(struct max77693_pmic_dev),
-                                GFP_KERNEL);
-        if (!max77693_pmic)
-                return -ENOMEM;
-
-        max77693_pmic->rdev = devm_kzalloc(&pdev->dev,
-                                sizeof(struct regulator_dev *) * num_rdata,
-                                GFP_KERNEL);
-        if (!max77693_pmic->rdev)
-                return -ENOMEM;
-
-        max77693_pmic->dev = &pdev->dev;
-        max77693_pmic->iodev = iodev;
-        max77693_pmic->num_regulators = num_rdata;
-
         config.dev = &pdev->dev;
         config.regmap = iodev->regmap;
-        config.driver_data = max77693_pmic;
-        platform_set_drvdata(pdev, max77693_pmic);
 
-        for (i = 0; i < max77693_pmic->num_regulators; i++) {
+        for (i = 0; i < num_rdata; i++) {
                 int id = rdata[i].id;
+                struct regulator_dev *rdev;
 
                 config.init_data = rdata[i].initdata;
                 config.of_node = rdata[i].of_node;
 
-                max77693_pmic->rdev[i] = devm_regulator_register(&pdev->dev,
+                rdev = devm_regulator_register(&pdev->dev,
                                                 &regulators[id], &config);
-                if (IS_ERR(max77693_pmic->rdev[i])) {
-                        dev_err(max77693_pmic->dev,
+                if (IS_ERR(rdev)) {
+                        dev_err(&pdev->dev,
                                 "Failed to initialize regulator-%d\n", id);
-                        return PTR_ERR(max77693_pmic->rdev[i]);
+                        return PTR_ERR(rdev);
                 }
         }
 
diff --git a/drivers/regulator/max8649.c b/drivers/regulator/max8649.c
index 7f049c92ee52..3172da847d24 100644
--- a/drivers/regulator/max8649.c
+++ b/drivers/regulator/max8649.c
@@ -49,7 +49,6 @@
 #define MAX8649_RAMP_DOWN       (1 << 1)
 
 struct max8649_regulator_info {
-        struct regulator_dev    *regulator;
         struct device           *dev;
         struct regmap           *regmap;
 
@@ -154,6 +153,7 @@ static int max8649_regulator_probe(struct i2c_client *client,
 {
         struct max8649_platform_data *pdata = dev_get_platdata(&client->dev);
         struct max8649_regulator_info *info = NULL;
+        struct regulator_dev *regulator;
         struct regulator_config config = { };
         unsigned int val;
         unsigned char data;
@@ -234,12 +234,12 @@ static int max8649_regulator_probe(struct i2c_client *client,
         config.driver_data = info;
         config.regmap = info->regmap;
 
-        info->regulator = devm_regulator_register(&client->dev, &dcdc_desc,
+        regulator = devm_regulator_register(&client->dev, &dcdc_desc,
                                                   &config);
-        if (IS_ERR(info->regulator)) {
+        if (IS_ERR(regulator)) {
                 dev_err(info->dev, "failed to register regulator %s\n",
                         dcdc_desc.name);
-                return PTR_ERR(info->regulator);
+                return PTR_ERR(regulator);
         }
 
         return 0;
diff --git a/drivers/regulator/max8660.c b/drivers/regulator/max8660.c
index 8d94d3d7f97f..2fc411188794 100644
--- a/drivers/regulator/max8660.c
+++ b/drivers/regulator/max8660.c
@@ -81,16 +81,17 @@ enum {
 struct max8660 {
         struct i2c_client *client;
         u8 shadow_regs[MAX8660_N_REGS];         /* as chip is write only */
-        struct regulator_dev *rdev[];
 };
 
 static int max8660_write(struct max8660 *max8660, u8 reg, u8 mask, u8 val)
 {
-        static const u8 max8660_addresses[MAX8660_N_REGS] =
-          { 0x10, 0x12, 0x20, 0x23, 0x24, 0x29, 0x2a, 0x32, 0x33, 0x39, 0x80 };
+        static const u8 max8660_addresses[MAX8660_N_REGS] = {
+         0x10, 0x12, 0x20, 0x23, 0x24, 0x29, 0x2a, 0x32, 0x33, 0x39, 0x80
+        };
 
         int ret;
         u8 reg_val = (max8660->shadow_regs[reg] & mask) | val;
+
         dev_vdbg(&max8660->client->dev, "Writing reg %02x with %02x\n",
                         max8660_addresses[reg], reg_val);
 
@@ -112,6 +113,7 @@ static int max8660_dcdc_is_enabled(struct regulator_dev *rdev)
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
         u8 val = max8660->shadow_regs[MAX8660_OVER1];
         u8 mask = (rdev_get_id(rdev) == MAX8660_V3) ? 1 : 4;
+
         return !!(val & mask);
 }
 
@@ -119,6 +121,7 @@ static int max8660_dcdc_enable(struct regulator_dev *rdev)
 {
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
         u8 bit = (rdev_get_id(rdev) == MAX8660_V3) ? 1 : 4;
+
         return max8660_write(max8660, MAX8660_OVER1, 0xff, bit);
 }
 
@@ -126,15 +129,16 @@ static int max8660_dcdc_disable(struct regulator_dev *rdev)
 {
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
         u8 mask = (rdev_get_id(rdev) == MAX8660_V3) ? ~1 : ~4;
+
         return max8660_write(max8660, MAX8660_OVER1, mask, 0);
 }
 
 static int max8660_dcdc_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
-
         u8 reg = (rdev_get_id(rdev) == MAX8660_V3) ? MAX8660_ADTV2 : MAX8660_SDTV2;
         u8 selector = max8660->shadow_regs[reg];
+
         return selector;
 }
 
@@ -207,6 +211,7 @@ static int max8660_ldo67_is_enabled(struct regulator_dev *rdev)
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
         u8 val = max8660->shadow_regs[MAX8660_OVER2];
         u8 mask = (rdev_get_id(rdev) == MAX8660_V6) ? 2 : 4;
+
         return !!(val & mask);
 }
 
@@ -214,6 +219,7 @@ static int max8660_ldo67_enable(struct regulator_dev *rdev)
 {
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
         u8 bit = (rdev_get_id(rdev) == MAX8660_V6) ? 2 : 4;
+
         return max8660_write(max8660, MAX8660_OVER2, 0xff, bit);
 }
 
@@ -221,15 +227,16 @@ static int max8660_ldo67_disable(struct regulator_dev *rdev)
 {
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
         u8 mask = (rdev_get_id(rdev) == MAX8660_V6) ? ~2 : ~4;
+
         return max8660_write(max8660, MAX8660_OVER2, mask, 0);
 }
 
 static int max8660_ldo67_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
-
         u8 shift = (rdev_get_id(rdev) == MAX8660_V6) ? 0 : 4;
         u8 selector = (max8660->shadow_regs[MAX8660_L12VCR] >> shift) & 0xf;
+
         return selector;
 }
 
@@ -330,7 +337,7 @@ static int max8660_pdata_from_dt(struct device *dev,
         struct max8660_subdev_data *sub;
         struct of_regulator_match rmatch[ARRAY_SIZE(max8660_reg)];
 
-        np = of_find_node_by_name(dev->of_node, "regulators");
+        np = of_get_child_by_name(dev->of_node, "regulators");
         if (!np) {
                 dev_err(dev, "missing 'regulators' subnode in DT\n");
                 return -EINVAL;
@@ -340,6 +347,7 @@ static int max8660_pdata_from_dt(struct device *dev,
                 rmatch[i].name = max8660_reg[i].name;
 
         matched = of_regulator_match(dev, np, rmatch, ARRAY_SIZE(rmatch));
+        of_node_put(np);
         if (matched <= 0)
                 return matched;
 
@@ -373,7 +381,6 @@ static inline int max8660_pdata_from_dt(struct device *dev,
 static int max8660_probe(struct i2c_client *client,
                                    const struct i2c_device_id *i2c_id)
 {
-        struct regulator_dev **rdev;
         struct device *dev = &client->dev;
         struct max8660_platform_data *pdata = dev_get_platdata(dev);
         struct regulator_config config = { };
@@ -406,14 +413,11 @@ static int max8660_probe(struct i2c_client *client,
                 return -EINVAL;
         }
 
-        max8660 = devm_kzalloc(dev, sizeof(struct max8660) +
-                        sizeof(struct regulator_dev *) * MAX8660_V_END,
-                        GFP_KERNEL);
+        max8660 = devm_kzalloc(dev, sizeof(struct max8660), GFP_KERNEL);
         if (!max8660)
                 return -ENOMEM;
 
         max8660->client = client;
-        rdev = max8660->rdev;
 
         if (pdata->en34_is_high) {
                 /* Simulate always on */
@@ -481,6 +485,7 @@ static int max8660_probe(struct i2c_client *client,
 
         /* Finally register devices */
         for (i = 0; i < pdata->num_subdevs; i++) {
+                struct regulator_dev *rdev;
 
                 id = pdata->subdevs[i].id;
 
@@ -489,13 +494,13 @@ static int max8660_probe(struct i2c_client *client,
                 config.of_node = of_node[i];
                 config.driver_data = max8660;
 
-                rdev[i] = devm_regulator_register(&client->dev,
+                rdev = devm_regulator_register(&client->dev,
                                                   &max8660_reg[id], &config);
-                if (IS_ERR(rdev[i])) {
-                        ret = PTR_ERR(rdev[i]);
+                if (IS_ERR(rdev)) {
+                        ret = PTR_ERR(rdev);
                         dev_err(&client->dev, "failed to register %s\n",
                                 max8660_reg[id].name);
-                        return PTR_ERR(rdev[i]);
+                        return PTR_ERR(rdev);
                 }
         }
 
diff --git a/drivers/regulator/max8907-regulator.c b/drivers/regulator/max8907-regulator.c
index 0c5fe6c6ac26..9623e9e290bf 100644
--- a/drivers/regulator/max8907-regulator.c
+++ b/drivers/regulator/max8907-regulator.c
@@ -34,7 +34,6 @@
 
 struct max8907_regulator {
         struct regulator_desc desc[MAX8907_NUM_REGULATORS];
-        struct regulator_dev *rdev[MAX8907_NUM_REGULATORS];
 };
 
 #define REG_MBATT() \
@@ -231,7 +230,7 @@ static int max8907_regulator_parse_dt(struct platform_device *pdev)
         if (!np)
                 return 0;
 
-        regulators = of_find_node_by_name(np, "regulators");
+        regulators = of_get_child_by_name(np, "regulators");
         if (!regulators) {
                 dev_err(&pdev->dev, "regulators node not found\n");
                 return -EINVAL;
@@ -292,10 +291,9 @@ static int max8907_regulator_probe(struct platform_device *pdev)
                 return ret;
 
         pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
-        if (!pmic) {
-                dev_err(&pdev->dev, "Failed to alloc pmic\n");
+        if (!pmic)
                 return -ENOMEM;
-        }
+
         platform_set_drvdata(pdev, pmic);
 
         memcpy(pmic->desc, max8907_regulators, sizeof(pmic->desc));
@@ -311,6 +309,8 @@ static int max8907_regulator_probe(struct platform_device *pdev)
         }
 
         for (i = 0; i < MAX8907_NUM_REGULATORS; i++) {
+                struct regulator_dev *rdev;
+
                 config.dev = pdev->dev.parent;
                 if (pdata)
                         idata = pdata->init_data[i];
@@ -350,13 +350,13 @@ static int max8907_regulator_probe(struct platform_device *pdev)
                                 pmic->desc[i].ops = &max8907_out5v_hwctl_ops;
                 }
 
-                pmic->rdev[i] = devm_regulator_register(&pdev->dev,
+                rdev = devm_regulator_register(&pdev->dev,
                                                 &pmic->desc[i], &config);
-                if (IS_ERR(pmic->rdev[i])) {
+                if (IS_ERR(rdev)) {
                         dev_err(&pdev->dev,
                                 "failed to register %s regulator\n",
                                 pmic->desc[i].name);
-                        return PTR_ERR(pmic->rdev[i]);
+                        return PTR_ERR(rdev);
                 }
         }
 
diff --git a/drivers/regulator/max8925-regulator.c b/drivers/regulator/max8925-regulator.c
index 759510789e71..dad2bcd14e96 100644
--- a/drivers/regulator/max8925-regulator.c
+++ b/drivers/regulator/max8925-regulator.c
@@ -36,9 +36,7 @@
 
 struct max8925_regulator_info {
         struct regulator_desc   desc;
-        struct regulator_dev    *regulator;
         struct i2c_client       *i2c;
-        struct max8925_chip     *chip;
 
         int     vol_reg;
         int     enable_reg;
@@ -251,10 +249,11 @@ static int max8925_regulator_dt_init(struct platform_device *pdev,
 {
         struct device_node *nproot, *np;
         int rcount;
+
         nproot = of_node_get(pdev->dev.parent->of_node);
         if (!nproot)
                 return -ENODEV;
-        np = of_find_node_by_name(nproot, "regulators");
+        np = of_get_child_by_name(nproot, "regulators");
         if (!np) {
                 dev_err(&pdev->dev, "failed to find regulators node\n");
                 return -ENODEV;
@@ -264,7 +263,7 @@ static int max8925_regulator_dt_init(struct platform_device *pdev,
                                 &max8925_regulator_matches[ridx], 1);
         of_node_put(np);
         if (rcount < 0)
-                return -ENODEV;
+                return rcount;
         config->init_data =     max8925_regulator_matches[ridx].init_data;
         config->of_node = max8925_regulator_matches[ridx].of_node;
 
@@ -303,7 +302,6 @@ static int max8925_regulator_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
         ri->i2c = chip->i2c;
-        ri->chip = chip;
 
         config.dev = &pdev->dev;
         config.driver_data = ri;
diff --git a/drivers/regulator/max8952.c b/drivers/regulator/max8952.c
index 788e5ae2af1b..d920f5a32ec8 100644
--- a/drivers/regulator/max8952.c
+++ b/drivers/regulator/max8952.c
@@ -48,9 +48,7 @@ enum {
 
 struct max8952_data {
         struct i2c_client       *client;
-        struct device           *dev;
         struct max8952_platform_data *pdata;
-        struct regulator_dev    *rdev;
 
         bool vid0;
         bool vid1;
@@ -59,6 +57,7 @@ struct max8952_data {
 static int max8952_read_reg(struct max8952_data *max8952, u8 reg)
 {
         int ret = i2c_smbus_read_byte_data(max8952->client, reg);
+
         if (ret > 0)
                 ret &= 0xff;
 
@@ -144,10 +143,8 @@ static struct max8952_platform_data *max8952_parse_dt(struct device *dev)
         int i;
 
         pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL);
-        if (!pd) {
-                dev_err(dev, "Failed to allocate platform data\n");
+        if (!pd)
                 return NULL;
-        }
 
         pd->gpio_vid0 = of_get_named_gpio(np, "max8952,vid-gpios", 0);
         pd->gpio_vid1 = of_get_named_gpio(np, "max8952,vid-gpios", 1);
@@ -199,6 +196,7 @@ static int max8952_pmic_probe(struct i2c_client *client,
         struct max8952_platform_data *pdata = dev_get_platdata(&client->dev);
         struct regulator_config config = { };
         struct max8952_data *max8952;
+        struct regulator_dev *rdev;
 
         int ret = 0, err = 0;
 
@@ -219,10 +217,9 @@ static int max8952_pmic_probe(struct i2c_client *client,
                 return -ENOMEM;
 
         max8952->client = client;
-        max8952->dev = &client->dev;
         max8952->pdata = pdata;
 
-        config.dev = max8952->dev;
+        config.dev = &client->dev;
         config.init_data = pdata->reg_data;
         config.driver_data = max8952;
         config.of_node = client->dev.of_node;
@@ -231,11 +228,11 @@ static int max8952_pmic_probe(struct i2c_client *client,
         if (pdata->reg_data->constraints.boot_on)
                 config.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
 
-        max8952->rdev = regulator_register(&regulator, &config);
+        rdev = devm_regulator_register(&client->dev, &regulator, &config);
 
-        if (IS_ERR(max8952->rdev)) {
-                ret = PTR_ERR(max8952->rdev);
-                dev_err(max8952->dev, "regulator init failed (%d)\n", ret);
+        if (IS_ERR(rdev)) {
+                ret = PTR_ERR(rdev);
+                dev_err(&client->dev, "regulator init failed (%d)\n", ret);
                 return ret;
         }
 
@@ -263,7 +260,7 @@ static int max8952_pmic_probe(struct i2c_client *client,
                 err = 3;
 
         if (err) {
-                dev_warn(max8952->dev, "VID0/1 gpio invalid: "
+                dev_warn(&client->dev, "VID0/1 gpio invalid: "
                                 "DVS not available.\n");
                 max8952->vid0 = 0;
                 max8952->vid1 = 0;
@@ -274,7 +271,7 @@ static int max8952_pmic_probe(struct i2c_client *client,
                 /* Disable Pulldown of EN only */
                 max8952_write_reg(max8952, MAX8952_REG_CONTROL, 0x60);
 
-                dev_err(max8952->dev, "DVS modes disabled because VID0 and VID1"
+                dev_err(&client->dev, "DVS modes disabled because VID0 and VID1"
                                 " do not have proper controls.\n");
         } else {
                 /*
@@ -321,9 +318,6 @@ static int max8952_pmic_remove(struct i2c_client *client)
 {
         struct max8952_data *max8952 = i2c_get_clientdata(client);
         struct max8952_platform_data *pdata = max8952->pdata;
-        struct regulator_dev *rdev = max8952->rdev;
-
-        regulator_unregister(rdev);
 
         gpio_free(pdata->gpio_vid0);
         gpio_free(pdata->gpio_vid1);
diff --git a/drivers/regulator/max8973-regulator.c b/drivers/regulator/max8973-regulator.c
index 892aa1e5b96c..dbedf1768db0 100644
--- a/drivers/regulator/max8973-regulator.c
+++ b/drivers/regulator/max8973-regulator.c
@@ -93,7 +93,6 @@
 struct max8973_chip {
         struct device *dev;
         struct regulator_desc desc;
-        struct regulator_dev *rdev;
         struct regmap *regmap;
         bool enable_external_control;
         int dvs_gpio;
@@ -379,10 +378,8 @@ static int max8973_probe(struct i2c_client *client,
         }
 
         max = devm_kzalloc(&client->dev, sizeof(*max), GFP_KERNEL);
-        if (!max) {
-                dev_err(&client->dev, "Memory allocation for max failed\n");
+        if (!max)
                 return -ENOMEM;
-        }
 
         max->regmap = devm_regmap_init_i2c(client, &max8973_regmap_config);
         if (IS_ERR(max->regmap)) {
@@ -474,7 +471,6 @@ static int max8973_probe(struct i2c_client *client,
                 return ret;
         }
 
-        max->rdev = rdev;
         return 0;
 }
 
diff --git a/drivers/regulator/max8997.c b/drivers/regulator/max8997.c
index 2d618fc9c1af..90b4c530dee5 100644
--- a/drivers/regulator/max8997.c
+++ b/drivers/regulator/max8997.c
@@ -38,7 +38,6 @@ struct max8997_data {
         struct device *dev;
         struct max8997_dev *iodev;
         int num_regulators;
-        struct regulator_dev **rdev;
         int ramp_delay; /* in mV/us */
 
         bool buck1_gpiodvs;
@@ -924,7 +923,7 @@ static int max8997_pmic_dt_parse_pdata(struct platform_device *pdev,
                 return -ENODEV;
         }
 
-        regulators_np = of_find_node_by_name(pmic_np, "regulators");
+        regulators_np = of_get_child_by_name(pmic_np, "regulators");
         if (!regulators_np) {
                 dev_err(&pdev->dev, "could not find regulators sub-node\n");
                 return -EINVAL;
@@ -937,7 +936,6 @@ static int max8997_pmic_dt_parse_pdata(struct platform_device *pdev,
                                 pdata->num_regulators, GFP_KERNEL);
         if (!rdata) {
                 of_node_put(regulators_np);
-                dev_err(&pdev->dev, "could not allocate memory for regulator data\n");
                 return -ENOMEM;
         }
 
@@ -1030,10 +1028,10 @@ static int max8997_pmic_probe(struct platform_device *pdev)
         struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
         struct max8997_platform_data *pdata = iodev->pdata;
         struct regulator_config config = { };
-        struct regulator_dev **rdev;
+        struct regulator_dev *rdev;
         struct max8997_data *max8997;
         struct i2c_client *i2c;
-        int i, ret, size, nr_dvs;
+        int i, ret, nr_dvs;
         u8 max_buck1 = 0, max_buck2 = 0, max_buck5 = 0;
 
         if (!pdata) {
@@ -1052,12 +1050,6 @@ static int max8997_pmic_probe(struct platform_device *pdev)
         if (!max8997)
                 return -ENOMEM;
 
-        size = sizeof(struct regulator_dev *) * pdata->num_regulators;
-        max8997->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
-        if (!max8997->rdev)
-                return -ENOMEM;
-
-        rdev = max8997->rdev;
         max8997->dev = &pdev->dev;
         max8997->iodev = iodev;
         max8997->num_regulators = pdata->num_regulators;
@@ -1205,12 +1197,12 @@ static int max8997_pmic_probe(struct platform_device *pdev)
                 config.driver_data = max8997;
                 config.of_node = pdata->regulators[i].reg_node;
 
-                rdev[i] = devm_regulator_register(&pdev->dev, &regulators[id],
-                                                  &config);
-                if (IS_ERR(rdev[i])) {
+                rdev = devm_regulator_register(&pdev->dev, &regulators[id],
+                                               &config);
+                if (IS_ERR(rdev)) {
                         dev_err(max8997->dev, "regulator init failed for %d\n",
                                         id);
-                        return PTR_ERR(rdev[i]);
+                        return PTR_ERR(rdev);
                 }
         }
 
diff --git a/drivers/regulator/max8998.c b/drivers/regulator/max8998.c
index ae3f0656feb0..961091b46557 100644
--- a/drivers/regulator/max8998.c
+++ b/drivers/regulator/max8998.c
@@ -40,7 +40,6 @@ struct max8998_data {
         struct device           *dev;
         struct max8998_dev      *iodev;
         int                     num_regulators;
-        struct regulator_dev    **rdev;
         u8                      buck1_vol[4]; /* voltages for selection */
         u8                      buck2_vol[2];
         unsigned int            buck1_idx; /* index to last changed voltage */
@@ -674,8 +673,10 @@ static int max8998_pmic_dt_parse_pdata(struct max8998_dev *iodev,
 
         rdata = devm_kzalloc(iodev->dev, sizeof(*rdata) *
                                 pdata->num_regulators, GFP_KERNEL);
-        if (!rdata)
+        if (!rdata) {
+                of_node_put(regulators_np);
                 return -ENOMEM;
+        }
 
         pdata->regulators = rdata;
         for (i = 0; i < ARRAY_SIZE(regulators); ++i) {
@@ -692,6 +693,9 @@ static int max8998_pmic_dt_parse_pdata(struct max8998_dev *iodev,
         }
         pdata->num_regulators = rdata - pdata->regulators;
 
+        of_node_put(reg_np);
+        of_node_put(regulators_np);
+
         ret = max8998_pmic_dt_parse_dvs_gpio(iodev, pdata, pmic_np);
         if (ret)
                 return -EINVAL;
@@ -741,10 +745,10 @@ static int max8998_pmic_probe(struct platform_device *pdev)
         struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent);
         struct max8998_platform_data *pdata = iodev->pdata;
         struct regulator_config config = { };
-        struct regulator_dev **rdev;
+        struct regulator_dev *rdev;
         struct max8998_data *max8998;
         struct i2c_client *i2c;
-        int i, ret, size;
+        int i, ret;
         unsigned int v;
 
         if (!pdata) {
@@ -763,12 +767,6 @@ static int max8998_pmic_probe(struct platform_device *pdev)
         if (!max8998)
                 return -ENOMEM;
 
-        size = sizeof(struct regulator_dev *) * pdata->num_regulators;
-        max8998->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
-        if (!max8998->rdev)
-                return -ENOMEM;
-
-        rdev = max8998->rdev;
         max8998->dev = &pdev->dev;
         max8998->iodev = iodev;
         max8998->num_regulators = pdata->num_regulators;
@@ -872,13 +870,12 @@ static int max8998_pmic_probe(struct platform_device *pdev)
                 config.init_data = pdata->regulators[i].initdata;
                 config.driver_data = max8998;
 
-                rdev[i] = devm_regulator_register(&pdev->dev,
-                                                  &regulators[index], &config);
-                if (IS_ERR(rdev[i])) {
-                        ret = PTR_ERR(rdev[i]);
+                rdev = devm_regulator_register(&pdev->dev, &regulators[index],
+                                               &config);
+                if (IS_ERR(rdev)) {
+                        ret = PTR_ERR(rdev);
                         dev_err(max8998->dev, "regulator %s init failed (%d)\n",
                                                 regulators[index].name, ret);
-                        rdev[i] = NULL;
                         return ret;
                 }
         }
diff --git a/drivers/regulator/mc13xxx-regulator-core.c b/drivers/regulator/mc13xxx-regulator-core.c
index da4859282302..05b971726ffa 100644
--- a/drivers/regulator/mc13xxx-regulator-core.c
+++ b/drivers/regulator/mc13xxx-regulator-core.c
@@ -167,8 +167,10 @@ int mc13xxx_get_num_regulators_dt(struct platform_device *pdev)
         struct device_node *parent;
         int num;
 
-        of_node_get(pdev->dev.parent->of_node);
-        parent = of_find_node_by_name(pdev->dev.parent->of_node, "regulators");
+        if (!pdev->dev.parent->of_node)
+                return -ENODEV;
+
+        parent = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
         if (!parent)
                 return -ENODEV;
 
@@ -187,8 +189,10 @@ struct mc13xxx_regulator_init_data *mc13xxx_parse_regulators_dt(
         struct device_node *parent, *child;
         int i, parsed = 0;
 
-        of_node_get(pdev->dev.parent->of_node);
-        parent = of_find_node_by_name(pdev->dev.parent->of_node, "regulators");
+        if (!pdev->dev.parent->of_node)
+                return NULL;
+
+        parent = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
         if (!parent)
                 return NULL;
 
diff --git a/drivers/regulator/pfuze100-regulator.c b/drivers/regulator/pfuze100-regulator.c
index ab174f20ca11..67e678c4301c 100644
--- a/drivers/regulator/pfuze100-regulator.c
+++ b/drivers/regulator/pfuze100-regulator.c
@@ -56,6 +56,8 @@
 #define PFUZE100_VGEN5VOL       0x70
 #define PFUZE100_VGEN6VOL       0x71
 
+enum chips { PFUZE100, PFUZE200 };
+
 struct pfuze_regulator {
         struct regulator_desc desc;
         unsigned char stby_reg;
@@ -63,6 +65,7 @@ struct pfuze_regulator {
 };
 
 struct pfuze_chip {
+        int     chip_id;
         struct regmap *regmap;
         struct device *dev;
         struct pfuze_regulator regulator_descs[PFUZE100_MAX_REGULATOR];
@@ -78,21 +81,23 @@ static const int pfuze100_vsnvs[] = {
 };
 
 static const struct i2c_device_id pfuze_device_id[] = {
-        {.name = "pfuze100"},
-        {},
+        {.name = "pfuze100", .driver_data = PFUZE100},
+        {.name = "pfuze200", .driver_data = PFUZE200},
+        { }
 };
 MODULE_DEVICE_TABLE(i2c, pfuze_device_id);
 
 static const struct of_device_id pfuze_dt_ids[] = {
-        { .compatible = "fsl,pfuze100" },
-        {},
+        { .compatible = "fsl,pfuze100", .data = (void *)PFUZE100},
+        { .compatible = "fsl,pfuze200", .data = (void *)PFUZE200},
+        { }
 };
 MODULE_DEVICE_TABLE(of, pfuze_dt_ids);
 
 static int pfuze100_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
 {
         struct pfuze_chip *pfuze100 = rdev_get_drvdata(rdev);
-        int id = rdev->desc->id;
+        int id = rdev_get_id(rdev);
         unsigned int ramp_bits;
         int ret;
 
@@ -139,14 +144,14 @@ static struct regulator_ops pfuze100_swb_regulator_ops = {
 
 };
 
-#define PFUZE100_FIXED_REG(_name, base, voltage)        \
-        [PFUZE100_ ## _name] = {        \
+#define PFUZE100_FIXED_REG(_chip, _name, base, voltage) \
+        [_chip ## _ ## _name] = {       \
                 .desc = {       \
                         .name = #_name, \
                         .n_voltages = 1,        \
                         .ops = &pfuze100_fixed_regulator_ops,   \
                         .type = REGULATOR_VOLTAGE,      \
-                        .id = PFUZE100_ ## _name,       \
+                        .id = _chip ## _ ## _name,      \
                         .owner = THIS_MODULE,   \
                         .min_uV = (voltage),    \
                         .enable_reg = (base),   \
@@ -154,14 +159,14 @@ static struct regulator_ops pfuze100_swb_regulator_ops = {
                 },      \
         }
 
-#define PFUZE100_SW_REG(_name, base, min, max, step)    \
-        [PFUZE100_ ## _name] = {        \
+#define PFUZE100_SW_REG(_chip, _name, base, min, max, step)     \
+        [_chip ## _ ## _name] = {       \
                 .desc = {       \
                         .name = #_name,\
                         .n_voltages = ((max) - (min)) / (step) + 1,     \
                         .ops = &pfuze100_sw_regulator_ops,      \
                         .type = REGULATOR_VOLTAGE,      \
-                        .id = PFUZE100_ ## _name,       \
+                        .id = _chip ## _ ## _name,      \
                         .owner = THIS_MODULE,   \
                         .min_uV = (min),        \
                         .uV_step = (step),      \
@@ -172,14 +177,14 @@ static struct regulator_ops pfuze100_swb_regulator_ops = {
                 .stby_mask = 0x3f,      \
         }
 
-#define PFUZE100_SWB_REG(_name, base, mask, voltages)   \
-        [PFUZE100_ ## _name] = {        \
+#define PFUZE100_SWB_REG(_chip, _name, base, mask, voltages)    \
+        [_chip ## _ ##  _name] = {      \
                 .desc = {       \
                         .name = #_name, \
                         .n_voltages = ARRAY_SIZE(voltages),     \
                         .ops = &pfuze100_swb_regulator_ops,     \
                         .type = REGULATOR_VOLTAGE,      \
-                        .id = PFUZE100_ ## _name,       \
+                        .id = _chip ## _ ## _name,      \
                         .owner = THIS_MODULE,   \
                         .volt_table = voltages, \
                         .vsel_reg = (base),     \
@@ -187,14 +192,14 @@ static struct regulator_ops pfuze100_swb_regulator_ops = {
                 },      \
         }
 
-#define PFUZE100_VGEN_REG(_name, base, min, max, step)  \
-        [PFUZE100_ ## _name] = {        \
+#define PFUZE100_VGEN_REG(_chip, _name, base, min, max, step)   \
+        [_chip ## _ ## _name] = {       \
                 .desc = {       \
                         .name = #_name, \
                         .n_voltages = ((max) - (min)) / (step) + 1,     \
                         .ops = &pfuze100_ldo_regulator_ops,     \
                         .type = REGULATOR_VOLTAGE,      \
-                        .id = PFUZE100_ ## _name,       \
+                        .id = _chip ## _ ## _name,      \
                         .owner = THIS_MODULE,   \
                         .min_uV = (min),        \
                         .uV_step = (step),      \
@@ -207,25 +212,45 @@ static struct regulator_ops pfuze100_swb_regulator_ops = {
                 .stby_mask = 0x20,      \
         }
 
+/* PFUZE100 */
 static struct pfuze_regulator pfuze100_regulators[] = {
-        PFUZE100_SW_REG(SW1AB, PFUZE100_SW1ABVOL, 300000, 1875000, 25000),
-        PFUZE100_SW_REG(SW1C, PFUZE100_SW1CVOL, 300000, 1875000, 25000),
-        PFUZE100_SW_REG(SW2, PFUZE100_SW2VOL, 400000, 1975000, 25000),
-        PFUZE100_SW_REG(SW3A, PFUZE100_SW3AVOL, 400000, 1975000, 25000),
-        PFUZE100_SW_REG(SW3B, PFUZE100_SW3BVOL, 400000, 1975000, 25000),
-        PFUZE100_SW_REG(SW4, PFUZE100_SW4VOL, 400000, 1975000, 25000),
-        PFUZE100_SWB_REG(SWBST, PFUZE100_SWBSTCON1, 0x3 , pfuze100_swbst),
-        PFUZE100_SWB_REG(VSNVS, PFUZE100_VSNVSVOL, 0x7, pfuze100_vsnvs),
-        PFUZE100_FIXED_REG(VREFDDR, PFUZE100_VREFDDRCON, 750000),
-        PFUZE100_VGEN_REG(VGEN1, PFUZE100_VGEN1VOL, 800000, 1550000, 50000),
-        PFUZE100_VGEN_REG(VGEN2, PFUZE100_VGEN2VOL, 800000, 1550000, 50000),
-        PFUZE100_VGEN_REG(VGEN3, PFUZE100_VGEN3VOL, 1800000, 3300000, 100000),
-        PFUZE100_VGEN_REG(VGEN4, PFUZE100_VGEN4VOL, 1800000, 3300000, 100000),
-        PFUZE100_VGEN_REG(VGEN5, PFUZE100_VGEN5VOL, 1800000, 3300000, 100000),
-        PFUZE100_VGEN_REG(VGEN6, PFUZE100_VGEN6VOL, 1800000, 3300000, 100000),
+        PFUZE100_SW_REG(PFUZE100, SW1AB, PFUZE100_SW1ABVOL, 300000, 1875000, 25000),
+        PFUZE100_SW_REG(PFUZE100, SW1C, PFUZE100_SW1CVOL, 300000, 1875000, 25000),
+        PFUZE100_SW_REG(PFUZE100, SW2, PFUZE100_SW2VOL, 400000, 1975000, 25000),
+        PFUZE100_SW_REG(PFUZE100, SW3A, PFUZE100_SW3AVOL, 400000, 1975000, 25000),
+        PFUZE100_SW_REG(PFUZE100, SW3B, PFUZE100_SW3BVOL, 400000, 1975000, 25000),
+        PFUZE100_SW_REG(PFUZE100, SW4, PFUZE100_SW4VOL, 400000, 1975000, 25000),
+        PFUZE100_SWB_REG(PFUZE100, SWBST, PFUZE100_SWBSTCON1, 0x3 , pfuze100_swbst),
+        PFUZE100_SWB_REG(PFUZE100, VSNVS, PFUZE100_VSNVSVOL, 0x7, pfuze100_vsnvs),
+        PFUZE100_FIXED_REG(PFUZE100, VREFDDR, PFUZE100_VREFDDRCON, 750000),
+        PFUZE100_VGEN_REG(PFUZE100, VGEN1, PFUZE100_VGEN1VOL, 800000, 1550000, 50000),
+        PFUZE100_VGEN_REG(PFUZE100, VGEN2, PFUZE100_VGEN2VOL, 800000, 1550000, 50000),
+        PFUZE100_VGEN_REG(PFUZE100, VGEN3, PFUZE100_VGEN3VOL, 1800000, 3300000, 100000),
+        PFUZE100_VGEN_REG(PFUZE100, VGEN4, PFUZE100_VGEN4VOL, 1800000, 3300000, 100000),
+        PFUZE100_VGEN_REG(PFUZE100, VGEN5, PFUZE100_VGEN5VOL, 1800000, 3300000, 100000),
+        PFUZE100_VGEN_REG(PFUZE100, VGEN6, PFUZE100_VGEN6VOL, 1800000, 3300000, 100000),
+};
+
+static struct pfuze_regulator pfuze200_regulators[] = {
+        PFUZE100_SW_REG(PFUZE200, SW1AB, PFUZE100_SW1ABVOL, 300000, 1875000, 25000),
+        PFUZE100_SW_REG(PFUZE200, SW2, PFUZE100_SW2VOL, 400000, 1975000, 25000),
+        PFUZE100_SW_REG(PFUZE200, SW3A, PFUZE100_SW3AVOL, 400000, 1975000, 25000),
+        PFUZE100_SW_REG(PFUZE200, SW3B, PFUZE100_SW3BVOL, 400000, 1975000, 25000),
+        PFUZE100_SWB_REG(PFUZE200, SWBST, PFUZE100_SWBSTCON1, 0x3 , pfuze100_swbst),
+        PFUZE100_SWB_REG(PFUZE200, VSNVS, PFUZE100_VSNVSVOL, 0x7, pfuze100_vsnvs),
+        PFUZE100_FIXED_REG(PFUZE200, VREFDDR, PFUZE100_VREFDDRCON, 750000),
+        PFUZE100_VGEN_REG(PFUZE200, VGEN1, PFUZE100_VGEN1VOL, 800000, 1550000, 50000),
+        PFUZE100_VGEN_REG(PFUZE200, VGEN2, PFUZE100_VGEN2VOL, 800000, 1550000, 50000),
+        PFUZE100_VGEN_REG(PFUZE200, VGEN3, PFUZE100_VGEN3VOL, 1800000, 3300000, 100000),
+        PFUZE100_VGEN_REG(PFUZE200, VGEN4, PFUZE100_VGEN4VOL, 1800000, 3300000, 100000),
+        PFUZE100_VGEN_REG(PFUZE200, VGEN5, PFUZE100_VGEN5VOL, 1800000, 3300000, 100000),
+        PFUZE100_VGEN_REG(PFUZE200, VGEN6, PFUZE100_VGEN6VOL, 1800000, 3300000, 100000),
 };
 
+static struct pfuze_regulator *pfuze_regulators;
+
 #ifdef CONFIG_OF
+/* PFUZE100 */
 static struct of_regulator_match pfuze100_matches[] = {
         { .name = "sw1ab",      },
         { .name = "sw1c",       },
@@ -244,24 +269,56 @@ static struct of_regulator_match pfuze100_matches[] = {
         { .name = "vgen6",      },
 };
 
+/* PFUZE200 */
+static struct of_regulator_match pfuze200_matches[] = {
+
+        { .name = "sw1ab",      },
+        { .name = "sw2",        },
+        { .name = "sw3a",       },
+        { .name = "sw3b",       },
+        { .name = "swbst",      },
+        { .name = "vsnvs",      },
+        { .name = "vrefddr",    },
+        { .name = "vgen1",      },
+        { .name = "vgen2",      },
+        { .name = "vgen3",      },
+        { .name = "vgen4",      },
+        { .name = "vgen5",      },
+        { .name = "vgen6",      },
+};
+
+static struct of_regulator_match *pfuze_matches;
+
 static int pfuze_parse_regulators_dt(struct pfuze_chip *chip)
 {
         struct device *dev = chip->dev;
         struct device_node *np, *parent;
         int ret;
 
-        np = of_node_get(dev->parent->of_node);
+        np = of_node_get(dev->of_node);
         if (!np)
-                return 0;
+                return -EINVAL;
 
-        parent = of_find_node_by_name(np, "regulators");
+        parent = of_get_child_by_name(np, "regulators");
         if (!parent) {
                 dev_err(dev, "regulators node not found\n");
                 return -EINVAL;
         }
 
-        ret = of_regulator_match(dev, parent, pfuze100_matches,
-                                 ARRAY_SIZE(pfuze100_matches));
+        switch (chip->chip_id) {
+        case PFUZE200:
+                pfuze_matches = pfuze200_matches;
+                ret = of_regulator_match(dev, parent, pfuze200_matches,
+                                         ARRAY_SIZE(pfuze200_matches));
+                break;
+
+        case PFUZE100:
+        default:
+                pfuze_matches = pfuze100_matches;
+                ret = of_regulator_match(dev, parent, pfuze100_matches,
+                                         ARRAY_SIZE(pfuze100_matches));
+                break;
+        }
 
         of_node_put(parent);
         if (ret < 0) {
@@ -275,12 +332,12 @@ static int pfuze_parse_regulators_dt(struct pfuze_chip *chip)
 
 static inline struct regulator_init_data *match_init_data(int index)
 {
-        return pfuze100_matches[index].init_data;
+        return pfuze_matches[index].init_data;
 }
 
 static inline struct device_node *match_of_node(int index)
 {
-        return pfuze100_matches[index].of_node;
+        return pfuze_matches[index].of_node;
 }
 #else
 static int pfuze_parse_regulators_dt(struct pfuze_chip *chip)
@@ -308,16 +365,14 @@ static int pfuze_identify(struct pfuze_chip *pfuze_chip)
         if (ret)
                 return ret;
 
-        switch (value & 0x0f) {
-        /*
-         * Freescale misprogrammed 1-3% of parts prior to week 8 of 2013
-         * as ID=8
-         */
-        case 0x8:
+        if (((value & 0x0f) == 0x8) && (pfuze_chip->chip_id == PFUZE100)) {
+                /*
+                 * Freescale misprogrammed 1-3% of parts prior to week 8 of 2013
+                 * as ID=8 in PFUZE100
+                 */
                 dev_info(pfuze_chip->dev, "Assuming misprogrammed ID=0x8");
-        case 0x0:
-                break;
-        default:
+        } else if ((value & 0x0f) != pfuze_chip->chip_id) {
+                /* device id NOT match with your setting */
                 dev_warn(pfuze_chip->dev, "Illegal ID: %x\n", value);
                 return -ENODEV;
         }
@@ -353,17 +408,31 @@ static int pfuze100_regulator_probe(struct i2c_client *client,
             dev_get_platdata(&client->dev);
         struct regulator_config config = { };
         int i, ret;
+        const struct of_device_id *match;
+        u32 regulator_num;
+        u32 sw_check_start, sw_check_end;
 
         pfuze_chip = devm_kzalloc(&client->dev, sizeof(*pfuze_chip),
                         GFP_KERNEL);
         if (!pfuze_chip)
                 return -ENOMEM;
 
-        i2c_set_clientdata(client, pfuze_chip);
-
-        memcpy(pfuze_chip->regulator_descs, pfuze100_regulators,
-                sizeof(pfuze_chip->regulator_descs));
+        if (client->dev.of_node) {
+                match = of_match_device(of_match_ptr(pfuze_dt_ids),
+                                &client->dev);
+                if (!match) {
+                        dev_err(&client->dev, "Error: No device match found\n");
+                        return -ENODEV;
+                }
+                pfuze_chip->chip_id = (int)(long)match->data;
+        } else if (id) {
+                pfuze_chip->chip_id = id->driver_data;
+        } else {
+                dev_err(&client->dev, "No dts match or id table match found\n");
+                return -ENODEV;
+        }
 
+        i2c_set_clientdata(client, pfuze_chip);
         pfuze_chip->dev = &client->dev;
 
         pfuze_chip->regmap = devm_regmap_init_i2c(client, &pfuze_regmap_config);
@@ -380,11 +449,34 @@ static int pfuze100_regulator_probe(struct i2c_client *client,
                 return ret;
         }
 
+        /* use the right regulators after identify the right device */
+        switch (pfuze_chip->chip_id) {
+        case PFUZE200:
+                pfuze_regulators = pfuze200_regulators;
+                regulator_num = ARRAY_SIZE(pfuze200_regulators);
+                sw_check_start = PFUZE200_SW2;
+                sw_check_end = PFUZE200_SW3B;
+                break;
+
+        case PFUZE100:
+        default:
+                pfuze_regulators = pfuze100_regulators;
+                regulator_num = ARRAY_SIZE(pfuze100_regulators);
+                sw_check_start = PFUZE100_SW2;
+                sw_check_end = PFUZE100_SW4;
+                break;
+        }
+        dev_info(&client->dev, "pfuze%s found.\n",
+                (pfuze_chip->chip_id == PFUZE100) ? "100" : "200");
+
+        memcpy(pfuze_chip->regulator_descs, pfuze_regulators,
+                sizeof(pfuze_chip->regulator_descs));
+
         ret = pfuze_parse_regulators_dt(pfuze_chip);
         if (ret)
                 return ret;
 
-        for (i = 0; i < PFUZE100_MAX_REGULATOR; i++) {
+        for (i = 0; i < regulator_num; i++) {
                 struct regulator_init_data *init_data;
                 struct regulator_desc *desc;
                 int val;
@@ -397,7 +489,7 @@ static int pfuze100_regulator_probe(struct i2c_client *client,
                         init_data = match_init_data(i);
 
                 /* SW2~SW4 high bit check and modify the voltage value table */
-                if (i > PFUZE100_SW1C && i < PFUZE100_SWBST) {
+                if (i >= sw_check_start && i <= sw_check_end) {
                         regmap_read(pfuze_chip->regmap, desc->vsel_reg, &val);
                         if (val & 0x40) {
                                 desc->min_uV = 800000;
@@ -415,7 +507,7 @@ static int pfuze100_regulator_probe(struct i2c_client *client,
                         devm_regulator_register(&client->dev, desc, &config);
                 if (IS_ERR(pfuze_chip->regulators[i])) {
                         dev_err(&client->dev, "register regulator%s failed\n",
-                                pfuze100_regulators[i].desc.name);
+                                pfuze_regulators[i].desc.name);
                         return PTR_ERR(pfuze_chip->regulators[i]);
                 }
         }
@@ -435,6 +527,6 @@ static struct i2c_driver pfuze_driver = {
 module_i2c_driver(pfuze_driver);
 
 MODULE_AUTHOR("Robin Gong <b38343@freescale.com>");
-MODULE_DESCRIPTION("Regulator Driver for Freescale PFUZE100 PMIC");
+MODULE_DESCRIPTION("Regulator Driver for Freescale PFUZE100/PFUZE200 PMIC");
 MODULE_LICENSE("GPL v2");
 MODULE_ALIAS("i2c:pfuze100-regulator");
diff --git a/drivers/regulator/rc5t583-regulator.c b/drivers/regulator/rc5t583-regulator.c
index b58affb33143..4c414ae109ae 100644
--- a/drivers/regulator/rc5t583-regulator.c
+++ b/drivers/regulator/rc5t583-regulator.c
@@ -119,7 +119,6 @@ static int rc5t583_regulator_probe(struct platform_device *pdev)
 {
         struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent);
         struct rc5t583_platform_data *pdata = dev_get_platdata(rc5t583->dev);
-        struct regulator_init_data *reg_data;
         struct regulator_config config = { };
         struct rc5t583_regulator *reg = NULL;
         struct rc5t583_regulator *regs;
@@ -135,19 +134,11 @@ static int rc5t583_regulator_probe(struct platform_device *pdev)
 
         regs = devm_kzalloc(&pdev->dev, RC5T583_REGULATOR_MAX *
                         sizeof(struct rc5t583_regulator), GFP_KERNEL);
-        if (!regs) {
-                dev_err(&pdev->dev, "Memory allocation failed exiting..\n");
+        if (!regs)
                 return -ENOMEM;
-        }
 
 
         for (id = 0; id < RC5T583_REGULATOR_MAX; ++id) {
-                reg_data = pdata->reg_init_data[id];
-
-                /* No need to register if there is no regulator data */
-                if (!reg_data)
-                        continue;
-
                 reg = &regs[id];
                 ri = &rc5t583_reg_info[id];
                 reg->reg_info = ri;
@@ -169,7 +160,7 @@ static int rc5t583_regulator_probe(struct platform_device *pdev)
 
 skip_ext_pwr_config:
                 config.dev = &pdev->dev;
-                config.init_data = reg_data;
+                config.init_data = pdata->reg_init_data[id];
                 config.driver_data = reg;
                 config.regmap = rc5t583->regmap;
 
diff --git a/drivers/regulator/s2mpa01.c b/drivers/regulator/s2mpa01.c
new file mode 100644
index 000000000000..808b3aa7a42c
--- /dev/null
+++ b/drivers/regulator/s2mpa01.c
@@ -0,0 +1,481 @@
+/*
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd
+ *              http://www.samsung.com
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/bug.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/regmap.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/regulator/of_regulator.h>
+#include <linux/mfd/samsung/core.h>
+#include <linux/mfd/samsung/s2mpa01.h>
+
+#define S2MPA01_REGULATOR_CNT ARRAY_SIZE(regulators)
+
+struct s2mpa01_info {
+        int ramp_delay24;
+        int ramp_delay3;
+        int ramp_delay5;
+        int ramp_delay16;
+        int ramp_delay7;
+        int ramp_delay8910;
+};
+
+static int get_ramp_delay(int ramp_delay)
+{
+        unsigned char cnt = 0;
+
+        ramp_delay /= 6250;
+
+        while (true) {
+                ramp_delay = ramp_delay >> 1;
+                if (ramp_delay == 0)
+                        break;
+                cnt++;
+        }
+
+        if (cnt > 3)
+                cnt = 3;
+
+        return cnt;
+}
+
+static int s2mpa01_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
+                                   unsigned int old_selector,
+                                   unsigned int new_selector)
+{
+        struct s2mpa01_info *s2mpa01 = rdev_get_drvdata(rdev);
+        unsigned int ramp_delay = 0;
+        int old_volt, new_volt;
+
+        switch (rdev->desc->id) {
+        case S2MPA01_BUCK2:
+        case S2MPA01_BUCK4:
+                ramp_delay = s2mpa01->ramp_delay24;
+                break;
+        case S2MPA01_BUCK3:
+                ramp_delay = s2mpa01->ramp_delay3;
+                break;
+        case S2MPA01_BUCK5:
+                ramp_delay = s2mpa01->ramp_delay5;
+                break;
+        case S2MPA01_BUCK1:
+        case S2MPA01_BUCK6:
+                ramp_delay = s2mpa01->ramp_delay16;
+                break;
+        case S2MPA01_BUCK7:
+                ramp_delay = s2mpa01->ramp_delay7;
+                break;
+        case S2MPA01_BUCK8:
+        case S2MPA01_BUCK9:
+        case S2MPA01_BUCK10:
+                ramp_delay = s2mpa01->ramp_delay8910;
+                break;
+        }
+
+        if (ramp_delay == 0)
+                ramp_delay = rdev->desc->ramp_delay;
+
+        old_volt = rdev->desc->min_uV + (rdev->desc->uV_step * old_selector);
+        new_volt = rdev->desc->min_uV + (rdev->desc->uV_step * new_selector);
+
+        return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
+}
+
+static int s2mpa01_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
+{
+        struct s2mpa01_info *s2mpa01 = rdev_get_drvdata(rdev);
+        unsigned int ramp_val, ramp_shift, ramp_reg = S2MPA01_REG_RAMP2;
+        unsigned int ramp_enable = 1, enable_shift = 0;
+        int ret;
+
+        switch (rdev->desc->id) {
+        case S2MPA01_BUCK1:
+                enable_shift = S2MPA01_BUCK1_RAMP_EN_SHIFT;
+                if (!ramp_delay) {
+                        ramp_enable = 0;
+                        break;
+                }
+
+                if (ramp_delay > s2mpa01->ramp_delay16)
+                        s2mpa01->ramp_delay16 = ramp_delay;
+                else
+                        ramp_delay = s2mpa01->ramp_delay16;
+
+                ramp_shift = S2MPA01_BUCK16_RAMP_SHIFT;
+                ramp_reg = S2MPA01_REG_RAMP1;
+                break;
+        case S2MPA01_BUCK2:
+                enable_shift = S2MPA01_BUCK2_RAMP_EN_SHIFT;
+                if (!ramp_delay) {
+                        ramp_enable = 0;
+                        break;
+                }
+
+                if (ramp_delay > s2mpa01->ramp_delay24)
+                        s2mpa01->ramp_delay24 = ramp_delay;
+                else
+                        ramp_delay = s2mpa01->ramp_delay24;
+
+                ramp_shift = S2MPA01_BUCK24_RAMP_SHIFT;
+                ramp_reg = S2MPA01_REG_RAMP1;
+                break;
+        case S2MPA01_BUCK3:
+                enable_shift = S2MPA01_BUCK3_RAMP_EN_SHIFT;
+                if (!ramp_delay) {
+                        ramp_enable = 0;
+                        break;
+                }
+
+                s2mpa01->ramp_delay3 = ramp_delay;
+                ramp_shift = S2MPA01_BUCK3_RAMP_SHIFT;
+                ramp_reg = S2MPA01_REG_RAMP1;
+                break;
+        case S2MPA01_BUCK4:
+                enable_shift = S2MPA01_BUCK4_RAMP_EN_SHIFT;
+                if (!ramp_delay) {
+                        ramp_enable = 0;
+                        break;
+                }
+
+                if (ramp_delay > s2mpa01->ramp_delay24)
+                        s2mpa01->ramp_delay24 = ramp_delay;
+                else
+                        ramp_delay = s2mpa01->ramp_delay24;
+
+                ramp_shift = S2MPA01_BUCK24_RAMP_SHIFT;
+                ramp_reg = S2MPA01_REG_RAMP1;
+                break;
+        case S2MPA01_BUCK5:
+                s2mpa01->ramp_delay5 = ramp_delay;
+                ramp_shift = S2MPA01_BUCK5_RAMP_SHIFT;
+                break;
+        case S2MPA01_BUCK6:
+                if (ramp_delay > s2mpa01->ramp_delay16)
+                        s2mpa01->ramp_delay16 = ramp_delay;
+                else
+                        ramp_delay = s2mpa01->ramp_delay16;
+
+                ramp_shift = S2MPA01_BUCK16_RAMP_SHIFT;
+                break;
+        case S2MPA01_BUCK7:
+                s2mpa01->ramp_delay7 = ramp_delay;
+                ramp_shift = S2MPA01_BUCK7_RAMP_SHIFT;
+                break;
+        case S2MPA01_BUCK8:
+        case S2MPA01_BUCK9:
+        case S2MPA01_BUCK10:
+                if (ramp_delay > s2mpa01->ramp_delay8910)
+                        s2mpa01->ramp_delay8910 = ramp_delay;
+                else
+                        ramp_delay = s2mpa01->ramp_delay8910;
+
+                ramp_shift = S2MPA01_BUCK8910_RAMP_SHIFT;
+                break;
+        default:
+                return 0;
+        }
+
+        if (!ramp_enable)
+                goto ramp_disable;
+
+        if (enable_shift) {
+                ret = regmap_update_bits(rdev->regmap, S2MPA01_REG_RAMP1,
+                                        1 << enable_shift, 1 << enable_shift);
+                if (ret) {
+                        dev_err(&rdev->dev, "failed to enable ramp rate\n");
+                        return ret;
+                }
+        }
+
+        ramp_val = get_ramp_delay(ramp_delay);
+
+        return regmap_update_bits(rdev->regmap, ramp_reg, 0x3 << ramp_shift,
+                                  ramp_val << ramp_shift);
+
+ramp_disable:
+        return regmap_update_bits(rdev->regmap, S2MPA01_REG_RAMP1,
+                                  1 << enable_shift, 0);
+}
+
+static struct regulator_ops s2mpa01_ldo_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+};
+
+static struct regulator_ops s2mpa01_buck_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = s2mpa01_regulator_set_voltage_time_sel,
+        .set_ramp_delay         = s2mpa01_set_ramp_delay,
+};
+
+#define regulator_desc_ldo1(num)        {               \
+        .name           = "LDO"#num,                    \
+        .id             = S2MPA01_LDO##num,             \
+        .ops            = &s2mpa01_ldo_ops,             \
+        .type           = REGULATOR_VOLTAGE,            \
+        .owner          = THIS_MODULE,                  \
+        .min_uV         = S2MPA01_LDO_MIN,              \
+        .uV_step        = S2MPA01_LDO_STEP1,            \
+        .n_voltages     = S2MPA01_LDO_N_VOLTAGES,       \
+        .vsel_reg       = S2MPA01_REG_L1CTRL + num - 1, \
+        .vsel_mask      = S2MPA01_LDO_VSEL_MASK,        \
+        .enable_reg     = S2MPA01_REG_L1CTRL + num - 1, \
+        .enable_mask    = S2MPA01_ENABLE_MASK           \
+}
+#define regulator_desc_ldo2(num)        {               \
+        .name           = "LDO"#num,                    \
+        .id             = S2MPA01_LDO##num,             \
+        .ops            = &s2mpa01_ldo_ops,             \
+        .type           = REGULATOR_VOLTAGE,            \
+        .owner          = THIS_MODULE,                  \
+        .min_uV         = S2MPA01_LDO_MIN,              \
+        .uV_step        = S2MPA01_LDO_STEP2,            \
+        .n_voltages     = S2MPA01_LDO_N_VOLTAGES,       \
+        .vsel_reg       = S2MPA01_REG_L1CTRL + num - 1, \
+        .vsel_mask      = S2MPA01_LDO_VSEL_MASK,        \
+        .enable_reg     = S2MPA01_REG_L1CTRL + num - 1, \
+        .enable_mask    = S2MPA01_ENABLE_MASK           \
+}
+
+#define regulator_desc_buck1_4(num)     {                       \
+        .name           = "BUCK"#num,                           \
+        .id             = S2MPA01_BUCK##num,                    \
+        .ops            = &s2mpa01_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPA01_BUCK_MIN1,                    \
+        .uV_step        = S2MPA01_BUCK_STEP1,                   \
+        .n_voltages     = S2MPA01_BUCK_N_VOLTAGES,              \
+        .ramp_delay     = S2MPA01_RAMP_DELAY,                   \
+        .vsel_reg       = S2MPA01_REG_B1CTRL2 + (num - 1) * 2,  \
+        .vsel_mask      = S2MPA01_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPA01_REG_B1CTRL1 + (num - 1) * 2,  \
+        .enable_mask    = S2MPA01_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck5    {                               \
+        .name           = "BUCK5",                              \
+        .id             = S2MPA01_BUCK5,                        \
+        .ops            = &s2mpa01_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPA01_BUCK_MIN2,                    \
+        .uV_step        = S2MPA01_BUCK_STEP1,                   \
+        .n_voltages     = S2MPA01_BUCK_N_VOLTAGES,              \
+        .ramp_delay     = S2MPA01_RAMP_DELAY,                   \
+        .vsel_reg       = S2MPA01_REG_B5CTRL2,                  \
+        .vsel_mask      = S2MPA01_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPA01_REG_B5CTRL1,                  \
+        .enable_mask    = S2MPA01_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck6_7(num)     {                       \
+        .name           = "BUCK"#num,                           \
+        .id             = S2MPA01_BUCK##num,                    \
+        .ops            = &s2mpa01_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPA01_BUCK_MIN1,                    \
+        .uV_step        = S2MPA01_BUCK_STEP1,                   \
+        .n_voltages     = S2MPA01_BUCK_N_VOLTAGES,              \
+        .ramp_delay     = S2MPA01_RAMP_DELAY,                   \
+        .vsel_reg       = S2MPA01_REG_B6CTRL2 + (num - 6) * 2,  \
+        .vsel_mask      = S2MPA01_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPA01_REG_B6CTRL1 + (num - 6) * 2,  \
+        .enable_mask    = S2MPA01_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck8    {                               \
+        .name           = "BUCK8",                              \
+        .id             = S2MPA01_BUCK8,                        \
+        .ops            = &s2mpa01_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPA01_BUCK_MIN2,                    \
+        .uV_step        = S2MPA01_BUCK_STEP2,                   \
+        .n_voltages     = S2MPA01_BUCK_N_VOLTAGES,              \
+        .ramp_delay     = S2MPA01_RAMP_DELAY,                   \
+        .vsel_reg       = S2MPA01_REG_B8CTRL2,                  \
+        .vsel_mask      = S2MPA01_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPA01_REG_B8CTRL1,                  \
+        .enable_mask    = S2MPA01_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck9    {                               \
+        .name           = "BUCK9",                              \
+        .id             = S2MPA01_BUCK9,                        \
+        .ops            = &s2mpa01_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPA01_BUCK_MIN4,                    \
+        .uV_step        = S2MPA01_BUCK_STEP2,                   \
+        .n_voltages     = S2MPA01_BUCK_N_VOLTAGES,              \
+        .ramp_delay     = S2MPA01_RAMP_DELAY,                   \
+        .vsel_reg       = S2MPA01_REG_B9CTRL2,                  \
+        .vsel_mask      = S2MPA01_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPA01_REG_B9CTRL1,                  \
+        .enable_mask    = S2MPA01_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck10   {                               \
+        .name           = "BUCK10",                             \
+        .id             = S2MPA01_BUCK10,                       \
+        .ops            = &s2mpa01_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPA01_BUCK_MIN3,                    \
+        .uV_step        = S2MPA01_BUCK_STEP2,                   \
+        .n_voltages     = S2MPA01_BUCK_N_VOLTAGES,              \
+        .ramp_delay     = S2MPA01_RAMP_DELAY,                   \
+        .vsel_reg       = S2MPA01_REG_B10CTRL2,                 \
+        .vsel_mask      = S2MPA01_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPA01_REG_B10CTRL1,                 \
+        .enable_mask    = S2MPA01_ENABLE_MASK                   \
+}
+
+static struct regulator_desc regulators[] = {
+        regulator_desc_ldo2(1),
+        regulator_desc_ldo1(2),
+        regulator_desc_ldo1(3),
+        regulator_desc_ldo1(4),
+        regulator_desc_ldo1(5),
+        regulator_desc_ldo2(6),
+        regulator_desc_ldo1(7),
+        regulator_desc_ldo1(8),
+        regulator_desc_ldo1(9),
+        regulator_desc_ldo1(10),
+        regulator_desc_ldo2(11),
+        regulator_desc_ldo1(12),
+        regulator_desc_ldo1(13),
+        regulator_desc_ldo1(14),
+        regulator_desc_ldo1(15),
+        regulator_desc_ldo1(16),
+        regulator_desc_ldo1(17),
+        regulator_desc_ldo1(18),
+        regulator_desc_ldo1(19),
+        regulator_desc_ldo1(20),
+        regulator_desc_ldo1(21),
+        regulator_desc_ldo2(22),
+        regulator_desc_ldo2(23),
+        regulator_desc_ldo1(24),
+        regulator_desc_ldo1(25),
+        regulator_desc_ldo1(26),
+        regulator_desc_buck1_4(1),
+        regulator_desc_buck1_4(2),
+        regulator_desc_buck1_4(3),
+        regulator_desc_buck1_4(4),
+        regulator_desc_buck5,
+        regulator_desc_buck6_7(6),
+        regulator_desc_buck6_7(7),
+        regulator_desc_buck8,
+        regulator_desc_buck9,
+        regulator_desc_buck10,
+};
+
+static int s2mpa01_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 of_regulator_match rdata[S2MPA01_REGULATOR_MAX];
+        struct device_node *reg_np = NULL;
+        struct regulator_config config = { };
+        struct s2mpa01_info *s2mpa01;
+        int i;
+
+        s2mpa01 = devm_kzalloc(&pdev->dev, sizeof(*s2mpa01), GFP_KERNEL);
+        if (!s2mpa01)
+                return -ENOMEM;
+
+        for (i = 0; i < S2MPA01_REGULATOR_CNT; i++)
+                rdata[i].name = regulators[i].name;
+
+        if (iodev->dev->of_node) {
+                reg_np = of_get_child_by_name(iodev->dev->of_node,
+                                                        "regulators");
+                        if (!reg_np) {
+                                dev_err(&pdev->dev,
+                                        "could not find regulators sub-node\n");
+                                return -EINVAL;
+                        }
+
+                of_regulator_match(&pdev->dev, reg_np, rdata,
+                                                S2MPA01_REGULATOR_MAX);
+                of_node_put(reg_np);
+        }
+
+        platform_set_drvdata(pdev, s2mpa01);
+
+        config.dev = &pdev->dev;
+        config.regmap = iodev->regmap_pmic;
+        config.driver_data = s2mpa01;
+
+        for (i = 0; i < S2MPA01_REGULATOR_MAX; i++) {
+                struct regulator_dev *rdev;
+                if (pdata)
+                        config.init_data = pdata->regulators[i].initdata;
+                else
+                        config.init_data = rdata[i].init_data;
+
+                if (reg_np)
+                        config.of_node = rdata[i].of_node;
+
+                rdev = devm_regulator_register(&pdev->dev,
+                                                &regulators[i], &config);
+                if (IS_ERR(rdev)) {
+                        dev_err(&pdev->dev, "regulator init failed for %d\n",
+                                i);
+                        return PTR_ERR(rdev);
+                }
+        }
+
+        return 0;
+}
+
+static const struct platform_device_id s2mpa01_pmic_id[] = {
+        { "s2mpa01-pmic", 0},
+        { },
+};
+MODULE_DEVICE_TABLE(platform, s2mpa01_pmic_id);
+
+static struct platform_driver s2mpa01_pmic_driver = {
+        .driver = {
+                .name = "s2mpa01-pmic",
+                .owner = THIS_MODULE,
+        },
+        .probe = s2mpa01_pmic_probe,
+        .id_table = s2mpa01_pmic_id,
+};
+
+module_platform_driver(s2mpa01_pmic_driver);
+
+/* Module information */
+MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
+MODULE_AUTHOR("Sachin Kamat <sachin.kamat@samsung.com>");
+MODULE_DESCRIPTION("SAMSUNG S2MPA01 Regulator Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
index d9e557990577..68fd54702edb 100644
--- a/drivers/regulator/s2mps11.c
+++ b/drivers/regulator/s2mps11.c
@@ -1,13 +1,18 @@
 /*
  * s2mps11.c
  *
- * Copyright (c) 2012 Samsung Electronics Co., Ltd
+ * Copyright (c) 2012-2014 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
  *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
  */
 
@@ -24,18 +29,21 @@
 #include <linux/regulator/of_regulator.h>
 #include <linux/mfd/samsung/core.h>
 #include <linux/mfd/samsung/s2mps11.h>
-
-#define S2MPS11_REGULATOR_CNT ARRAY_SIZE(regulators)
+#include <linux/mfd/samsung/s2mps14.h>
 
 struct s2mps11_info {
-        struct regulator_dev *rdev[S2MPS11_REGULATOR_MAX];
-
+        unsigned int rdev_num;
         int ramp_delay2;
         int ramp_delay34;
         int ramp_delay5;
         int ramp_delay16;
         int ramp_delay7810;
         int ramp_delay9;
+        /*
+         * One bit for each S2MPS14 regulator whether the suspend mode
+         * was enabled.
+         */
+        unsigned int s2mps14_suspend_state:30;
 };
 
 static int get_ramp_delay(int ramp_delay)
@@ -65,7 +73,7 @@ static int s2mps11_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
         unsigned int ramp_delay = 0;
         int old_volt, new_volt;
 
-        switch (rdev->desc->id) {
+        switch (rdev_get_id(rdev)) {
         case S2MPS11_BUCK2:
                 ramp_delay = s2mps11->ramp_delay2;
                 break;
@@ -105,7 +113,7 @@ static int s2mps11_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
         unsigned int ramp_enable = 1, enable_shift = 0;
         int ret;
 
-        switch (rdev->desc->id) {
+        switch (rdev_get_id(rdev)) {
         case S2MPS11_BUCK1:
                 if (ramp_delay > s2mps11->ramp_delay16)
                         s2mps11->ramp_delay16 = ramp_delay;
@@ -236,7 +244,7 @@ static struct regulator_ops s2mps11_buck_ops = {
         .set_ramp_delay         = s2mps11_set_ramp_delay,
 };
 
-#define regulator_desc_ldo1(num)        {               \
+#define regulator_desc_s2mps11_ldo1(num)        {               \
         .name           = "LDO"#num,                    \
         .id             = S2MPS11_LDO##num,             \
         .ops            = &s2mps11_ldo_ops,             \
@@ -250,7 +258,7 @@ static struct regulator_ops s2mps11_buck_ops = {
         .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
         .enable_mask    = S2MPS11_ENABLE_MASK           \
 }
-#define regulator_desc_ldo2(num)        {               \
+#define regulator_desc_s2mps11_ldo2(num) {              \
         .name           = "LDO"#num,                    \
         .id             = S2MPS11_LDO##num,             \
         .ops            = &s2mps11_ldo_ops,             \
@@ -265,7 +273,7 @@ static struct regulator_ops s2mps11_buck_ops = {
         .enable_mask    = S2MPS11_ENABLE_MASK           \
 }
 
-#define regulator_desc_buck1_4(num)     {                       \
+#define regulator_desc_s2mps11_buck1_4(num) {                   \
         .name           = "BUCK"#num,                           \
         .id             = S2MPS11_BUCK##num,                    \
         .ops            = &s2mps11_buck_ops,                    \
@@ -281,7 +289,7 @@ static struct regulator_ops s2mps11_buck_ops = {
         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 }
 
-#define regulator_desc_buck5    {                               \
+#define regulator_desc_s2mps11_buck5 {                          \
         .name           = "BUCK5",                              \
         .id             = S2MPS11_BUCK5,                        \
         .ops            = &s2mps11_buck_ops,                    \
@@ -297,7 +305,7 @@ static struct regulator_ops s2mps11_buck_ops = {
         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 }
 
-#define regulator_desc_buck6_8(num)     {                       \
+#define regulator_desc_s2mps11_buck6_8(num) {                   \
         .name           = "BUCK"#num,                           \
         .id             = S2MPS11_BUCK##num,                    \
         .ops            = &s2mps11_buck_ops,                    \
@@ -313,7 +321,7 @@ static struct regulator_ops s2mps11_buck_ops = {
         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 }
 
-#define regulator_desc_buck9    {                               \
+#define regulator_desc_s2mps11_buck9 {                          \
         .name           = "BUCK9",                              \
         .id             = S2MPS11_BUCK9,                        \
         .ops            = &s2mps11_buck_ops,                    \
@@ -329,7 +337,7 @@ static struct regulator_ops s2mps11_buck_ops = {
         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 }
 
-#define regulator_desc_buck10   {                               \
+#define regulator_desc_s2mps11_buck10 {                         \
         .name           = "BUCK10",                             \
         .id             = S2MPS11_BUCK10,                       \
         .ops            = &s2mps11_buck_ops,                    \
@@ -345,72 +353,252 @@ static struct regulator_ops s2mps11_buck_ops = {
         .enable_mask    = S2MPS11_ENABLE_MASK                   \
 }
 
-static struct regulator_desc regulators[] = {
-        regulator_desc_ldo2(1),
-        regulator_desc_ldo1(2),
-        regulator_desc_ldo1(3),
-        regulator_desc_ldo1(4),
-        regulator_desc_ldo1(5),
-        regulator_desc_ldo2(6),
-        regulator_desc_ldo1(7),
-        regulator_desc_ldo1(8),
-        regulator_desc_ldo1(9),
-        regulator_desc_ldo1(10),
-        regulator_desc_ldo2(11),
-        regulator_desc_ldo1(12),
-        regulator_desc_ldo1(13),
-        regulator_desc_ldo1(14),
-        regulator_desc_ldo1(15),
-        regulator_desc_ldo1(16),
-        regulator_desc_ldo1(17),
-        regulator_desc_ldo1(18),
-        regulator_desc_ldo1(19),
-        regulator_desc_ldo1(20),
-        regulator_desc_ldo1(21),
-        regulator_desc_ldo2(22),
-        regulator_desc_ldo2(23),
-        regulator_desc_ldo1(24),
-        regulator_desc_ldo1(25),
-        regulator_desc_ldo1(26),
-        regulator_desc_ldo2(27),
-        regulator_desc_ldo1(28),
-        regulator_desc_ldo1(29),
-        regulator_desc_ldo1(30),
-        regulator_desc_ldo1(31),
-        regulator_desc_ldo1(32),
-        regulator_desc_ldo1(33),
-        regulator_desc_ldo1(34),
-        regulator_desc_ldo1(35),
-        regulator_desc_ldo1(36),
-        regulator_desc_ldo1(37),
-        regulator_desc_ldo1(38),
-        regulator_desc_buck1_4(1),
-        regulator_desc_buck1_4(2),
-        regulator_desc_buck1_4(3),
-        regulator_desc_buck1_4(4),
-        regulator_desc_buck5,
-        regulator_desc_buck6_8(6),
-        regulator_desc_buck6_8(7),
-        regulator_desc_buck6_8(8),
-        regulator_desc_buck9,
-        regulator_desc_buck10,
+static const struct regulator_desc s2mps11_regulators[] = {
+        regulator_desc_s2mps11_ldo2(1),
+        regulator_desc_s2mps11_ldo1(2),
+        regulator_desc_s2mps11_ldo1(3),
+        regulator_desc_s2mps11_ldo1(4),
+        regulator_desc_s2mps11_ldo1(5),
+        regulator_desc_s2mps11_ldo2(6),
+        regulator_desc_s2mps11_ldo1(7),
+        regulator_desc_s2mps11_ldo1(8),
+        regulator_desc_s2mps11_ldo1(9),
+        regulator_desc_s2mps11_ldo1(10),
+        regulator_desc_s2mps11_ldo2(11),
+        regulator_desc_s2mps11_ldo1(12),
+        regulator_desc_s2mps11_ldo1(13),
+        regulator_desc_s2mps11_ldo1(14),
+        regulator_desc_s2mps11_ldo1(15),
+        regulator_desc_s2mps11_ldo1(16),
+        regulator_desc_s2mps11_ldo1(17),
+        regulator_desc_s2mps11_ldo1(18),
+        regulator_desc_s2mps11_ldo1(19),
+        regulator_desc_s2mps11_ldo1(20),
+        regulator_desc_s2mps11_ldo1(21),
+        regulator_desc_s2mps11_ldo2(22),
+        regulator_desc_s2mps11_ldo2(23),
+        regulator_desc_s2mps11_ldo1(24),
+        regulator_desc_s2mps11_ldo1(25),
+        regulator_desc_s2mps11_ldo1(26),
+        regulator_desc_s2mps11_ldo2(27),
+        regulator_desc_s2mps11_ldo1(28),
+        regulator_desc_s2mps11_ldo1(29),
+        regulator_desc_s2mps11_ldo1(30),
+        regulator_desc_s2mps11_ldo1(31),
+        regulator_desc_s2mps11_ldo1(32),
+        regulator_desc_s2mps11_ldo1(33),
+        regulator_desc_s2mps11_ldo1(34),
+        regulator_desc_s2mps11_ldo1(35),
+        regulator_desc_s2mps11_ldo1(36),
+        regulator_desc_s2mps11_ldo1(37),
+        regulator_desc_s2mps11_ldo1(38),
+        regulator_desc_s2mps11_buck1_4(1),
+        regulator_desc_s2mps11_buck1_4(2),
+        regulator_desc_s2mps11_buck1_4(3),
+        regulator_desc_s2mps11_buck1_4(4),
+        regulator_desc_s2mps11_buck5,
+        regulator_desc_s2mps11_buck6_8(6),
+        regulator_desc_s2mps11_buck6_8(7),
+        regulator_desc_s2mps11_buck6_8(8),
+        regulator_desc_s2mps11_buck9,
+        regulator_desc_s2mps11_buck10,
+};
+
+static int s2mps14_regulator_enable(struct regulator_dev *rdev)
+{
+        struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
+        unsigned int val;
+
+        if (s2mps11->s2mps14_suspend_state & (1 << rdev_get_id(rdev)))
+                val = S2MPS14_ENABLE_SUSPEND;
+        else
+                val = rdev->desc->enable_mask;
+
+        return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
+                        rdev->desc->enable_mask, val);
+}
+
+static int s2mps14_regulator_set_suspend_disable(struct regulator_dev *rdev)
+{
+        int ret;
+        unsigned int val;
+        struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
+
+        /* LDO3 should be always on and does not support suspend mode */
+        if (rdev_get_id(rdev) == S2MPS14_LDO3)
+                return 0;
+
+        ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
+        if (ret < 0)
+                return ret;
+
+        s2mps11->s2mps14_suspend_state |= (1 << rdev_get_id(rdev));
+        /*
+         * Don't enable suspend mode if regulator is already disabled because
+         * this would effectively for a short time turn on the regulator after
+         * resuming.
+         * However we still want to toggle the suspend_state bit for regulator
+         * in case if it got enabled before suspending the system.
+         */
+        if (!(val & rdev->desc->enable_mask))
+                return 0;
+
+        return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
+                        rdev->desc->enable_mask, S2MPS14_ENABLE_SUSPEND);
+}
+
+static struct regulator_ops s2mps14_reg_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = s2mps14_regulator_enable,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+        .set_suspend_disable    = s2mps14_regulator_set_suspend_disable,
+};
+
+#define regulator_desc_s2mps14_ldo1(num) {              \
+        .name           = "LDO"#num,                    \
+        .id             = S2MPS14_LDO##num,             \
+        .ops            = &s2mps14_reg_ops,             \
+        .type           = REGULATOR_VOLTAGE,            \
+        .owner          = THIS_MODULE,                  \
+        .min_uV         = S2MPS14_LDO_MIN_800MV,        \
+        .uV_step        = S2MPS14_LDO_STEP_25MV,        \
+        .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
+        .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
+        .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
+        .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
+        .enable_mask    = S2MPS14_ENABLE_MASK           \
+}
+#define regulator_desc_s2mps14_ldo2(num) {              \
+        .name           = "LDO"#num,                    \
+        .id             = S2MPS14_LDO##num,             \
+        .ops            = &s2mps14_reg_ops,             \
+        .type           = REGULATOR_VOLTAGE,            \
+        .owner          = THIS_MODULE,                  \
+        .min_uV         = S2MPS14_LDO_MIN_1800MV,       \
+        .uV_step        = S2MPS14_LDO_STEP_25MV,        \
+        .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
+        .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
+        .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
+        .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
+        .enable_mask    = S2MPS14_ENABLE_MASK           \
+}
+#define regulator_desc_s2mps14_ldo3(num) {              \
+        .name           = "LDO"#num,                    \
+        .id             = S2MPS14_LDO##num,             \
+        .ops            = &s2mps14_reg_ops,             \
+        .type           = REGULATOR_VOLTAGE,            \
+        .owner          = THIS_MODULE,                  \
+        .min_uV         = S2MPS14_LDO_MIN_800MV,        \
+        .uV_step        = S2MPS14_LDO_STEP_12_5MV,      \
+        .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
+        .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
+        .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
+        .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
+        .enable_mask    = S2MPS14_ENABLE_MASK           \
+}
+#define regulator_desc_s2mps14_buck1235(num) {                  \
+        .name           = "BUCK"#num,                           \
+        .id             = S2MPS14_BUCK##num,                    \
+        .ops            = &s2mps14_reg_ops,                     \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS14_BUCK1235_MIN_600MV,           \
+        .uV_step        = S2MPS14_BUCK1235_STEP_6_25MV,         \
+        .n_voltages     = S2MPS14_BUCK_N_VOLTAGES,              \
+        .linear_min_sel = S2MPS14_BUCK1235_START_SEL,           \
+        .ramp_delay     = S2MPS14_BUCK_RAMP_DELAY,              \
+        .vsel_reg       = S2MPS14_REG_B1CTRL2 + (num - 1) * 2,  \
+        .vsel_mask      = S2MPS14_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS14_REG_B1CTRL1 + (num - 1) * 2,  \
+        .enable_mask    = S2MPS14_ENABLE_MASK                   \
+}
+#define regulator_desc_s2mps14_buck4(num) {                     \
+        .name           = "BUCK"#num,                           \
+        .id             = S2MPS14_BUCK##num,                    \
+        .ops            = &s2mps14_reg_ops,                     \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS14_BUCK4_MIN_1400MV,             \
+        .uV_step        = S2MPS14_BUCK4_STEP_12_5MV,            \
+        .n_voltages     = S2MPS14_BUCK_N_VOLTAGES,              \
+        .linear_min_sel = S2MPS14_BUCK4_START_SEL,              \
+        .ramp_delay     = S2MPS14_BUCK_RAMP_DELAY,              \
+        .vsel_reg       = S2MPS14_REG_B1CTRL2 + (num - 1) * 2,  \
+        .vsel_mask      = S2MPS14_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS14_REG_B1CTRL1 + (num - 1) * 2,  \
+        .enable_mask    = S2MPS14_ENABLE_MASK                   \
+}
+
+static const struct regulator_desc s2mps14_regulators[] = {
+        regulator_desc_s2mps14_ldo3(1),
+        regulator_desc_s2mps14_ldo3(2),
+        regulator_desc_s2mps14_ldo1(3),
+        regulator_desc_s2mps14_ldo1(4),
+        regulator_desc_s2mps14_ldo3(5),
+        regulator_desc_s2mps14_ldo3(6),
+        regulator_desc_s2mps14_ldo1(7),
+        regulator_desc_s2mps14_ldo2(8),
+        regulator_desc_s2mps14_ldo3(9),
+        regulator_desc_s2mps14_ldo3(10),
+        regulator_desc_s2mps14_ldo1(11),
+        regulator_desc_s2mps14_ldo2(12),
+        regulator_desc_s2mps14_ldo2(13),
+        regulator_desc_s2mps14_ldo2(14),
+        regulator_desc_s2mps14_ldo2(15),
+        regulator_desc_s2mps14_ldo2(16),
+        regulator_desc_s2mps14_ldo2(17),
+        regulator_desc_s2mps14_ldo2(18),
+        regulator_desc_s2mps14_ldo1(19),
+        regulator_desc_s2mps14_ldo1(20),
+        regulator_desc_s2mps14_ldo1(21),
+        regulator_desc_s2mps14_ldo3(22),
+        regulator_desc_s2mps14_ldo1(23),
+        regulator_desc_s2mps14_ldo2(24),
+        regulator_desc_s2mps14_ldo2(25),
+        regulator_desc_s2mps14_buck1235(1),
+        regulator_desc_s2mps14_buck1235(2),
+        regulator_desc_s2mps14_buck1235(3),
+        regulator_desc_s2mps14_buck4(4),
+        regulator_desc_s2mps14_buck1235(5),
 };
 
 static 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 of_regulator_match rdata[S2MPS11_REGULATOR_MAX];
+        struct sec_platform_data *pdata = iodev->pdata;
+        struct of_regulator_match *rdata = NULL;
         struct device_node *reg_np = NULL;
         struct regulator_config config = { };
         struct s2mps11_info *s2mps11;
-        int i, ret;
+        int i, ret = 0;
+        const struct regulator_desc *regulators;
+        enum sec_device_type dev_type;
 
         s2mps11 = devm_kzalloc(&pdev->dev, sizeof(struct s2mps11_info),
                                 GFP_KERNEL);
         if (!s2mps11)
                 return -ENOMEM;
 
+        dev_type = platform_get_device_id(pdev)->driver_data;
+        switch (dev_type) {
+        case S2MPS11X:
+                s2mps11->rdev_num = ARRAY_SIZE(s2mps11_regulators);
+                regulators = s2mps11_regulators;
+                break;
+        case S2MPS14X:
+                s2mps11->rdev_num = ARRAY_SIZE(s2mps14_regulators);
+                regulators = s2mps14_regulators;
+                break;
+        default:
+                dev_err(&pdev->dev, "Invalid device type: %u\n", dev_type);
+                return -EINVAL;
+        };
+
         if (!iodev->dev->of_node) {
                 if (pdata) {
                         goto common_reg;
@@ -421,16 +609,22 @@ static int s2mps11_pmic_probe(struct platform_device *pdev)
                 }
         }
 
-        for (i = 0; i < S2MPS11_REGULATOR_CNT; i++)
+        rdata = kzalloc(sizeof(*rdata) * s2mps11->rdev_num, GFP_KERNEL);
+        if (!rdata)
+                return -ENOMEM;
+
+        for (i = 0; i < s2mps11->rdev_num; i++)
                 rdata[i].name = regulators[i].name;
 
-        reg_np = of_find_node_by_name(iodev->dev->of_node, "regulators");
+        reg_np = of_get_child_by_name(iodev->dev->of_node, "regulators");
         if (!reg_np) {
                 dev_err(&pdev->dev, "could not find regulators sub-node\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
 
-        of_regulator_match(&pdev->dev, reg_np, rdata, S2MPS11_REGULATOR_MAX);
+        of_regulator_match(&pdev->dev, reg_np, rdata, s2mps11->rdev_num);
+        of_node_put(reg_np);
 
 common_reg:
         platform_set_drvdata(pdev, s2mps11);
@@ -438,29 +632,36 @@ common_reg:
         config.dev = &pdev->dev;
         config.regmap = iodev->regmap_pmic;
         config.driver_data = s2mps11;
-        for (i = 0; i < S2MPS11_REGULATOR_MAX; i++) {
+        for (i = 0; i < s2mps11->rdev_num; i++) {
+                struct regulator_dev *regulator;
+
                 if (!reg_np) {
                         config.init_data = pdata->regulators[i].initdata;
+                        config.of_node = pdata->regulators[i].reg_node;
                 } else {
                         config.init_data = rdata[i].init_data;
                         config.of_node = rdata[i].of_node;
                 }
 
-                s2mps11->rdev[i] = devm_regulator_register(&pdev->dev,
+                regulator = devm_regulator_register(&pdev->dev,
                                                 &regulators[i], &config);
-                if (IS_ERR(s2mps11->rdev[i])) {
-                        ret = PTR_ERR(s2mps11->rdev[i]);
+                if (IS_ERR(regulator)) {
+                        ret = PTR_ERR(regulator);
                         dev_err(&pdev->dev, "regulator init failed for %d\n",
                                 i);
-                        return ret;
+                        goto out;
                 }
         }
 
-        return 0;
+out:
+        kfree(rdata);
+
+        return ret;
 }
 
 static const struct platform_device_id s2mps11_pmic_id[] = {
-        { "s2mps11-pmic", 0},
+        { "s2mps11-pmic", S2MPS11X},
+        { "s2mps14-pmic", S2MPS14X},
         { },
 };
 MODULE_DEVICE_TABLE(platform, s2mps11_pmic_id);
@@ -488,5 +689,5 @@ module_exit(s2mps11_pmic_exit);
 
 /* Module information */
 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
-MODULE_DESCRIPTION("SAMSUNG S2MPS11 Regulator Driver");
+MODULE_DESCRIPTION("SAMSUNG S2MPS11/S2MPS14 Regulator Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/s5m8767.c b/drivers/regulator/s5m8767.c
index d7164bb75d3e..f05badabd69e 100644
--- a/drivers/regulator/s5m8767.c
+++ b/drivers/regulator/s5m8767.c
@@ -11,11 +11,8 @@
  *
  */
 
-#include <linux/bug.h>
 #include <linux/err.h>
-#include <linux/gpio.h>
 #include <linux/of_gpio.h>
-#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
@@ -170,12 +167,11 @@ static unsigned int s5m8767_opmode_reg[][4] = {
         {0x0, 0x3, 0x1, 0x1}, /* BUCK9 */
 };
 
-static int s5m8767_get_register(struct regulator_dev *rdev, int *reg,
-                                int *enable_ctrl)
+static int s5m8767_get_register(struct s5m8767_info *s5m8767, int reg_id,
+                                int *reg, int *enable_ctrl)
 {
-        int i, reg_id = rdev_get_id(rdev);
+        int i;
         unsigned int mode;
-        struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
 
         switch (reg_id) {
         case S5M8767_LDO1 ... S5M8767_LDO2:
@@ -214,53 +210,6 @@ static int s5m8767_get_register(struct regulator_dev *rdev, int *reg,
         return 0;
 }
 
-static int s5m8767_reg_is_enabled(struct regulator_dev *rdev)
-{
-        struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
-        int ret, reg;
-        int enable_ctrl;
-        unsigned int val;
-
-        ret = s5m8767_get_register(rdev, &reg, &enable_ctrl);
-        if (ret == -EINVAL)
-                return 1;
-        else if (ret)
-                return ret;
-
-        ret = regmap_read(s5m8767->iodev->regmap_pmic, reg, &val);
-        if (ret)
-                return ret;
-
-        return (val & S5M8767_ENCTRL_MASK) == enable_ctrl;
-}
-
-static int s5m8767_reg_enable(struct regulator_dev *rdev)
-{
-        struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
-        int ret, reg;
-        int enable_ctrl;
-
-        ret = s5m8767_get_register(rdev, &reg, &enable_ctrl);
-        if (ret)
-                return ret;
-
-        return regmap_update_bits(s5m8767->iodev->regmap_pmic, reg,
-                        S5M8767_ENCTRL_MASK, enable_ctrl);
-}
-
-static int s5m8767_reg_disable(struct regulator_dev *rdev)
-{
-        struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
-        int ret, reg, enable_ctrl;
-
-        ret = s5m8767_get_register(rdev, &reg, &enable_ctrl);
-        if (ret)
-                return ret;
-
-        return regmap_update_bits(s5m8767->iodev->regmap_pmic, reg,
-                        S5M8767_ENCTRL_MASK, ~S5M8767_ENCTRL_MASK);
-}
-
 static int s5m8767_get_vsel_reg(int reg_id, struct s5m8767_info *s5m8767)
 {
         int reg;
@@ -410,9 +359,9 @@ static int s5m8767_set_voltage_time_sel(struct regulator_dev *rdev,
 
 static struct regulator_ops s5m8767_ops = {
         .list_voltage           = regulator_list_voltage_linear,
-        .is_enabled             = s5m8767_reg_is_enabled,
-        .enable                 = s5m8767_reg_enable,
-        .disable                = s5m8767_reg_disable,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = s5m8767_set_voltage_sel,
         .set_voltage_time_sel   = s5m8767_set_voltage_time_sel,
@@ -420,9 +369,9 @@ static struct regulator_ops s5m8767_ops = {
 
 static struct regulator_ops s5m8767_buck78_ops = {
         .list_voltage           = regulator_list_voltage_linear,
-        .is_enabled             = s5m8767_reg_is_enabled,
-        .enable                 = s5m8767_reg_enable,
-        .disable                = s5m8767_reg_disable,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
 };
@@ -483,6 +432,66 @@ static struct regulator_desc regulators[] = {
         s5m8767_regulator_desc(BUCK9),
 };
 
+/*
+ * Enable GPIO control over BUCK9 in regulator_config for that regulator.
+ */
+static void s5m8767_regulator_config_ext_control(struct s5m8767_info *s5m8767,
+                struct sec_regulator_data *rdata,
+                struct regulator_config *config)
+{
+        int i, mode = 0;
+
+        if (rdata->id != S5M8767_BUCK9)
+                return;
+
+        /* Check if opmode for regulator matches S5M8767_ENCTRL_USE_GPIO */
+        for (i = 0; i < s5m8767->num_regulators; i++) {
+                const struct sec_opmode_data *opmode = &s5m8767->opmode[i];
+                if (opmode->id == rdata->id) {
+                        mode = s5m8767_opmode_reg[rdata->id][opmode->mode];
+                        break;
+                }
+        }
+        if (mode != S5M8767_ENCTRL_USE_GPIO) {
+                dev_warn(s5m8767->dev,
+                                "ext-control for %s: mismatched op_mode (%x), ignoring\n",
+                                rdata->reg_node->name, mode);
+                return;
+        }
+
+        if (!gpio_is_valid(rdata->ext_control_gpio)) {
+                dev_warn(s5m8767->dev,
+                                "ext-control for %s: GPIO not valid, ignoring\n",
+                                rdata->reg_node->name);
+                return;
+        }
+
+        config->ena_gpio = rdata->ext_control_gpio;
+        config->ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
+}
+
+/*
+ * Turn on GPIO control over BUCK9.
+ */
+static int s5m8767_enable_ext_control(struct s5m8767_info *s5m8767,
+                struct regulator_dev *rdev)
+{
+        int id = rdev_get_id(rdev);
+        int ret, reg, enable_ctrl;
+
+        if (id != S5M8767_BUCK9)
+                return -EINVAL;
+
+        ret = s5m8767_get_register(s5m8767, id, &reg, &enable_ctrl);
+        if (ret)
+                return ret;
+
+        return regmap_update_bits(s5m8767->iodev->regmap_pmic,
+                        reg, S5M8767_ENCTRL_MASK,
+                        S5M8767_ENCTRL_USE_GPIO << S5M8767_ENCTRL_SHIFT);
+}
+
+
 #ifdef CONFIG_OF
 static int s5m8767_pmic_dt_parse_dvs_gpio(struct sec_pmic_dev *iodev,
                         struct sec_platform_data *pdata,
@@ -520,6 +529,16 @@ static int s5m8767_pmic_dt_parse_ds_gpio(struct sec_pmic_dev *iodev,
         return 0;
 }
 
+static void s5m8767_pmic_dt_parse_ext_control_gpio(struct sec_pmic_dev *iodev,
+                struct sec_regulator_data *rdata,
+                struct device_node *reg_np)
+{
+        rdata->ext_control_gpio = of_get_named_gpio(reg_np,
+                        "s5m8767,pmic-ext-control-gpios", 0);
+        if (!gpio_is_valid(rdata->ext_control_gpio))
+                rdata->ext_control_gpio = 0;
+}
+
 static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev,
                                         struct sec_platform_data *pdata)
 {
@@ -535,7 +554,7 @@ static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev,
                 return -ENODEV;
         }
 
-        regulators_np = of_find_node_by_name(pmic_np, "regulators");
+        regulators_np = of_get_child_by_name(pmic_np, "regulators");
         if (!regulators_np) {
                 dev_err(iodev->dev, "could not find regulators sub-node\n");
                 return -EINVAL;
@@ -546,19 +565,13 @@ static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev,
 
         rdata = devm_kzalloc(&pdev->dev, sizeof(*rdata) *
                                 pdata->num_regulators, GFP_KERNEL);
-        if (!rdata) {
-                dev_err(iodev->dev,
-                        "could not allocate memory for regulator data\n");
+        if (!rdata)
                 return -ENOMEM;
-        }
 
         rmode = devm_kzalloc(&pdev->dev, sizeof(*rmode) *
                                 pdata->num_regulators, GFP_KERNEL);
-        if (!rmode) {
-                dev_err(iodev->dev,
-                        "could not allocate memory for regulator mode\n");
+        if (!rmode)
                 return -ENOMEM;
-        }
 
         pdata->regulators = rdata;
         pdata->opmode = rmode;
@@ -574,6 +587,8 @@ static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev,
                         continue;
                 }
 
+                s5m8767_pmic_dt_parse_ext_control_gpio(iodev, rdata, reg_np);
+
                 rdata->id = i;
                 rdata->initdata = of_get_regulator_init_data(
                                                 &pdev->dev, reg_np);
@@ -591,6 +606,8 @@ static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev,
                 rmode++;
         }
 
+        of_node_put(regulators_np);
+
         if (of_get_property(pmic_np, "s5m8767,pmic-buck2-uses-gpio-dvs", NULL)) {
                 pdata->buck2_gpiodvs = true;
 
@@ -920,6 +937,7 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
         for (i = 0; i < pdata->num_regulators; i++) {
                 const struct sec_voltage_desc *desc;
                 int id = pdata->regulators[i].id;
+                int enable_reg, enable_val;
 
                 desc = reg_voltage_map[id];
                 if (desc) {
@@ -933,6 +951,12 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
                                 regulators[id].vsel_mask = 0x3f;
                         else
                                 regulators[id].vsel_mask = 0xff;
+
+                        s5m8767_get_register(s5m8767, id, &enable_reg,
+                                             &enable_val);
+                        regulators[id].enable_reg = enable_reg;
+                        regulators[id].enable_mask = S5M8767_ENCTRL_MASK;
+                        regulators[id].enable_val = enable_val;
                 }
 
                 config.dev = s5m8767->dev;
@@ -940,6 +964,9 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
                 config.driver_data = s5m8767;
                 config.regmap = iodev->regmap_pmic;
                 config.of_node = pdata->regulators[i].reg_node;
+                if (pdata->regulators[i].ext_control_gpio)
+                        s5m8767_regulator_config_ext_control(s5m8767,
+                                        &pdata->regulators[i], &config);
 
                 rdev[i] = devm_regulator_register(&pdev->dev, &regulators[id],
                                                   &config);
@@ -949,6 +976,16 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
                                         id);
                         return ret;
                 }
+
+                if (pdata->regulators[i].ext_control_gpio) {
+                        ret = s5m8767_enable_ext_control(s5m8767, rdev[i]);
+                        if (ret < 0) {
+                                dev_err(s5m8767->dev,
+                                                "failed to enable gpio control over %s: %d\n",
+                                                rdev[i]->desc->name, ret);
+                                return ret;
+                        }
+                }
         }
 
         return 0;
diff --git a/drivers/regulator/st-pwm.c b/drivers/regulator/st-pwm.c
new file mode 100644
index 000000000000..e367af1c5f9d
--- /dev/null
+++ b/drivers/regulator/st-pwm.c
@@ -0,0 +1,190 @@
+/*
+ * Regulator driver for ST's PWM Regulators
+ *
+ * Copyright (C) 2014 - STMicroelectronics Inc.
+ *
+ * Author: Lee Jones <lee.jones@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/regulator/of_regulator.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/pwm.h>
+
+#define ST_PWM_REG_PERIOD 8448
+
+struct st_pwm_regulator_pdata {
+        const struct regulator_desc *desc;
+        struct st_pwm_voltages *duty_cycle_table;
+};
+
+struct st_pwm_regulator_data {
+        const struct st_pwm_regulator_pdata *pdata;
+        struct pwm_device *pwm;
+        bool enabled;
+        int state;
+};
+
+struct st_pwm_voltages {
+        unsigned int uV;
+        unsigned int dutycycle;
+};
+
+static int st_pwm_regulator_get_voltage_sel(struct regulator_dev *dev)
+{
+        struct st_pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
+
+        return drvdata->state;
+}
+
+static int st_pwm_regulator_set_voltage_sel(struct regulator_dev *dev,
+                                            unsigned selector)
+{
+        struct st_pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
+        int dutycycle;
+        int ret;
+
+        dutycycle = (ST_PWM_REG_PERIOD / 100) *
+                drvdata->pdata->duty_cycle_table[selector].dutycycle;
+
+        ret = pwm_config(drvdata->pwm, dutycycle, ST_PWM_REG_PERIOD);
+        if (ret) {
+                dev_err(&dev->dev, "Failed to configure PWM\n");
+                return ret;
+        }
+
+        drvdata->state = selector;
+
+        if (!drvdata->enabled) {
+                ret = pwm_enable(drvdata->pwm);
+                if (ret) {
+                        dev_err(&dev->dev, "Failed to enable PWM\n");
+                        return ret;
+                }
+                drvdata->enabled = true;
+        }
+
+        return 0;
+}
+
+static int st_pwm_regulator_list_voltage(struct regulator_dev *dev,
+                                         unsigned selector)
+{
+        struct st_pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
+
+        if (selector >= dev->desc->n_voltages)
+                return -EINVAL;
+
+        return drvdata->pdata->duty_cycle_table[selector].uV;
+}
+
+static struct regulator_ops st_pwm_regulator_voltage_ops = {
+        .set_voltage_sel = st_pwm_regulator_set_voltage_sel,
+        .get_voltage_sel = st_pwm_regulator_get_voltage_sel,
+        .list_voltage    = st_pwm_regulator_list_voltage,
+        .map_voltage     = regulator_map_voltage_iterate,
+};
+
+static struct st_pwm_voltages b2105_duty_cycle_table[] = {
+        { .uV = 1114000, .dutycycle = 0,  },
+        { .uV = 1095000, .dutycycle = 10, },
+        { .uV = 1076000, .dutycycle = 20, },
+        { .uV = 1056000, .dutycycle = 30, },
+        { .uV = 1036000, .dutycycle = 40, },
+        { .uV = 1016000, .dutycycle = 50, },
+        /* WARNING: Values above 50% duty-cycle cause boot failures. */
+};
+
+static const struct regulator_desc b2105_desc = {
+        .name           = "b2105-pwm-regulator",
+        .ops            = &st_pwm_regulator_voltage_ops,
+        .type           = REGULATOR_VOLTAGE,
+        .owner          = THIS_MODULE,
+        .n_voltages     = ARRAY_SIZE(b2105_duty_cycle_table),
+        .supply_name    = "pwm",
+};
+
+static const struct st_pwm_regulator_pdata b2105_info = {
+        .desc             = &b2105_desc,
+        .duty_cycle_table = b2105_duty_cycle_table,
+};
+
+static struct of_device_id st_pwm_of_match[] = {
+        { .compatible = "st,b2105-pwm-regulator", .data = &b2105_info, },
+        { },
+};
+MODULE_DEVICE_TABLE(of, st_pwm_of_match);
+
+static int st_pwm_regulator_probe(struct platform_device *pdev)
+{
+        struct st_pwm_regulator_data *drvdata;
+        struct regulator_dev *regulator;
+        struct regulator_config config = { };
+        struct device_node *np = pdev->dev.of_node;
+        const struct of_device_id *of_match;
+
+        if (!np) {
+                dev_err(&pdev->dev, "Device Tree node missing\n");
+                return -EINVAL;
+        }
+
+        drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL);
+        if (!drvdata)
+                return -ENOMEM;
+
+        of_match = of_match_device(st_pwm_of_match, &pdev->dev);
+        if (!of_match) {
+                dev_err(&pdev->dev, "failed to match of device\n");
+                return -ENODEV;
+        }
+        drvdata->pdata = of_match->data;
+
+        config.init_data = of_get_regulator_init_data(&pdev->dev, np);
+        if (!config.init_data)
+                return -ENOMEM;
+
+        config.of_node = np;
+        config.dev = &pdev->dev;
+        config.driver_data = drvdata;
+
+        drvdata->pwm = devm_pwm_get(&pdev->dev, NULL);
+        if (IS_ERR(drvdata->pwm)) {
+                dev_err(&pdev->dev, "Failed to get PWM\n");
+                return PTR_ERR(drvdata->pwm);
+        }
+
+        regulator = devm_regulator_register(&pdev->dev,
+                                            drvdata->pdata->desc, &config);
+        if (IS_ERR(regulator)) {
+                dev_err(&pdev->dev, "Failed to register regulator %s\n",
+                        drvdata->pdata->desc->name);
+                return PTR_ERR(regulator);
+        }
+
+        return 0;
+}
+
+static struct platform_driver st_pwm_regulator_driver = {
+        .driver = {
+                .name           = "st-pwm-regulator",
+                .owner          = THIS_MODULE,
+                .of_match_table = of_match_ptr(st_pwm_of_match),
+        },
+        .probe = st_pwm_regulator_probe,
+};
+
+module_platform_driver(st_pwm_regulator_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org>");
+MODULE_DESCRIPTION("ST PWM Regulator Driver");
+MODULE_ALIAS("platform:st_pwm-regulator");
diff --git a/drivers/regulator/ti-abb-regulator.c b/drivers/regulator/ti-abb-regulator.c
index b187b6bba7ad..a2dabb575b97 100644
--- a/drivers/regulator/ti-abb-regulator.c
+++ b/drivers/regulator/ti-abb-regulator.c
@@ -54,8 +54,8 @@ struct ti_abb_info {
 
 /**
  * struct ti_abb_reg - Register description for ABB block
- * @setup_reg:                  setup register offset from base
- * @control_reg:                control register offset from base
+ * @setup_off:                  setup register offset from base
+ * @control_off:                control register offset from base
  * @sr2_wtcnt_value_mask:       setup register- sr2_wtcnt_value mask
  * @fbb_sel_mask:               setup register- FBB sel mask
  * @rbb_sel_mask:               setup register- RBB sel mask
@@ -64,8 +64,8 @@ struct ti_abb_info {
  * @opp_sel_mask:               control register - mask for mode to operate
  */
 struct ti_abb_reg {
-        u32 setup_reg;
-        u32 control_reg;
+        u32 setup_off;
+        u32 control_off;
 
         /* Setup register fields */
         u32 sr2_wtcnt_value_mask;
@@ -83,6 +83,8 @@ struct ti_abb_reg {
  * @rdesc:                      regulator descriptor
  * @clk:                        clock(usually sysclk) supplying ABB block
  * @base:                       base address of ABB block
+ * @setup_reg:                  setup register of ABB block
+ * @control_reg:                control register of ABB block
  * @int_base:                   interrupt register base address
  * @efuse_base:                 (optional) efuse base address for ABB modes
  * @ldo_base:                   (optional) LDOVBB vset override base address
@@ -99,6 +101,8 @@ struct ti_abb {
         struct regulator_desc rdesc;
         struct clk *clk;
         void __iomem *base;
+        void __iomem *setup_reg;
+        void __iomem *control_reg;
         void __iomem *int_base;
         void __iomem *efuse_base;
         void __iomem *ldo_base;
@@ -118,20 +122,18 @@ struct ti_abb {
  * ti_abb_rmw() - handy wrapper to set specific register bits
  * @mask:       mask for register field
  * @value:      value shifted to mask location and written
- * @offset:     offset of register
- * @base:       base address
+ * @reg:        register address
  *
  * Return: final register value (may be unused)
  */
-static inline u32 ti_abb_rmw(u32 mask, u32 value, u32 offset,
-                             void __iomem *base)
+static inline u32 ti_abb_rmw(u32 mask, u32 value, void __iomem *reg)
 {
         u32 val;
 
-        val = readl(base + offset);
+        val = readl(reg);
         val &= ~mask;
         val |= (value << __ffs(mask)) & mask;
-        writel(val, base + offset);
+        writel(val, reg);
 
         return val;
 }
@@ -263,21 +265,19 @@ static int ti_abb_set_opp(struct regulator_dev *rdev, struct ti_abb *abb,
         if (ret)
                 goto out;
 
-        ti_abb_rmw(regs->fbb_sel_mask | regs->rbb_sel_mask, 0, regs->setup_reg,
-                   abb->base);
+        ti_abb_rmw(regs->fbb_sel_mask | regs->rbb_sel_mask, 0, abb->setup_reg);
 
         switch (info->opp_sel) {
         case TI_ABB_SLOW_OPP:
-                ti_abb_rmw(regs->rbb_sel_mask, 1, regs->setup_reg, abb->base);
+                ti_abb_rmw(regs->rbb_sel_mask, 1, abb->setup_reg);
                 break;
         case TI_ABB_FAST_OPP:
-                ti_abb_rmw(regs->fbb_sel_mask, 1, regs->setup_reg, abb->base);
+                ti_abb_rmw(regs->fbb_sel_mask, 1, abb->setup_reg);
                 break;
         }
 
         /* program next state of ABB ldo */
-        ti_abb_rmw(regs->opp_sel_mask, info->opp_sel, regs->control_reg,
-                   abb->base);
+        ti_abb_rmw(regs->opp_sel_mask, info->opp_sel, abb->control_reg);
 
         /*
          * program LDO VBB vset override if needed for !bypass mode
@@ -288,7 +288,7 @@ static int ti_abb_set_opp(struct regulator_dev *rdev, struct ti_abb *abb,
                 ti_abb_program_ldovbb(dev, abb, info);
 
         /* Initiate ABB ldo change */
-        ti_abb_rmw(regs->opp_change_mask, 1, regs->control_reg, abb->base);
+        ti_abb_rmw(regs->opp_change_mask, 1, abb->control_reg);
 
         /* Wait for ABB LDO to complete transition to new Bias setting */
         ret = ti_abb_wait_txdone(dev, abb);
@@ -490,8 +490,7 @@ static int ti_abb_init_timings(struct device *dev, struct ti_abb *abb)
         dev_dbg(dev, "%s: Clk_rate=%ld, sr2_cnt=0x%08x\n", __func__,
                 clk_get_rate(abb->clk), sr2_wt_cnt_val);
 
-        ti_abb_rmw(regs->sr2_wtcnt_value_mask, sr2_wt_cnt_val, regs->setup_reg,
-                   abb->base);
+        ti_abb_rmw(regs->sr2_wtcnt_value_mask, sr2_wt_cnt_val, abb->setup_reg);
 
         return 0;
 }
@@ -508,32 +507,24 @@ static int ti_abb_init_table(struct device *dev, struct ti_abb *abb,
                              struct regulator_init_data *rinit_data)
 {
         struct ti_abb_info *info;
-        const struct property *prop;
-        const __be32 *abb_info;
         const u32 num_values = 6;
         char *pname = "ti,abb_info";
-        u32 num_entries, i;
+        u32 i;
         unsigned int *volt_table;
-        int min_uV = INT_MAX, max_uV = 0;
+        int num_entries, min_uV = INT_MAX, max_uV = 0;
         struct regulation_constraints *c = &rinit_data->constraints;
 
-        prop = of_find_property(dev->of_node, pname, NULL);
-        if (!prop) {
-                dev_err(dev, "No '%s' property?\n", pname);
-                return -ENODEV;
-        }
-
-        if (!prop->value) {
-                dev_err(dev, "Empty '%s' property?\n", pname);
-                return -ENODATA;
-        }
-
         /*
          * Each abb_info is a set of n-tuple, where n is num_values, consisting
          * of voltage and a set of detection logic for ABB information for that
          * voltage to apply.
          */
-        num_entries = prop->length / sizeof(u32);
+        num_entries = of_property_count_u32_elems(dev->of_node, pname);
+        if (num_entries < 0) {
+                dev_err(dev, "No '%s' property?\n", pname);
+                return num_entries;
+        }
+
         if (!num_entries || (num_entries % num_values)) {
                 dev_err(dev, "All '%s' list entries need %d vals\n", pname,
                         num_values);
@@ -542,38 +533,38 @@ static int ti_abb_init_table(struct device *dev, struct ti_abb *abb,
         num_entries /= num_values;
 
         info = devm_kzalloc(dev, sizeof(*info) * num_entries, GFP_KERNEL);
-        if (!info) {
-                dev_err(dev, "Can't allocate info table for '%s' property\n",
-                        pname);
+        if (!info)
                 return -ENOMEM;
-        }
+
         abb->info = info;
 
         volt_table = devm_kzalloc(dev, sizeof(unsigned int) * num_entries,
                                   GFP_KERNEL);
-        if (!volt_table) {
-                dev_err(dev, "Can't allocate voltage table for '%s' property\n",
-                        pname);
+        if (!volt_table)
                 return -ENOMEM;
-        }
 
         abb->rdesc.n_voltages = num_entries;
         abb->rdesc.volt_table = volt_table;
         /* We do not know where the OPP voltage is at the moment */
         abb->current_info_idx = -EINVAL;
 
-        abb_info = prop->value;
         for (i = 0; i < num_entries; i++, info++, volt_table++) {
                 u32 efuse_offset, rbb_mask, fbb_mask, vset_mask;
                 u32 efuse_val;
 
                 /* NOTE: num_values should equal to entries picked up here */
-                *volt_table = be32_to_cpup(abb_info++);
-                info->opp_sel = be32_to_cpup(abb_info++);
-                efuse_offset = be32_to_cpup(abb_info++);
-                rbb_mask = be32_to_cpup(abb_info++);
-                fbb_mask = be32_to_cpup(abb_info++);
-                vset_mask = be32_to_cpup(abb_info++);
+                of_property_read_u32_index(dev->of_node, pname, i * num_values,
+                                           volt_table);
+                of_property_read_u32_index(dev->of_node, pname,
+                                           i * num_values + 1, &info->opp_sel);
+                of_property_read_u32_index(dev->of_node, pname,
+                                           i * num_values + 2, &efuse_offset);
+                of_property_read_u32_index(dev->of_node, pname,
+                                           i * num_values + 3, &rbb_mask);
+                of_property_read_u32_index(dev->of_node, pname,
+                                           i * num_values + 4, &fbb_mask);
+                of_property_read_u32_index(dev->of_node, pname,
+                                           i * num_values + 5, &vset_mask);
 
                 dev_dbg(dev,
                         "[%d]v=%d ABB=%d ef=0x%x rbb=0x%x fbb=0x%x vset=0x%x\n",
@@ -648,8 +639,8 @@ static struct regulator_ops ti_abb_reg_ops = {
 /* Default ABB block offsets, IF this changes in future, create new one */
 static const struct ti_abb_reg abb_regs_v1 = {
         /* WARNING: registers are wrongly documented in TRM */
-        .setup_reg              = 0x04,
-        .control_reg            = 0x00,
+        .setup_off              = 0x04,
+        .control_off            = 0x00,
 
         .sr2_wtcnt_value_mask   = (0xff << 8),
         .fbb_sel_mask           = (0x01 << 2),
@@ -661,8 +652,8 @@ static const struct ti_abb_reg abb_regs_v1 = {
 };
 
 static const struct ti_abb_reg abb_regs_v2 = {
-        .setup_reg              = 0x00,
-        .control_reg            = 0x04,
+        .setup_off              = 0x00,
+        .control_off            = 0x04,
 
         .sr2_wtcnt_value_mask   = (0xff << 8),
         .fbb_sel_mask           = (0x01 << 2),
@@ -673,9 +664,20 @@ static const struct ti_abb_reg abb_regs_v2 = {
         .opp_sel_mask           = (0x03 << 0),
 };
 
+static const struct ti_abb_reg abb_regs_generic = {
+        .sr2_wtcnt_value_mask   = (0xff << 8),
+        .fbb_sel_mask           = (0x01 << 2),
+        .rbb_sel_mask           = (0x01 << 1),
+        .sr2_en_mask            = (0x01 << 0),
+
+        .opp_change_mask        = (0x01 << 2),
+        .opp_sel_mask           = (0x03 << 0),
+};
+
 static const struct of_device_id ti_abb_of_match[] = {
         {.compatible = "ti,abb-v1", .data = &abb_regs_v1},
         {.compatible = "ti,abb-v2", .data = &abb_regs_v2},
+        {.compatible = "ti,abb-v3", .data = &abb_regs_generic},
         { },
 };
 
@@ -722,11 +724,29 @@ static int ti_abb_probe(struct platform_device *pdev)
         abb->regs = match->data;
 
         /* Map ABB resources */
-        pname = "base-address";
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
-        abb->base = devm_ioremap_resource(dev, res);
-        if (IS_ERR(abb->base))
-                return PTR_ERR(abb->base);
+        if (abb->regs->setup_off || abb->regs->control_off) {
+                pname = "base-address";
+                res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
+                abb->base = devm_ioremap_resource(dev, res);
+                if (IS_ERR(abb->base))
+                        return PTR_ERR(abb->base);
+
+                abb->setup_reg = abb->base + abb->regs->setup_off;
+                abb->control_reg = abb->base + abb->regs->control_off;
+
+        } else {
+                pname = "control-address";
+                res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
+                abb->control_reg = devm_ioremap_resource(dev, res);
+                if (IS_ERR(abb->control_reg))
+                        return PTR_ERR(abb->control_reg);
+
+                pname = "setup-address";
+                res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
+                abb->setup_reg = devm_ioremap_resource(dev, res);
+                if (IS_ERR(abb->setup_reg))
+                        return PTR_ERR(abb->setup_reg);
+        }
 
         pname = "int-address";
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, pname);
@@ -860,7 +880,7 @@ skip_opt:
         platform_set_drvdata(pdev, rdev);
 
         /* Enable the ldo if not already done by bootloader */
-        ti_abb_rmw(abb->regs->sr2_en_mask, 1, abb->regs->setup_reg, abb->base);
+        ti_abb_rmw(abb->regs->sr2_en_mask, 1, abb->setup_reg);
 
         return 0;
 }
diff --git a/drivers/regulator/tps51632-regulator.c b/drivers/regulator/tps51632-regulator.c
index b3764f594ee9..f31f22e3e1bd 100644
--- a/drivers/regulator/tps51632-regulator.c
+++ b/drivers/regulator/tps51632-regulator.c
@@ -227,10 +227,8 @@ static struct tps51632_regulator_platform_data *
         struct device_node *np = dev->of_node;
 
         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
-        if (!pdata) {
-                dev_err(dev, "Memory alloc failed for platform data\n");
+        if (!pdata)
                 return NULL;
-        }
 
         pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node);
         if (!pdata->reg_init_data) {
@@ -299,10 +297,8 @@ static int tps51632_probe(struct i2c_client *client,
         }
 
         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
-        if (!tps) {
-                dev_err(&client->dev, "Memory allocation failed\n");
+        if (!tps)
                 return -ENOMEM;
-        }
 
         tps->dev = &client->dev;
         tps->desc.name = client->name;
diff --git a/drivers/regulator/tps6507x-regulator.c b/drivers/regulator/tps6507x-regulator.c
index 162a0fae20b3..98e66ce26723 100644
--- a/drivers/regulator/tps6507x-regulator.c
+++ b/drivers/regulator/tps6507x-regulator.c
@@ -359,7 +359,6 @@ static struct regulator_ops tps6507x_pmic_ops = {
         .map_voltage = regulator_map_voltage_ascend,
 };
 
-#ifdef CONFIG_OF
 static struct of_regulator_match tps6507x_matches[] = {
         { .name = "VDCDC1"},
         { .name = "VDCDC2"},
@@ -381,12 +380,10 @@ static struct tps6507x_board *tps6507x_parse_dt_reg_data(
 
         tps_board = devm_kzalloc(&pdev->dev, sizeof(*tps_board),
                                         GFP_KERNEL);
-        if (!tps_board) {
-                dev_err(&pdev->dev, "Failure to alloc pdata for regulators.\n");
+        if (!tps_board)
                 return NULL;
-        }
 
-        regulators = of_find_node_by_name(np, "regulators");
+        regulators = of_get_child_by_name(np, "regulators");
         if (!regulators) {
                 dev_err(&pdev->dev, "regulator node not found\n");
                 return NULL;
@@ -396,6 +393,7 @@ static struct tps6507x_board *tps6507x_parse_dt_reg_data(
         matches = tps6507x_matches;
 
         ret = of_regulator_match(&pdev->dev, regulators, matches, count);
+        of_node_put(regulators);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Error parsing regulator init data: %d\n",
                         ret);
@@ -406,10 +404,8 @@ static struct tps6507x_board *tps6507x_parse_dt_reg_data(
 
         reg_data = devm_kzalloc(&pdev->dev, (sizeof(struct regulator_init_data)
                                         * TPS6507X_NUM_REGULATOR), GFP_KERNEL);
-        if (!reg_data) {
-                dev_err(&pdev->dev, "Failure to alloc init data for regulators.\n");
+        if (!reg_data)
                 return NULL;
-        }
 
         tps_board->tps6507x_pmic_init_data = reg_data;
 
@@ -424,15 +420,7 @@ static struct tps6507x_board *tps6507x_parse_dt_reg_data(
 
         return tps_board;
 }
-#else
-static inline struct tps6507x_board *tps6507x_parse_dt_reg_data(
-                        struct platform_device *pdev,
-                        struct of_regulator_match **tps6507x_reg_matches)
-{
-        *tps6507x_reg_matches = NULL;
-        return NULL;
-}
-#endif
+
 static int tps6507x_pmic_probe(struct platform_device *pdev)
 {
         struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
@@ -453,9 +441,10 @@ static int tps6507x_pmic_probe(struct platform_device *pdev)
          */
 
         tps_board = dev_get_platdata(tps6507x_dev->dev);
-        if (!tps_board && tps6507x_dev->dev->of_node)
+        if (IS_ENABLED(CONFIG_OF) && !tps_board &&
+                tps6507x_dev->dev->of_node)
                 tps_board = tps6507x_parse_dt_reg_data(pdev,
-                                                &tps6507x_reg_matches);
+                                &tps6507x_reg_matches);
         if (!tps_board)
                 return -EINVAL;
 
@@ -481,7 +470,7 @@ static int tps6507x_pmic_probe(struct platform_device *pdev)
                 tps->info[i] = info;
                 if (init_data->driver_data) {
                         struct tps6507x_reg_platform_data *data =
-                                                        init_data->driver_data;
+                                        init_data->driver_data;
                         tps->info[i]->defdcdc_default = data->defdcdc_default;
                 }
 
diff --git a/drivers/regulator/tps65090-regulator.c b/drivers/regulator/tps65090-regulator.c
index 676f75548f00..2e92ef68574d 100644
--- a/drivers/regulator/tps65090-regulator.c
+++ b/drivers/regulator/tps65090-regulator.c
@@ -168,17 +168,13 @@ static struct tps65090_platform_data *tps65090_parse_dt_reg_data(
 
         tps65090_pdata = devm_kzalloc(&pdev->dev, sizeof(*tps65090_pdata),
                                 GFP_KERNEL);
-        if (!tps65090_pdata) {
-                dev_err(&pdev->dev, "Memory alloc for tps65090_pdata failed\n");
+        if (!tps65090_pdata)
                 return ERR_PTR(-ENOMEM);
-        }
 
         reg_pdata = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX *
                                 sizeof(*reg_pdata), GFP_KERNEL);
-        if (!reg_pdata) {
-                dev_err(&pdev->dev, "Memory alloc for reg_pdata failed\n");
+        if (!reg_pdata)
                 return ERR_PTR(-ENOMEM);
-        }
 
         regulators = of_get_child_by_name(np, "regulators");
         if (!regulators) {
@@ -188,6 +184,7 @@ static struct tps65090_platform_data *tps65090_parse_dt_reg_data(
 
         ret = of_regulator_match(&pdev->dev, regulators, tps65090_matches,
                         ARRAY_SIZE(tps65090_matches));
+        of_node_put(regulators);
         if (ret < 0) {
                 dev_err(&pdev->dev,
                         "Error parsing regulator init data: %d\n", ret);
@@ -252,10 +249,8 @@ static int tps65090_regulator_probe(struct platform_device *pdev)
 
         pmic = devm_kzalloc(&pdev->dev, TPS65090_REGULATOR_MAX * sizeof(*pmic),
                         GFP_KERNEL);
-        if (!pmic) {
-                dev_err(&pdev->dev, "mem alloc for pmic failed\n");
+        if (!pmic)
                 return -ENOMEM;
-        }
 
         for (num = 0; num < TPS65090_REGULATOR_MAX; num++) {
                 tps_pdata = tps65090_pdata->reg_pdata[num];
diff --git a/drivers/regulator/tps65217-regulator.c b/drivers/regulator/tps65217-regulator.c
index 9ea1bf26bd13..10b78d2b766a 100644
--- a/drivers/regulator/tps65217-regulator.c
+++ b/drivers/regulator/tps65217-regulator.c
@@ -187,7 +187,7 @@ static struct tps65217_board *tps65217_parse_dt(struct platform_device *pdev)
         struct device_node *regs;
         int i, count;
 
-        regs = of_find_node_by_name(node, "regulators");
+        regs = of_get_child_by_name(node, "regulators");
         if (!regs)
                 return NULL;
 
@@ -202,7 +202,7 @@ static struct tps65217_board *tps65217_parse_dt(struct platform_device *pdev)
                 return NULL;
 
         for (i = 0; i < count; i++) {
-                if (!reg_matches[i].init_data || !reg_matches[i].of_node)
+                if (!reg_matches[i].of_node)
                         continue;
 
                 pdata->tps65217_init_data[i] = reg_matches[i].init_data;
@@ -222,7 +222,6 @@ static int 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 regulator_config config = { };
         int i;
@@ -243,19 +242,9 @@ static int tps65217_regulator_probe(struct platform_device *pdev)
         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 */
                 config.dev = tps->dev;
-                config.init_data = reg_data;
+                config.init_data = pdata->tps65217_init_data[i];
                 config.driver_data = tps;
                 config.regmap = tps->regmap;
                 if (tps->dev->of_node)