regulator: core: Use a struct to pass in regulator runtime configuration

Rather than adding new arguments to regulator_register() every time we
want to add a new bit of dynamic information at runtime change the function
to take these via a struct. By doing this we avoid needing to do further
changes like the recent addition of device tree support which required each
regulator driver to be updated to take an additional parameter.

The regulator_desc which should (mostly) be static data is still passed
separately as most drivers are able to configure this statically at build
time.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>

43 files changed, 299 insertions, 113 deletions

diff --git a/drivers/regulator/88pm8607.c b/drivers/regulator/88pm8607.c
index 11e5ddd7e796..d04fbe953dd8 100644
--- a/drivers/regulator/88pm8607.c
+++ b/drivers/regulator/88pm8607.c
@@ -365,6 +365,7 @@ static int __devinit pm8607_regulator_probe(struct platform_device *pdev)
         struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
         struct pm8607_regulator_info *info = NULL;
         struct regulator_init_data *pdata = pdev->dev.platform_data;
+        struct regulator_config config = { };
         struct resource *res;
         int i;
 
@@ -390,9 +391,12 @@ static int __devinit pm8607_regulator_probe(struct platform_device *pdev)
         if ((i == PM8607_ID_BUCK3) && info->chip->buck3_double)
                 info->slope_double = 1;
 
+        config.dev = &pdev->dev;
+        config.init_data = pdata;
+        config.driver_data = info;
+
         /* replace driver_data with info */
-        info->regulator = regulator_register(&info->desc, &pdev->dev,
-                                             pdata, info, NULL);
+        info->regulator = regulator_register(&info->desc, &config);
         if (IS_ERR(info->regulator)) {
                 dev_err(&pdev->dev, "failed to register regulator %s\n",
                         info->desc.name);
diff --git a/drivers/regulator/aat2870-regulator.c b/drivers/regulator/aat2870-regulator.c
index 7cc380e950f6..7f000d6bb984 100644
--- a/drivers/regulator/aat2870-regulator.c
+++ b/drivers/regulator/aat2870-regulator.c
@@ -178,6 +178,7 @@ static struct aat2870_regulator *aat2870_get_regulator(int id)
 static int aat2870_regulator_probe(struct platform_device *pdev)
 {
         struct aat2870_regulator *ri;
+        struct regulator_config config = { 0 };
         struct regulator_dev *rdev;
 
         ri = aat2870_get_regulator(pdev->id);
@@ -187,8 +188,11 @@ static int aat2870_regulator_probe(struct platform_device *pdev)
         }
         ri->aat2870 = dev_get_drvdata(pdev->dev.parent);
 
-        rdev = regulator_register(&ri->desc, &pdev->dev,
-                                  pdev->dev.platform_data, ri, NULL);
+        config.dev = &pdev->dev;
+        config.driver_data = ri;
+        config.init_data = pdev->dev.platform_data;
+
+        rdev = regulator_register(&ri->desc, &config);
         if (IS_ERR(rdev)) {
                 dev_err(&pdev->dev, "Failed to register regulator %s\n",
                         ri->desc.name);
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
index ed56c9352e6f..ce6192592ca2 100644
--- a/drivers/regulator/ab3100.c
+++ b/drivers/regulator/ab3100.c
@@ -574,6 +574,7 @@ ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
 static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
 {
         struct ab3100_platform_data *plfdata = pdev->dev.platform_data;
+        struct regulator_config config = { };
         int err = 0;
         u8 data;
         int i;
@@ -619,15 +620,15 @@ static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
                 reg->dev = &pdev->dev;
                 reg->plfdata = plfdata;
 
+                config.dev = &pdev->dev;
+                config.driver_data = reg;
+                config.init_data = &plfdata->reg_constraints[i];
+
                 /*
                  * Register the regulator, pass around
                  * the ab3100_regulator struct
                  */
-                rdev = regulator_register(&ab3100_regulator_desc[i],
-                                          &pdev->dev,
-                                          &plfdata->reg_constraints[i],
-                                          reg, NULL);
-
+                rdev = regulator_register(&ab3100_regulator_desc[i], &config);
                 if (IS_ERR(rdev)) {
                         err = PTR_ERR(rdev);
                         dev_err(&pdev->dev,
diff --git a/drivers/regulator/ab8500.c b/drivers/regulator/ab8500.c
index 0d095b6e567a..93feadaf40c0 100644
--- a/drivers/regulator/ab8500.c
+++ b/drivers/regulator/ab8500.c
@@ -712,6 +712,7 @@ static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
 {
         struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
         struct ab8500_platform_data *pdata;
+        struct regulator_config config = { };
         int i, err;
 
         if (!ab8500) {
@@ -779,6 +780,10 @@ static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
                 info = &ab8500_regulator_info[i];
                 info->dev = &pdev->dev;
 
+                config->dev = &pdev->dev;
+                config->init_data = &pdata->regulator[i];
+                config->driver_data = info;
+
                 /* fix for hardware before ab8500v2.0 */
                 if (abx500_get_chip_id(info->dev) < 0x20) {
                         if (info->desc.id == AB8500_LDO_AUX3) {
@@ -792,8 +797,7 @@ static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
                 }
 
                 /* register regulator with framework */
-                info->regulator = regulator_register(&info->desc, &pdev->dev,
-                                &pdata->regulator[i], info, NULL);
+                info->regulator = regulator_register(&info->desc, &config);
                 if (IS_ERR(info->regulator)) {
                         err = PTR_ERR(info->regulator);
                         dev_err(&pdev->dev, "failed to register regulator %s\n",
diff --git a/drivers/regulator/ad5398.c b/drivers/regulator/ad5398.c
index 9ba69c431da8..46d05f38baf8 100644
--- a/drivers/regulator/ad5398.c
+++ b/drivers/regulator/ad5398.c
@@ -212,6 +212,7 @@ static int __devinit ad5398_probe(struct i2c_client *client,
                                 const struct i2c_device_id *id)
 {
         struct regulator_init_data *init_data = client->dev.platform_data;
+        struct regulator_config config = { };
         struct ad5398_chip_info *chip;
         const struct ad5398_current_data_format *df =
                         (struct ad5398_current_data_format *)id->driver_data;
@@ -224,6 +225,10 @@ static int __devinit ad5398_probe(struct i2c_client *client,
         if (!chip)
                 return -ENOMEM;
 
+        config.dev = &client->dev;
+        config.init_data = init_data;
+        config.driver_data = chip;
+
         chip->client = client;
 
         chip->min_uA = df->min_uA;
@@ -232,8 +237,7 @@ static int __devinit ad5398_probe(struct i2c_client *client,
         chip->current_offset = df->current_offset;
         chip->current_mask = (chip->current_level - 1) << chip->current_offset;
 
-        chip->rdev = regulator_register(&ad5398_reg, &client->dev,
-                                        init_data, chip, NULL);
+        chip->rdev = regulator_register(&ad5398_reg, &config);
         if (IS_ERR(chip->rdev)) {
                 ret = PTR_ERR(chip->rdev);
                 dev_err(&client->dev, "failed to register %s %s\n",
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index c4b626789f8e..8b9f8602d47b 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -2820,27 +2820,24 @@ static void rdev_init_debugfs(struct regulator_dev *rdev)
 /**
  * regulator_register - register regulator
  * @regulator_desc: regulator to register
- * @dev: struct device for the regulator
- * @init_data: platform provided init data, passed through by driver
- * @driver_data: private regulator data
- * @of_node: OpenFirmware node to parse for device tree bindings (may be
- *           NULL).
+ * @config: runtime configuration for regulator
  *
  * Called by regulator drivers to register a regulator.
  * Returns 0 on success.
  */
 struct regulator_dev *
 regulator_register(const struct regulator_desc *regulator_desc,
-        struct device *dev, const struct regulator_init_data *init_data,
-        void *driver_data, struct device_node *of_node)
+                   const struct regulator_config *config)
 {
         const struct regulation_constraints *constraints = NULL;
+        const struct regulator_init_data *init_data;
         static atomic_t regulator_no = ATOMIC_INIT(0);
         struct regulator_dev *rdev;
+        struct device *dev = config->dev;
         int ret, i;
         const char *supply = NULL;
 
-        if (regulator_desc == NULL)
+        if (regulator_desc == NULL || config == NULL)
                 return ERR_PTR(-EINVAL);
 
         if (regulator_desc->name == NULL || regulator_desc->ops == NULL)
@@ -2866,6 +2863,8 @@ regulator_register(const struct regulator_desc *regulator_desc,
                 return ERR_PTR(-EINVAL);
         }
 
+        init_data = config->init_data;
+
         rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
         if (rdev == NULL)
                 return ERR_PTR(-ENOMEM);
@@ -2873,7 +2872,7 @@ regulator_register(const struct regulator_desc *regulator_desc,
         mutex_lock(&regulator_list_mutex);
 
         mutex_init(&rdev->mutex);
-        rdev->reg_data = driver_data;
+        rdev->reg_data = config->driver_data;
         rdev->owner = regulator_desc->owner;
         rdev->desc = regulator_desc;
         INIT_LIST_HEAD(&rdev->consumer_list);
@@ -2890,7 +2889,7 @@ regulator_register(const struct regulator_desc *regulator_desc,
 
         /* register with sysfs */
         rdev->dev.class = &regulator_class;
-        rdev->dev.of_node = of_node;
+        rdev->dev.of_node = config->of_node;
         rdev->dev.parent = dev;
         dev_set_name(&rdev->dev, "regulator.%d",
                      atomic_inc_return(&regulator_no) - 1);
diff --git a/drivers/regulator/da903x.c b/drivers/regulator/da903x.c
index 1851f0929ef0..4630b1ee9966 100644
--- a/drivers/regulator/da903x.c
+++ b/drivers/regulator/da903x.c
@@ -517,6 +517,7 @@ static int __devinit da903x_regulator_probe(struct platform_device *pdev)
 {
         struct da903x_regulator_info *ri = NULL;
         struct regulator_dev *rdev;
+        struct regulator_config config = { };
 
         ri = find_regulator_info(pdev->id);
         if (ri == NULL) {
@@ -536,8 +537,11 @@ static int __devinit da903x_regulator_probe(struct platform_device *pdev)
         if (ri->desc.id == DA9030_ID_LDO1 || ri->desc.id == DA9030_ID_LDO15)
                 ri->desc.ops = &da9030_regulator_ldo1_15_ops;
 
-        rdev = regulator_register(&ri->desc, &pdev->dev,
-                                  pdev->dev.platform_data, ri, NULL);
+        config.dev = &pdev->dev;
+        conifg.init_data = pdev->dev.platform_data;
+        config.driver_data = ri;
+
+        rdev = regulator_register(&ri->desc, &config);
         if (IS_ERR(rdev)) {
                 dev_err(&pdev->dev, "failed to register regulator %s\n",
                                 ri->desc.name);
diff --git a/drivers/regulator/da9052-regulator.c b/drivers/regulator/da9052-regulator.c
index 83e489f76a90..b6c8c4be83c9 100644
--- a/drivers/regulator/da9052-regulator.c
+++ b/drivers/regulator/da9052-regulator.c
@@ -403,6 +403,7 @@ static inline struct da9052_regulator_info *find_regulator_info(u8 chip_id,
 
 static int __devinit da9052_regulator_probe(struct platform_device *pdev)
 {
+        struct regulator_config config = { };
         struct da9052_regulator *regulator;
         struct da9052 *da9052;
         struct da9052_pdata *pdata;
@@ -422,10 +423,13 @@ static int __devinit da9052_regulator_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "invalid regulator ID specified\n");
                 return -EINVAL;
         }
+
+        config.dev = &pdev->dev;
+        config.init_data = pdata->regulators[pdev->id];
+        config.driver_data = regulator;
+
         regulator->rdev = regulator_register(&regulator->info->reg_desc,
-                                             &pdev->dev,
-                                             pdata->regulators[pdev->id],
-                                             regulator, NULL);
+                                             &config);
         if (IS_ERR(regulator->rdev)) {
                 dev_err(&pdev->dev, "failed to register regulator %s\n",
                         regulator->info->reg_desc.name);
diff --git a/drivers/regulator/db8500-prcmu.c b/drivers/regulator/db8500-prcmu.c
index 4bd25e75efa0..87b2e83be11c 100644
--- a/drivers/regulator/db8500-prcmu.c
+++ b/drivers/regulator/db8500-prcmu.c
@@ -414,6 +414,7 @@ static int __devinit db8500_regulator_probe(struct platform_device *pdev)
 {
         struct regulator_init_data *db8500_init_data =
                                         dev_get_platdata(&pdev->dev);
+        struct regulator_config config = { };
         int i, err;
 
         /* register all regulators */
@@ -425,9 +426,12 @@ static int __devinit db8500_regulator_probe(struct platform_device *pdev)
                 info = &dbx500_regulator_info[i];
                 info->dev = &pdev->dev;
 
+                config.dev = &pdev->dev;
+                config.init_data = init_data;
+                config.driver_data = info;
+
                 /* register with the regulator framework */
-                info->rdev = regulator_register(&info->desc, &pdev->dev,
-                                init_data, info, NULL);
+                info->rdev = regulator_register(&info->desc, &config);
                 if (IS_ERR(info->rdev)) {
                         err = PTR_ERR(info->rdev);
                         dev_err(&pdev->dev, "failed to register %s: err %i\n",
diff --git a/drivers/regulator/dummy.c b/drivers/regulator/dummy.c
index 0ee00de4be72..1571bee6b1bc 100644
--- a/drivers/regulator/dummy.c
+++ b/drivers/regulator/dummy.c
@@ -39,10 +39,12 @@ static struct regulator_desc dummy_desc = {
 
 static int __devinit dummy_regulator_probe(struct platform_device *pdev)
 {
+        struct regulator_config config = { };
         int ret;
 
-        dummy_regulator_rdev = regulator_register(&dummy_desc, NULL,
-                                                  &dummy_initdata, NULL, NULL);
+        config.init_data = &dummy_initdata;
+
+        dummy_regulator_rdev = regulator_register(&dummy_desc, &config);
         if (IS_ERR(dummy_regulator_rdev)) {
                 ret = PTR_ERR(dummy_regulator_rdev);
                 pr_err("Failed to register regulator: %d\n", ret);
diff --git a/drivers/regulator/fixed.c b/drivers/regulator/fixed.c
index 9a7d70a9c8d7..b47b005a8d28 100644
--- a/drivers/regulator/fixed.c
+++ b/drivers/regulator/fixed.c
@@ -167,6 +167,7 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
 {
         struct fixed_voltage_config *config;
         struct fixed_voltage_data *drvdata;
+        struct regulator_config cfg = { };
         int ret;
 
         if (pdev->dev.of_node)
@@ -247,9 +248,12 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
                 drvdata->desc.ops = &fixed_voltage_ops;
         }
 
-        drvdata->dev = regulator_register(&drvdata->desc, &pdev->dev,
-                                          config->init_data, drvdata,
-                                          pdev->dev.of_node);
+        cfg.dev = &pdev->dev;
+        cfg.init_data = config->init_data;
+        cfg.driver_data = drvdata;
+        cfg.of_node = pdev->dev.of_node;
+
+        drvdata->dev = regulator_register(&drvdata->desc, &cfg);
         if (IS_ERR(drvdata->dev)) {
                 ret = PTR_ERR(drvdata->dev);
                 dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c
index ad0fc78c3cb4..f93b06b1e7ec 100644
--- a/drivers/regulator/gpio-regulator.c
+++ b/drivers/regulator/gpio-regulator.c
@@ -172,6 +172,7 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
 {
         struct gpio_regulator_config *config = pdev->dev.platform_data;
         struct gpio_regulator_data *drvdata;
+        struct regulator_config cfg = { };
         int ptr, ret, state;
 
         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct gpio_regulator_data),
@@ -284,8 +285,11 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
         }
         drvdata->state = state;
 
-        drvdata->dev = regulator_register(&drvdata->desc, &pdev->dev,
-                                          config->init_data, drvdata, NULL);
+        cfg.dev = &pdev->dev;
+        cfg.init_data = config->init_data;
+        cfg.driver_data = &drvdata;
+
+        drvdata->dev = regulator_register(&drvdata->desc, &cfg);
         if (IS_ERR(drvdata->dev)) {
                 ret = PTR_ERR(drvdata->dev);
                 dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
diff --git a/drivers/regulator/isl6271a-regulator.c b/drivers/regulator/isl6271a-regulator.c
index eee6f6b85ebc..863f45a18c30 100644
--- a/drivers/regulator/isl6271a-regulator.c
+++ b/drivers/regulator/isl6271a-regulator.c
@@ -140,6 +140,7 @@ static const struct regulator_desc isl_rd[] = {
 static int __devinit isl6271a_probe(struct i2c_client *i2c,
                                      const struct i2c_device_id *id)
 {
+        struct regulator_config config = { };
         struct regulator_init_data *init_data   = i2c->dev.platform_data;
         struct isl_pmic *pmic;
         int err, i;
@@ -156,8 +157,14 @@ static int __devinit isl6271a_probe(struct i2c_client *i2c,
         mutex_init(&pmic->mtx);
 
         for (i = 0; i < 3; i++) {
-                pmic->rdev[i] = regulator_register(&isl_rd[i], &i2c->dev,
-                                                init_data, pmic, NULL);
+                config.dev = &i2c->dev;
+                if (i == 0)
+                        config.init_data = init_data;
+                else
+                        config.init_data = 0;
+                config.driver_data = pmic;
+
+                pmic->rdev[i] = regulator_register(&isl_rd[i], &config);
                 if (IS_ERR(pmic->rdev[i])) {
                         dev_err(&i2c->dev, "failed to register %s\n", id->name);
                         err = PTR_ERR(pmic->rdev[i]);
diff --git a/drivers/regulator/lp3971.c b/drivers/regulator/lp3971.c
index 499986e00fb2..981bea9cb9d7 100644
--- a/drivers/regulator/lp3971.c
+++ b/drivers/regulator/lp3971.c
@@ -421,10 +421,15 @@ static int __devinit setup_regulators(struct lp3971 *lp3971,
 
         /* Instantiate the regulators */
         for (i = 0; i < pdata->num_regulators; i++) {
+                struct regulator_config config = { };
                 struct lp3971_regulator_subdev *reg = &pdata->regulators[i];
-                lp3971->rdev[i] = regulator_register(&regulators[reg->id],
-                                lp3971->dev, reg->initdata, lp3971, NULL);
 
+                config.dev = lp3971->dev;
+                config.init_data = reg->initdata;
+                config.driver_data = lp3971;
+
+                lp3971->rdev[i] = regulator_register(&regulators[reg->id],
+                                                     &config);
                 if (IS_ERR(lp3971->rdev[i])) {
                         err = PTR_ERR(lp3971->rdev[i]);
                         dev_err(lp3971->dev, "regulator init failed: %d\n",
diff --git a/drivers/regulator/lp3972.c b/drivers/regulator/lp3972.c
index fbe3a58a71f2..de073df7d344 100644
--- a/drivers/regulator/lp3972.c
+++ b/drivers/regulator/lp3972.c
@@ -527,9 +527,14 @@ static int __devinit setup_regulators(struct lp3972 *lp3972,
         /* Instantiate the regulators */
         for (i = 0; i < pdata->num_regulators; i++) {
                 struct lp3972_regulator_subdev *reg = &pdata->regulators[i];
-                lp3972->rdev[i] = regulator_register(&regulators[reg->id],
-                                lp3972->dev, reg->initdata, lp3972, NULL);
+                struct regulator_config config = { };
+
+                config.dev = lp3972->dev;
+                config.init_data = reg->initdata;
+                config.driver_data = lp3972;
 
+                lp3972->rdev[i] = regulator_register(&regulators[reg->id],
+                                                     &config);
                 if (IS_ERR(lp3972->rdev[i])) {
                         err = PTR_ERR(lp3972->rdev[i]);
                         dev_err(lp3972->dev, "regulator init failed: %d\n",
diff --git a/drivers/regulator/max1586.c b/drivers/regulator/max1586.c
index fad0bee10c54..ea832b4ef643 100644
--- a/drivers/regulator/max1586.c
+++ b/drivers/regulator/max1586.c
@@ -185,6 +185,7 @@ static int __devinit max1586_pmic_probe(struct i2c_client *client,
 {
         struct regulator_dev **rdev;
         struct max1586_platform_data *pdata = client->dev.platform_data;
+        struct regulator_config config = { };
         struct max1586_data *max1586;
         int i, id, ret = -ENOMEM;
 
@@ -212,9 +213,12 @@ static int __devinit max1586_pmic_probe(struct i2c_client *client,
                         dev_err(&client->dev, "invalid regulator id %d\n", id);
                         goto err;
                 }
-                rdev[i] = regulator_register(&max1586_reg[id], &client->dev,
-                                             pdata->subdevs[i].platform_data,
-                                             max1586, NULL);
+
+                config.dev = &client->dev;
+                config.init_data = pdata->subdevs[i].platform_data;
+                config.driver_data = max1586;
+
+                rdev[i] = regulator_register(&max1586_reg[id], &config);
                 if (IS_ERR(rdev[i])) {
                         ret = PTR_ERR(rdev[i]);
                         dev_err(&client->dev, "failed to register %s\n",
diff --git a/drivers/regulator/max8649.c b/drivers/regulator/max8649.c
index dca7835b381c..991f517c8dc8 100644
--- a/drivers/regulator/max8649.c
+++ b/drivers/regulator/max8649.c
@@ -225,6 +225,7 @@ static int __devinit max8649_regulator_probe(struct i2c_client *client,
 {
         struct max8649_platform_data *pdata = client->dev.platform_data;
         struct max8649_regulator_info *info = NULL;
+        struct regulator_config config = { };
         unsigned int val;
         unsigned char data;
         int ret;
@@ -297,8 +298,11 @@ static int __devinit max8649_regulator_probe(struct i2c_client *client,
                                    MAX8649_RAMP_DOWN);
         }
 
-        info->regulator = regulator_register(&dcdc_desc, &client->dev,
-                                             pdata->regulator, info, NULL);
+        config.dev = &client->dev;
+        config.init_data = pdata->regulator;
+        config.driver_data = info;
+
+        info->regulator = regulator_register(&dcdc_desc, &config);
         if (IS_ERR(info->regulator)) {
                 dev_err(info->dev, "failed to register regulator %s\n",
                         dcdc_desc.name);
diff --git a/drivers/regulator/max8660.c b/drivers/regulator/max8660.c
index 0e327871fd0e..88f678e4a1a7 100644
--- a/drivers/regulator/max8660.c
+++ b/drivers/regulator/max8660.c
@@ -361,6 +361,7 @@ static int __devinit max8660_probe(struct i2c_client *client,
 {
         struct regulator_dev **rdev;
         struct max8660_platform_data *pdata = client->dev.platform_data;
+        struct regulator_config config = { };
         struct max8660 *max8660;
         int boot_on, i, id, ret = -EINVAL;
 
@@ -449,9 +450,11 @@ static int __devinit max8660_probe(struct i2c_client *client,
 
                 id = pdata->subdevs[i].id;
 
-                rdev[i] = regulator_register(&max8660_reg[id], &client->dev,
-                                             pdata->subdevs[i].platform_data,
-                                             max8660, NULL);
+                config.dev = &client->dev;
+                config.init_data = pdata->subdevs[i].platform_data;
+                config.driver_data = max8660;
+
+                rdev[i] = regulator_register(&max8660_reg[id], &config);
                 if (IS_ERR(rdev[i])) {
                         ret = PTR_ERR(rdev[i]);
                         dev_err(&client->dev, "failed to register %s\n",
diff --git a/drivers/regulator/max8925-regulator.c b/drivers/regulator/max8925-regulator.c
index a62f3b5cc312..de30ea2b80f5 100644
--- a/drivers/regulator/max8925-regulator.c
+++ b/drivers/regulator/max8925-regulator.c
@@ -258,6 +258,7 @@ static int __devinit max8925_regulator_probe(struct platform_device *pdev)
 {
         struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
         struct max8925_platform_data *pdata = chip->dev->platform_data;
+        struct regulator_config config = { };
         struct max8925_regulator_info *ri;
         struct regulator_dev *rdev;
 
@@ -269,8 +270,11 @@ static int __devinit max8925_regulator_probe(struct platform_device *pdev)
         ri->i2c = chip->i2c;
         ri->chip = chip;
 
-        rdev = regulator_register(&ri->desc, &pdev->dev,
-                                  pdata->regulator[pdev->id], ri, NULL);
+        config.dev = &pdev->dev;
+        config.init_data = pdata->regulator[pdev->id];
+        config.driver_data = ri;
+
+        rdev = regulator_register(&ri->desc, &config);
         if (IS_ERR(rdev)) {
                 dev_err(&pdev->dev, "failed to register regulator %s\n",
                                 ri->desc.name);
diff --git a/drivers/regulator/max8952.c b/drivers/regulator/max8952.c
index b4084314c222..c0ab4ddc1023 100644
--- a/drivers/regulator/max8952.c
+++ b/drivers/regulator/max8952.c
@@ -173,6 +173,7 @@ static int __devinit max8952_pmic_probe(struct i2c_client *client,
 {
         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
         struct max8952_platform_data *pdata = client->dev.platform_data;
+        struct regulator_config config = { };
         struct max8952_data *max8952;
 
         int ret = 0, err = 0;
@@ -193,8 +194,11 @@ static int __devinit max8952_pmic_probe(struct i2c_client *client,
         max8952->dev = &client->dev;
         max8952->pdata = pdata;
 
-        max8952->rdev = regulator_register(&regulator, max8952->dev,
-                        &pdata->reg_data, max8952, NULL);
+        config.dev = max8952->dev;
+        config.init_data = &pdata->reg_data;
+        config.driver_data = max8952;
+
+        max8952->rdev = regulator_register(&regulator, &config);
 
         if (IS_ERR(max8952->rdev)) {
                 ret = PTR_ERR(max8952->rdev);
diff --git a/drivers/regulator/max8997.c b/drivers/regulator/max8997.c
index 6e7beee1c205..48fa966929eb 100644
--- a/drivers/regulator/max8997.c
+++ b/drivers/regulator/max8997.c
@@ -913,6 +913,7 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
 {
         struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
         struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct regulator_config config = { };
         struct regulator_dev **rdev;
         struct max8997_data *max8997;
         struct i2c_client *i2c;
@@ -1096,8 +1097,11 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                 else if (id == MAX8997_CHARGER_CV)
                         regulators[id].n_voltages = 16;
 
-                rdev[i] = regulator_register(&regulators[id], max8997->dev,
-                                pdata->regulators[i].initdata, max8997, NULL);
+                config.dev = max8997->dev;
+                config.init_data = pdata->regulators[i].initdata;
+                config.driver_data = max8997;
+
+                rdev[i] = regulator_register(&regulators[id], &config);
                 if (IS_ERR(rdev[i])) {
                         ret = PTR_ERR(rdev[i]);
                         dev_err(max8997->dev, "regulator init failed for %d\n",
diff --git a/drivers/regulator/max8998.c b/drivers/regulator/max8998.c
index 5890265eeacc..74b0b0c94120 100644
--- a/drivers/regulator/max8998.c
+++ b/drivers/regulator/max8998.c
@@ -685,6 +685,7 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
 {
         struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent);
         struct max8998_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct regulator_config config = { };
         struct regulator_dev **rdev;
         struct max8998_data *max8998;
         struct i2c_client *i2c;
@@ -840,8 +841,12 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                         int count = (desc->max - desc->min) / desc->step + 1;
                         regulators[index].n_voltages = count;
                 }
-                rdev[i] = regulator_register(&regulators[index], max8998->dev,
-                                pdata->regulators[i].initdata, max8998, NULL);
+
+                config.dev = max8998->dev;
+                config.init_data = pdata->regulators[i].initdata;
+                config.driver_data = max8998;
+
+                rdev[i] = regulator_register(&regulators[index], &config);
                 if (IS_ERR(rdev[i])) {
                         ret = PTR_ERR(rdev[i]);
                         dev_err(max8998->dev, "regulator init failed\n");
diff --git a/drivers/regulator/pcap-regulator.c b/drivers/regulator/pcap-regulator.c
index b55128db07cc..8211101121f0 100644
--- a/drivers/regulator/pcap-regulator.c
+++ b/drivers/regulator/pcap-regulator.c
@@ -251,9 +251,13 @@ static int __devinit pcap_regulator_probe(struct platform_device *pdev)
 {
         struct regulator_dev *rdev;
         void *pcap = dev_get_drvdata(pdev->dev.parent);
+        struct regulator_config config = { };
 
-        rdev = regulator_register(&pcap_regulators[pdev->id], &pdev->dev,
-                                pdev->dev.platform_data, pcap, NULL);
+        config.dev = &pdev->dev;
+        config.init_data = pdev->dev.platform_data;
+        config.driver_data = pcap;
+
+        rdev = regulator_register(&pcap_regulators[pdev->id], &config);
         if (IS_ERR(rdev))
                 return PTR_ERR(rdev);
 
diff --git a/drivers/regulator/pcf50633-regulator.c b/drivers/regulator/pcf50633-regulator.c
index 43163f14bec7..7ee70f1b3f24 100644
--- a/drivers/regulator/pcf50633-regulator.c
+++ b/drivers/regulator/pcf50633-regulator.c
@@ -296,12 +296,16 @@ static int __devinit pcf50633_regulator_probe(struct platform_device *pdev)
 {
         struct regulator_dev *rdev;
         struct pcf50633 *pcf;
+        struct regulator_config config = { };
 
         /* Already set by core driver */
         pcf = dev_to_pcf50633(pdev->dev.parent);
 
-        rdev = regulator_register(&regulators[pdev->id], &pdev->dev,
-                                  pdev->dev.platform_data, pcf, NULL);
+        config.dev = &pdev->dev;
+        config.init_data = pdev->dev.platform_data;
+        config.driver_data = pcf;
+
+        rdev = regulator_register(&regulators[pdev->id], &config);
         if (IS_ERR(rdev))
                 return PTR_ERR(rdev);
 
diff --git a/drivers/regulator/rc5t583-regulator.c b/drivers/regulator/rc5t583-regulator.c
index fe094a6140d9..b567c9ec47c1 100644
--- a/drivers/regulator/rc5t583-regulator.c
+++ b/drivers/regulator/rc5t583-regulator.c
@@ -251,6 +251,7 @@ static int __devinit 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;
         struct regulator_dev *rdev;
@@ -300,8 +301,11 @@ static int __devinit rc5t583_regulator_probe(struct platform_device *pdev)
                                 "Failed to configure ext control %d\n", id);
 
 skip_ext_pwr_config:
-                rdev = regulator_register(&ri->desc, &pdev->dev,
-                                        reg_data, reg, NULL);
+                config.dev = &pdev->dev;
+                config.init_data = reg_data;
+                config.driver_data = reg;
+
+                rdev = regulator_register(&ri->desc, &config);
                 if (IS_ERR(rdev)) {
                         dev_err(&pdev->dev, "Failed to register regulator %s\n",
                                                 ri->desc.name);
diff --git a/drivers/regulator/s5m8767.c b/drivers/regulator/s5m8767.c
index a2afc0edc5a4..10c38f9ae787 100644
--- a/drivers/regulator/s5m8767.c
+++ b/drivers/regulator/s5m8767.c
@@ -579,6 +579,7 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
 {
         struct s5m87xx_dev *iodev = dev_get_drvdata(pdev->dev.parent);
         struct s5m_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct regulator_config config = { };
         struct regulator_dev **rdev;
         struct s5m8767_info *s5m8767;
         int i, ret, size;
@@ -774,8 +775,11 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
                         regulators[id].n_voltages =
                                 (desc->max - desc->min) / desc->step + 1;
 
-                rdev[i] = regulator_register(&regulators[id], s5m8767->dev,
-                                pdata->regulators[i].initdata, s5m8767, NULL);
+                config.dev = s5m8767->dev;
+                config.init_data = pdata->regulators[i].initdata;
+                config.driver_data = s5m8767;
+
+                rdev[i] = regulator_register(&regulators[id], &config);
                 if (IS_ERR(rdev[i])) {
                         ret = PTR_ERR(rdev[i]);
                         dev_err(s5m8767->dev, "regulator init failed for %d\n",
diff --git a/drivers/regulator/tps6105x-regulator.c b/drivers/regulator/tps6105x-regulator.c
index 3b788977cb72..d840d8440a91 100644
--- a/drivers/regulator/tps6105x-regulator.c
+++ b/drivers/regulator/tps6105x-regulator.c
@@ -139,6 +139,7 @@ static int __devinit tps6105x_regulator_probe(struct platform_device *pdev)
 {
         struct tps6105x *tps6105x = dev_get_platdata(&pdev->dev);
         struct tps6105x_platform_data *pdata = tps6105x->pdata;
+        struct regulator_config config = { };
         int ret;
 
         /* This instance is not set for regulator mode so bail out */
@@ -148,11 +149,13 @@ static int __devinit tps6105x_regulator_probe(struct platform_device *pdev)
                 return 0;
         }
 
+        config.dev = &tps6105x->client->dev;
+        config.init_data = pdata->regulator_data;
+        config.driver_data = tps6105x;
+
         /* Register regulator with framework */
         tps6105x->regulator = regulator_register(&tps6105x_regulator_desc,
-                                             &tps6105x->client->dev,
-                                             pdata->regulator_data, tps6105x,
-                                             NULL);
+                                                 &config);
         if (IS_ERR(tps6105x->regulator)) {
                 ret = PTR_ERR(tps6105x->regulator);
                 dev_err(&tps6105x->client->dev,
diff --git a/drivers/regulator/tps62360-regulator.c b/drivers/regulator/tps62360-regulator.c
index aa57632c0150..8fffc6e45b3a 100644
--- a/drivers/regulator/tps62360-regulator.c
+++ b/drivers/regulator/tps62360-regulator.c
@@ -270,6 +270,7 @@ static const struct regmap_config tps62360_regmap_config = {
 static int __devinit tps62360_probe(struct i2c_client *client,
                                      const struct i2c_device_id *id)
 {
+        struct regulator_config config = { };
         struct tps62360_regulator_platform_data *pdata;
         struct regulator_dev *rdev;
         struct tps62360_chip *tps;
@@ -384,9 +385,12 @@ static int __devinit tps62360_probe(struct i2c_client *client,
                 goto err_init;
         }
 
+        config.dev = &client->dev;
+        config.init_data = &pdata->reg_init_data;
+        config.driver_data = tps;
+
         /* Register the regulators */
-        rdev = regulator_register(&tps->desc, &client->dev,
-                                &pdata->reg_init_data, tps, NULL);
+        rdev = regulator_register(&tps->desc, &config);
         if (IS_ERR(rdev)) {
                 dev_err(tps->dev, "%s() Err: Failed to register %s\n",
                                 __func__, id->name);
diff --git a/drivers/regulator/tps65023-regulator.c b/drivers/regulator/tps65023-regulator.c
index 5c9a9001f816..7755afeecede 100644
--- a/drivers/regulator/tps65023-regulator.c
+++ b/drivers/regulator/tps65023-regulator.c
@@ -376,6 +376,7 @@ static int __devinit tps_65023_probe(struct i2c_client *client,
 {
         const struct tps_driver_data *drv_data = (void *)id->driver_data;
         const struct tps_info *info = drv_data->info;
+        struct regulator_config config = { };
         struct regulator_init_data *init_data;
         struct regulator_dev *rdev;
         struct tps_pmic *tps;
@@ -420,9 +421,12 @@ static int __devinit tps_65023_probe(struct i2c_client *client,
                 tps->desc[i].type = REGULATOR_VOLTAGE;
                 tps->desc[i].owner = THIS_MODULE;
 
+                config.dev = &client->dev;
+                config.init_data = init_data;
+                config.driver_data = tps;
+
                 /* Register the regulators */
-                rdev = regulator_register(&tps->desc[i], &client->dev,
-                                          init_data, tps, NULL);
+                rdev = regulator_register(&tps->desc[i], &config);
                 if (IS_ERR(rdev)) {
                         dev_err(&client->dev, "failed to register %s\n",
                                 id->name);
diff --git a/drivers/regulator/tps6507x-regulator.c b/drivers/regulator/tps6507x-regulator.c
index 832833fe8aad..16d27fc2c7f7 100644
--- a/drivers/regulator/tps6507x-regulator.c
+++ b/drivers/regulator/tps6507x-regulator.c
@@ -404,6 +404,7 @@ static __devinit int tps6507x_pmic_probe(struct platform_device *pdev)
 {
         struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
         struct tps_info *info = &tps6507x_pmic_regs[0];
+        struct regulator_config config = { };
         struct regulator_init_data *init_data;
         struct regulator_dev *rdev;
         struct tps6507x_pmic *tps;
@@ -453,8 +454,11 @@ static __devinit int tps6507x_pmic_probe(struct platform_device *pdev)
                 tps->desc[i].type = REGULATOR_VOLTAGE;
                 tps->desc[i].owner = THIS_MODULE;
 
-                rdev = regulator_register(&tps->desc[i],
-                                        tps6507x_dev->dev, init_data, tps, NULL);
+                config.dev = tps6507x_dev->dev;
+                config.init_data = init_data;
+                config.driver_data = tps;
+
+                rdev = regulator_register(&tps->desc[i], &config);
                 if (IS_ERR(rdev)) {
                         dev_err(tps6507x_dev->dev,
                                 "failed to register %s regulator\n",
diff --git a/drivers/regulator/tps65090-regulator.c b/drivers/regulator/tps65090-regulator.c
index 7baff2e8765d..6bbf760be80a 100644
--- a/drivers/regulator/tps65090-regulator.c
+++ b/drivers/regulator/tps65090-regulator.c
@@ -137,6 +137,7 @@ static inline struct tps65090_regulator *find_regulator_info(int id)
 static int __devinit tps65090_regulator_probe(struct platform_device *pdev)
 {
         struct tps65090_regulator *ri = NULL;
+        struct regulator_config config = { };
         struct regulator_dev *rdev;
         struct tps65090_regulator_platform_data *tps_pdata;
         int id = pdev->id;
@@ -151,8 +152,11 @@ static int __devinit tps65090_regulator_probe(struct platform_device *pdev)
         tps_pdata = pdev->dev.platform_data;
         ri->dev = &pdev->dev;
 
-        rdev = regulator_register(&ri->desc, &pdev->dev,
-                                &tps_pdata->regulator, ri, NULL);
+        config.dev = &pdev->dev;
+        config.init_data = &tps_pdata->regulator;
+        config.driver_data = ri;
+
+        rdev = regulator_register(&ri->desc, &config);
         if (IS_ERR(rdev)) {
                 dev_err(&pdev->dev, "failed to register regulator %s\n",
                                 ri->desc.name);
diff --git a/drivers/regulator/tps65217-regulator.c b/drivers/regulator/tps65217-regulator.c
index 80fad2d3479e..00c5c1c96d19 100644
--- a/drivers/regulator/tps65217-regulator.c
+++ b/drivers/regulator/tps65217-regulator.c
@@ -327,13 +327,17 @@ static int __devinit tps65217_regulator_probe(struct platform_device *pdev)
         struct regulator_dev *rdev;
         struct tps65217 *tps;
         struct tps_info *info = &tps65217_pmic_regs[pdev->id];
+        struct regulator_config config = { };
 
         /* Already set by core driver */
         tps = dev_to_tps65217(pdev->dev.parent);
         tps->info[pdev->id] = info;
 
-        rdev = regulator_register(&regulators[pdev->id], &pdev->dev,
-                                  pdev->dev.platform_data, tps, NULL);
+        config.dev = &pdev->dev;
+        config.init_data = pdev->dev.platform_data;
+        config.driver_data = tps;
+
+        rdev = regulator_register(&regulators[pdev->id], &config);
         if (IS_ERR(rdev))
                 return PTR_ERR(rdev);
 
diff --git a/drivers/regulator/tps6524x-regulator.c b/drivers/regulator/tps6524x-regulator.c
index eabf0e601f65..6616af7d2956 100644
--- a/drivers/regulator/tps6524x-regulator.c
+++ b/drivers/regulator/tps6524x-regulator.c
@@ -605,6 +605,7 @@ static int __devinit pmic_probe(struct spi_device *spi)
         struct device *dev = &spi->dev;
         const struct supply_info *info = supply_info;
         struct regulator_init_data *init_data;
+        struct regulator_config config = { };
         int ret = 0, i;
 
         init_data = dev->platform_data;
@@ -636,8 +637,11 @@ static int __devinit pmic_probe(struct spi_device *spi)
                 if (info->flags & FIXED_VOLTAGE)
                         hw->desc[i].n_voltages = 1;
 
-                hw->rdev[i] = regulator_register(&hw->desc[i], dev,
-                                                 init_data, hw, NULL);
+                config.dev = dev;
+                config.init_data = init_data;
+                config.driver_data = hw;
+
+                hw->rdev[i] = regulator_register(&hw->desc[i], &config);
                 if (IS_ERR(hw->rdev[i])) {
                         ret = PTR_ERR(hw->rdev[i]);
                         hw->rdev[i] = NULL;
diff --git a/drivers/regulator/tps6586x-regulator.c b/drivers/regulator/tps6586x-regulator.c
index 2dd66fe9570f..deb855c41e16 100644
--- a/drivers/regulator/tps6586x-regulator.c
+++ b/drivers/regulator/tps6586x-regulator.c
@@ -340,6 +340,7 @@ static inline struct tps6586x_regulator *find_regulator_info(int id)
 static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
 {
         struct tps6586x_regulator *ri = NULL;
+        struct regulator_config config = { };
         struct regulator_dev *rdev;
         int id = pdev->id;
         int err;
@@ -356,8 +357,11 @@ static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
         if (err)
                 return err;
 
-        rdev = regulator_register(&ri->desc, &pdev->dev,
-                                  pdev->dev.platform_data, ri, NULL);
+        config.dev = &pdev->dev;
+        config.init_data = pdev->dev.platform_data;
+        config.driver_data = ri;
+
+        rdev = regulator_register(&ri->desc, &config);
         if (IS_ERR(rdev)) {
                 dev_err(&pdev->dev, "failed to register regulator %s\n",
                                 ri->desc.name);
diff --git a/drivers/regulator/tps65910-regulator.c b/drivers/regulator/tps65910-regulator.c
index 4a37c2b6367f..e7a4ece10628 100644
--- a/drivers/regulator/tps65910-regulator.c
+++ b/drivers/regulator/tps65910-regulator.c
@@ -1097,6 +1097,7 @@ static int tps65910_set_ext_sleep_config(struct tps65910_reg *pmic,
 static __devinit int tps65910_probe(struct platform_device *pdev)
 {
         struct tps65910 *tps65910 = dev_get_drvdata(pdev->dev.parent);
+        struct regulator_config config = { };
         struct tps_info *info;
         struct regulator_init_data *reg_data;
         struct regulator_dev *rdev;
@@ -1206,8 +1207,11 @@ static __devinit int tps65910_probe(struct platform_device *pdev)
                 pmic->desc[i].type = REGULATOR_VOLTAGE;
                 pmic->desc[i].owner = THIS_MODULE;
 
-                rdev = regulator_register(&pmic->desc[i],
-                                tps65910->dev, reg_data, pmic, NULL);
+                config.dev = tps65910->dev;
+                config.init_data = reg_data;
+                config.driver_data = pmic;
+
+                rdev = regulator_register(&pmic->desc[i], &config);
                 if (IS_ERR(rdev)) {
                         dev_err(tps65910->dev,
                                 "failed to register %s regulator\n",
diff --git a/drivers/regulator/tps65912-regulator.c b/drivers/regulator/tps65912-regulator.c
index 05ea096cf8a7..8c9c61383fee 100644
--- a/drivers/regulator/tps65912-regulator.c
+++ b/drivers/regulator/tps65912-regulator.c
@@ -463,6 +463,7 @@ static struct regulator_ops tps65912_ops_ldo = {
 static __devinit int tps65912_probe(struct platform_device *pdev)
 {
         struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
+        struct regulator_config config = { };
         struct tps_info *info;
         struct regulator_init_data *reg_data;
         struct regulator_dev *rdev;
@@ -500,8 +501,12 @@ static __devinit int tps65912_probe(struct platform_device *pdev)
                 pmic->desc[i].type = REGULATOR_VOLTAGE;
                 pmic->desc[i].owner = THIS_MODULE;
                 range = tps65912_get_range(pmic, i);
-                rdev = regulator_register(&pmic->desc[i],
-                                        tps65912->dev, reg_data, pmic, NULL);
+
+                config.dev = tps65912->dev;
+                config.init_data = reg_data;
+                config.driver_data = pmic;
+
+                rdev = regulator_register(&pmic->desc[i], &config);
                 if (IS_ERR(rdev)) {
                         dev_err(tps65912->dev,
                                 "failed to register %s regulator\n",
diff --git a/drivers/regulator/twl-regulator.c b/drivers/regulator/twl-regulator.c
index 107a08bc50d9..9cf6f59d27bc 100644
--- a/drivers/regulator/twl-regulator.c
+++ b/drivers/regulator/twl-regulator.c
@@ -1175,6 +1175,7 @@ static int __devinit twlreg_probe(struct platform_device *pdev)
         struct regulator_dev            *rdev;
         struct twl_regulator_driver_data        *drvdata;
         const struct of_device_id       *match;
+        struct regulator_config         config = { };
 
         match = of_match_device(twl_of_match, &pdev->dev);
         if (match) {
@@ -1254,8 +1255,12 @@ static int __devinit twlreg_probe(struct platform_device *pdev)
                 break;
         }
 
-        rdev = regulator_register(&info->desc, &pdev->dev, initdata, info,
-                                                        pdev->dev.of_node);
+        config.dev = &pdev->dev;
+        config.init_data = initdata;
+        config.driver_data = info;
+        config.of_node = pdev->dev.of_node;
+
+        rdev = regulator_register(&info->desc, &config);
         if (IS_ERR(rdev)) {
                 dev_err(&pdev->dev, "can't register %s, %ld\n",
                                 info->desc.name, PTR_ERR(rdev));
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
index 909c53b70375..c754eae18c4a 100644
--- a/drivers/regulator/wm831x-dcdc.c
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -495,6 +495,7 @@ static __devinit int wm831x_buckv_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        struct regulator_config config = { };
         int id;
         struct wm831x_dcdc *dcdc;
         struct resource *res;
@@ -553,8 +554,11 @@ static __devinit int wm831x_buckv_probe(struct platform_device *pdev)
         if (pdata->dcdc[id])
                 wm831x_buckv_dvs_init(dcdc, pdata->dcdc[id]->driver_data);
 
-        dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev,
-                                             pdata->dcdc[id], dcdc, NULL);
+        config.dev = pdev->dev.parent;
+        config.init_data = pdata->dcdc[id];
+        config.driver_data = dcdc;
+
+        dcdc->regulator = regulator_register(&dcdc->desc, &config);
         if (IS_ERR(dcdc->regulator)) {
                 ret = PTR_ERR(dcdc->regulator);
                 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
@@ -705,6 +709,7 @@ static __devinit int wm831x_buckp_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        struct regulator_config config = { };
         int id;
         struct wm831x_dcdc *dcdc;
         struct resource *res;
@@ -746,8 +751,11 @@ static __devinit int wm831x_buckp_probe(struct platform_device *pdev)
         dcdc->desc.ops = &wm831x_buckp_ops;
         dcdc->desc.owner = THIS_MODULE;
 
-        dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev,
-                                             pdata->dcdc[id], dcdc, NULL);
+        config.dev = pdev->dev.parent;
+        config.init_data = pdata->dcdc[id];
+        config.driver_data = dcdc;
+
+        dcdc->regulator = regulator_register(&dcdc->desc, &config);
         if (IS_ERR(dcdc->regulator)) {
                 ret = PTR_ERR(dcdc->regulator);
                 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
@@ -838,6 +846,7 @@ static __devinit int wm831x_boostp_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        struct regulator_config config = { };
         int id = pdev->id % ARRAY_SIZE(pdata->dcdc);
         struct wm831x_dcdc *dcdc;
         struct resource *res;
@@ -871,8 +880,11 @@ static __devinit int wm831x_boostp_probe(struct platform_device *pdev)
         dcdc->desc.ops = &wm831x_boostp_ops;
         dcdc->desc.owner = THIS_MODULE;
 
-        dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev,
-                                             pdata->dcdc[id], dcdc, NULL);
+        config.dev = pdev->dev.parent;
+        config.init_data = pdata->dcdc[id];
+        config.driver_data = dcdc;
+
+        dcdc->regulator = regulator_register(&dcdc->desc, &config);
         if (IS_ERR(dcdc->regulator)) {
                 ret = PTR_ERR(dcdc->regulator);
                 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
@@ -941,6 +953,7 @@ static __devinit int wm831x_epe_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        struct regulator_config config = { };
         int id = pdev->id % ARRAY_SIZE(pdata->epe);
         struct wm831x_dcdc *dcdc;
         int ret;
@@ -968,8 +981,11 @@ static __devinit int wm831x_epe_probe(struct platform_device *pdev)
         dcdc->desc.type = REGULATOR_VOLTAGE;
         dcdc->desc.owner = THIS_MODULE;
 
-        dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev,
-                                             pdata->epe[id], dcdc, NULL);
+        config.dev = pdev->dev.parent;
+        config.init_data = pdata->epe[id];
+        config.driver_data = dcdc;
+
+        dcdc->regulator = regulator_register(&dcdc->desc, &config);
         if (IS_ERR(dcdc->regulator)) {
                 ret = PTR_ERR(dcdc->regulator);
                 dev_err(wm831x->dev, "Failed to register EPE%d: %d\n",
diff --git a/drivers/regulator/wm831x-isink.c b/drivers/regulator/wm831x-isink.c
index 634aac3f2d5f..046fabf648d2 100644
--- a/drivers/regulator/wm831x-isink.c
+++ b/drivers/regulator/wm831x-isink.c
@@ -154,6 +154,7 @@ static __devinit int wm831x_isink_probe(struct platform_device *pdev)
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
         struct wm831x_isink *isink;
         int id = pdev->id % ARRAY_SIZE(pdata->isink);
+        struct regulator_config config = { };
         struct resource *res;
         int ret, irq;
 
@@ -189,8 +190,11 @@ static __devinit int wm831x_isink_probe(struct platform_device *pdev)
         isink->desc.type = REGULATOR_CURRENT;
         isink->desc.owner = THIS_MODULE;
 
-        isink->regulator = regulator_register(&isink->desc, &pdev->dev,
-                                             pdata->isink[id], isink, NULL);
+        config.dev = pdev->dev.parent;
+        config.init_data = pdata->isink[id];
+        config.driver_data = isink;
+
+        isink->regulator = regulator_register(&isink->desc, &config);
         if (IS_ERR(isink->regulator)) {
                 ret = PTR_ERR(isink->regulator);
                 dev_err(wm831x->dev, "Failed to register ISINK%d: %d\n",
diff --git a/drivers/regulator/wm831x-ldo.c b/drivers/regulator/wm831x-ldo.c
index a4b16831f4ca..eb6a3061884c 100644
--- a/drivers/regulator/wm831x-ldo.c
+++ b/drivers/regulator/wm831x-ldo.c
@@ -310,6 +310,7 @@ static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        struct regulator_config config = { };
         int id;
         struct wm831x_ldo *ldo;
         struct resource *res;
@@ -350,8 +351,11 @@ static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
         ldo->desc.ops = &wm831x_gp_ldo_ops;
         ldo->desc.owner = THIS_MODULE;
 
-        ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
-                                             pdata->ldo[id], ldo, NULL);
+        config.dev = pdev->dev.parent;
+        config.init_data = pdata->ldo[id];
+        config.driver_data = ldo;
+
+        ldo->regulator = regulator_register(&ldo->desc, &config);
         if (IS_ERR(ldo->regulator)) {
                 ret = PTR_ERR(ldo->regulator);
                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
@@ -578,6 +582,7 @@ static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        struct regulator_config config = { };
         int id;
         struct wm831x_ldo *ldo;
         struct resource *res;
@@ -618,8 +623,11 @@ static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
         ldo->desc.ops = &wm831x_aldo_ops;
         ldo->desc.owner = THIS_MODULE;
 
-        ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
-                                             pdata->ldo[id], ldo, NULL);
+        config.dev = pdev->dev.parent;
+        config.init_data = pdata->ldo[id];
+        config.driver_data = ldo;
+
+        ldo->regulator = regulator_register(&ldo->desc, &config);
         if (IS_ERR(ldo->regulator)) {
                 ret = PTR_ERR(ldo->regulator);
                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
@@ -772,6 +780,7 @@ static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        struct regulator_config config = { };
         int id;
         struct wm831x_ldo *ldo;
         struct resource *res;
@@ -813,8 +822,11 @@ static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
         ldo->desc.ops = &wm831x_alive_ldo_ops;
         ldo->desc.owner = THIS_MODULE;
 
-        ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
-                                             pdata->ldo[id], ldo, NULL);
+        config.dev = pdev->dev.parent;
+        config.init_data = pdata->ldo[id];
+        config.driver_data = ldo;
+
+        ldo->regulator = regulator_register(&ldo->desc, &config);
         if (IS_ERR(ldo->regulator)) {
                 ret = PTR_ERR(ldo->regulator);
                 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
diff --git a/drivers/regulator/wm8350-regulator.c b/drivers/regulator/wm8350-regulator.c
index 552b1edf8091..4dcbab1314a5 100644
--- a/drivers/regulator/wm8350-regulator.c
+++ b/drivers/regulator/wm8350-regulator.c
@@ -1398,6 +1398,7 @@ static irqreturn_t pmic_uv_handler(int irq, void *data)
 static int wm8350_regulator_probe(struct platform_device *pdev)
 {
         struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev);
+        struct regulator_config config = { };
         struct regulator_dev *rdev;
         int ret;
         u16 val;
@@ -1425,10 +1426,12 @@ static int wm8350_regulator_probe(struct platform_device *pdev)
                 break;
         }
 
+        config.dev = &pdev->dev;
+        config.init_data = pdev->dev.platform_data;
+        config.driver_data = dev_get_drvdata(&pdev->dev);
+
         /* register regulator */
-        rdev = regulator_register(&wm8350_reg[pdev->id], &pdev->dev,
-                                  pdev->dev.platform_data,
-                                  dev_get_drvdata(&pdev->dev), NULL);
+        rdev = regulator_register(&wm8350_reg[pdev->id], &config);
         if (IS_ERR(rdev)) {
                 dev_err(&pdev->dev, "failed to register %s\n",
                         wm8350_reg[pdev->id].name);
diff --git a/drivers/regulator/wm8400-regulator.c b/drivers/regulator/wm8400-regulator.c
index 8477153780b6..4408b7802e75 100644
--- a/drivers/regulator/wm8400-regulator.c
+++ b/drivers/regulator/wm8400-regulator.c
@@ -323,11 +323,14 @@ static struct regulator_desc regulators[] = {
 static int __devinit wm8400_regulator_probe(struct platform_device *pdev)
 {
         struct wm8400 *wm8400 = container_of(pdev, struct wm8400, regulators[pdev->id]);
+        struct regulator_config config = { };
         struct regulator_dev *rdev;
 
-        rdev = regulator_register(&regulators[pdev->id], &pdev->dev,
-                                  pdev->dev.platform_data, wm8400, NULL);
+        config.dev = &pdev->dev;
+        config.init_data = pdev->dev.platform_data;
+        config.driver_data = wm8400;
 
+        rdev = regulator_register(&regulators[pdev->id], &config);
         if (IS_ERR(rdev))
                 return PTR_ERR(rdev);
 
diff --git a/drivers/regulator/wm8994-regulator.c b/drivers/regulator/wm8994-regulator.c
index 8a4897a35f28..f4a62941b711 100644
--- a/drivers/regulator/wm8994-regulator.c
+++ b/drivers/regulator/wm8994-regulator.c
@@ -233,6 +233,7 @@ static __devinit int wm8994_ldo_probe(struct platform_device *pdev)
         struct wm8994 *wm8994 = dev_get_drvdata(pdev->dev.parent);
         struct wm8994_pdata *pdata = wm8994->dev->platform_data;
         int id = pdev->id % ARRAY_SIZE(pdata->ldo);
+        struct regulator_config config = { };
         struct wm8994_ldo *ldo;
         int ret;
 
@@ -268,8 +269,11 @@ static __devinit int wm8994_ldo_probe(struct platform_device *pdev)
         } else
                 ldo->is_enabled = true;
 
-        ldo->regulator = regulator_register(&wm8994_ldo_desc[id], &pdev->dev,
-                                             pdata->ldo[id].init_data, ldo, NULL);
+        config.dev = &pdev->dev;
+        config.init_data = pdata->ldo[id].init_data;
+        config.driver_data = ldo;
+
+        ldo->regulator = regulator_register(&wm8994_ldo_desc[id], &config);
         if (IS_ERR(ldo->regulator)) {
                 ret = PTR_ERR(ldo->regulator);
                 dev_err(wm8994->dev, "Failed to register LDO%d: %d\n",