UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

regulator: of: Add regulator desc param to of_get_regulator_init_data() 

The of_get_regulator_init_data() function is used to extract the regulator
init_data but information on how to extract certain data is defined in the
static regulator descriptor (e.g: how to map the hardware operating modes).

Add a const struct regulator_desc * parameter to the function signature so
the parsing logic could use the information in the struct regulator_desc.

of_get_regulator_init_data() relies on of_get_regulation_constraints() to
actually extract the init_data so it has to pass the struct regulator_desc
but that is modified on a later patch.

Signed-off-by: Javier Martinez Canillas <javier.martinez@collabora.co.uk>
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Javier Martinez Canillas 2014-11-10 14:43:53 +01:00 committed by Mark Brown
parent 87e1e0f29f
commit 072e78b12b
27 changed files with 130 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/regulator/88pm8607.c
View File

@ -330,7 +330,8 @@ static int pm8607_regulator_dt_init(struct platform_device *pdev,
for_each_child_of_node(nproot, np) { for_each_child_of_node(nproot, np) {
if (!of_node_cmp(np->name, info->desc.name)) { if (!of_node_cmp(np->name, info->desc.name)) {
config->init_data = config->init_data =
of_get_regulator_init_data(&pdev->dev, np); of_get_regulator_init_data(&pdev->dev, np,
&info->desc);
config->of_node = np; config->of_node = np;
break; break;
} }

5
drivers/regulator/anatop-regulator.c
View File

@ -189,17 +189,18 @@ static int anatop_regulator_probe(struct platform_device *pdev)
int ret = 0; int ret = 0;
u32 val; u32 val;
initdata = of_get_regulator_init_data(dev, np);
sreg = devm_kzalloc(dev, sizeof(*sreg), GFP_KERNEL); sreg = devm_kzalloc(dev, sizeof(*sreg), GFP_KERNEL);
if (!sreg) if (!sreg)
return -ENOMEM; return -ENOMEM;
sreg->initdata = initdata;
sreg->name = of_get_property(np, "regulator-name", NULL); sreg->name = of_get_property(np, "regulator-name", NULL);
rdesc = &sreg->rdesc; rdesc = &sreg->rdesc;
rdesc->name = sreg->name; rdesc->name = sreg->name;
rdesc->type = REGULATOR_VOLTAGE; rdesc->type = REGULATOR_VOLTAGE;
rdesc->owner = THIS_MODULE; rdesc->owner = THIS_MODULE;
initdata = of_get_regulator_init_data(dev, np, rdesc);
sreg->initdata = initdata;
anatop_np = of_get_parent(np); anatop_np = of_get_parent(np);
if (!anatop_np) if (!anatop_np)
return -ENODEV; return -ENODEV;

8
drivers/regulator/arizona-ldo1.c
View File

@ -179,7 +179,8 @@ static const struct regulator_init_data arizona_ldo1_default = {
}; };
static int arizona_ldo1_of_get_pdata(struct arizona *arizona, static int arizona_ldo1_of_get_pdata(struct arizona *arizona,
struct regulator_config *config) struct regulator_config *config,
const struct regulator_desc *desc)
{ {
struct arizona_pdata *pdata = &arizona->pdata; struct arizona_pdata *pdata = &arizona->pdata;
struct arizona_ldo1 *ldo1 = config->driver_data; struct arizona_ldo1 *ldo1 = config->driver_data;
@ -194,7 +195,8 @@ static int arizona_ldo1_of_get_pdata(struct arizona *arizona,
if (init_node) { if (init_node) {
config->of_node = init_node; config->of_node = init_node;
init_data = of_get_regulator_init_data(arizona->dev, init_node); init_data = of_get_regulator_init_data(arizona->dev, init_node,
desc);
if (init_data) { if (init_data) {
init_data->consumer_supplies = &ldo1->supply; init_data->consumer_supplies = &ldo1->supply;
@ -257,7 +259,7 @@ static int arizona_ldo1_probe(struct platform_device *pdev)
if (IS_ENABLED(CONFIG_OF)) { if (IS_ENABLED(CONFIG_OF)) {
if (!dev_get_platdata(arizona->dev)) { if (!dev_get_platdata(arizona->dev)) {
ret = arizona_ldo1_of_get_pdata(arizona, &config); ret = arizona_ldo1_of_get_pdata(arizona, &config, desc);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }

8
drivers/regulator/arizona-micsupp.c
View File

@ -198,7 +198,8 @@ static const struct regulator_init_data arizona_micsupp_ext_default = {
}; };
static int arizona_micsupp_of_get_pdata(struct arizona *arizona, static int arizona_micsupp_of_get_pdata(struct arizona *arizona,
struct regulator_config *config) struct regulator_config *config,
const struct regulator_desc *desc)
{ {
struct arizona_pdata *pdata = &arizona->pdata; struct arizona_pdata *pdata = &arizona->pdata;
struct arizona_micsupp *micsupp = config->driver_data; struct arizona_micsupp *micsupp = config->driver_data;
@ -210,7 +211,7 @@ static int arizona_micsupp_of_get_pdata(struct arizona *arizona,
if (np) { if (np) {
config->of_node = np; config->of_node = np;
init_data = of_get_regulator_init_data(arizona->dev, np); init_data = of_get_regulator_init_data(arizona->dev, np, desc);
if (init_data) { if (init_data) {
init_data->consumer_supplies = &micsupp->supply; init_data->consumer_supplies = &micsupp->supply;
@ -264,7 +265,8 @@ static int arizona_micsupp_probe(struct platform_device *pdev)
if (IS_ENABLED(CONFIG_OF)) { if (IS_ENABLED(CONFIG_OF)) {
if (!dev_get_platdata(arizona->dev)) { if (!dev_get_platdata(arizona->dev)) {
ret = arizona_micsupp_of_get_pdata(arizona, &config); ret = arizona_micsupp_of_get_pdata(arizona, &config,
desc);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }

3
drivers/regulator/da9052-regulator.c
View File

@ -436,7 +436,8 @@ static int da9052_regulator_probe(struct platform_device *pdev)
if (!of_node_cmp(np->name, if (!of_node_cmp(np->name,
regulator->info->reg_desc.name)) { regulator->info->reg_desc.name)) {
config.init_data = of_get_regulator_init_data( config.init_data = of_get_regulator_init_data(
&pdev->dev, np); &pdev->dev, np,
&regulator->info->reg_desc);
config.of_node = np; config.of_node = np;
break; break;
} }

2
drivers/regulator/da9210-regulator.c
View File

@ -147,7 +147,7 @@ static int da9210_i2c_probe(struct i2c_client *i2c,
config.dev = &i2c->dev; config.dev = &i2c->dev;
config.init_data = pdata ? &pdata->da9210_constraints : config.init_data = pdata ? &pdata->da9210_constraints :
of_get_regulator_init_data(dev, dev->of_node); of_get_regulator_init_data(dev, dev->of_node, &da9210_reg);
config.driver_data = chip; config.driver_data = chip;
config.regmap = chip->regmap; config.regmap = chip->regmap;
config.of_node = dev->of_node; config.of_node = dev->of_node;

17
drivers/regulator/fan53555.c
View File

@ -302,7 +302,8 @@ static struct regmap_config fan53555_regmap_config = {
}; };
static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev, static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,
struct device_node *np) struct device_node *np,
const struct regulator_desc *desc)
{ {
struct fan53555_platform_data *pdata; struct fan53555_platform_data *pdata;
int ret; int ret;
@ -312,7 +313,7 @@ static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,
if (!pdata) if (!pdata)
return NULL; return NULL;
pdata->regulator = of_get_regulator_init_data(dev, np); pdata->regulator = of_get_regulator_init_data(dev, np, desc);
ret = of_property_read_u32(np, "fcs,suspend-voltage-selector", ret = of_property_read_u32(np, "fcs,suspend-voltage-selector",
&tmp); &tmp);
@ -347,20 +348,20 @@ static int fan53555_regulator_probe(struct i2c_client *client,
unsigned int val; unsigned int val;
int ret; int ret;
di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
GFP_KERNEL);
if (!di)
return -ENOMEM;
pdata = dev_get_platdata(&client->dev); pdata = dev_get_platdata(&client->dev);
if (!pdata) if (!pdata)
pdata = fan53555_parse_dt(&client->dev, np); pdata = fan53555_parse_dt(&client->dev, np, &di->desc);
if (!pdata || !pdata->regulator) { if (!pdata || !pdata->regulator) {
dev_err(&client->dev, "Platform data not found!\n"); dev_err(&client->dev, "Platform data not found!\n");
return -ENODEV; return -ENODEV;
} }
di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
GFP_KERNEL);
if (!di)
return -ENOMEM;
di->regulator = pdata->regulator; di->regulator = pdata->regulator;
if (client->dev.of_node) { if (client->dev.of_node) {
const struct of_device_id *match; const struct of_device_id *match;

19
drivers/regulator/fixed.c
View File

@ -40,13 +40,15 @@ struct fixed_voltage_data {
/** /**
* of_get_fixed_voltage_config - extract fixed_voltage_config structure info * of_get_fixed_voltage_config - extract fixed_voltage_config structure info
* @dev: device requesting for fixed_voltage_config * @dev: device requesting for fixed_voltage_config
* @desc: regulator description
* *
* Populates fixed_voltage_config structure by extracting data from device * Populates fixed_voltage_config structure by extracting data from device
* tree node, returns a pointer to the populated structure of NULL if memory * tree node, returns a pointer to the populated structure of NULL if memory
* alloc fails. * alloc fails.
*/ */
static struct fixed_voltage_config * static struct fixed_voltage_config *
of_get_fixed_voltage_config(struct device *dev) of_get_fixed_voltage_config(struct device *dev,
const struct regulator_desc *desc)
{ {
struct fixed_voltage_config *config; struct fixed_voltage_config *config;
struct device_node *np = dev->of_node; struct device_node *np = dev->of_node;
@ -57,7 +59,7 @@ of_get_fixed_voltage_config(struct device *dev)
if (!config) if (!config)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
config->init_data = of_get_regulator_init_data(dev, dev->of_node); config->init_data = of_get_regulator_init_data(dev, dev->of_node, desc);
if (!config->init_data) if (!config->init_data)
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
@ -112,8 +114,14 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
struct regulator_config cfg = { }; struct regulator_config cfg = { };
int ret; int ret;
drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data),
GFP_KERNEL);
if (!drvdata)
return -ENOMEM;
if (pdev->dev.of_node) { if (pdev->dev.of_node) {
config = of_get_fixed_voltage_config(&pdev->dev); config = of_get_fixed_voltage_config(&pdev->dev,
&drvdata->desc);
if (IS_ERR(config)) if (IS_ERR(config))
return PTR_ERR(config); return PTR_ERR(config);
} else { } else {
@ -123,11 +131,6 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
if (!config) if (!config)
return -ENOMEM; return -ENOMEM;
drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data),
GFP_KERNEL);
if (!drvdata)
return -ENOMEM;
drvdata->desc.name = devm_kstrdup(&pdev->dev, drvdata->desc.name = devm_kstrdup(&pdev->dev,
config->supply_name, config->supply_name,
GFP_KERNEL); GFP_KERNEL);

18
drivers/regulator/gpio-regulator.c
View File

@ -133,7 +133,8 @@ static struct regulator_ops gpio_regulator_voltage_ops = {
}; };
static struct gpio_regulator_config * static struct gpio_regulator_config *
of_get_gpio_regulator_config(struct device *dev, struct device_node *np) of_get_gpio_regulator_config(struct device *dev, struct device_node *np,
const struct regulator_desc *desc)
{ {
struct gpio_regulator_config *config; struct gpio_regulator_config *config;
const char *regtype; const char *regtype;
@ -146,7 +147,7 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
if (!config) if (!config)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
config->init_data = of_get_regulator_init_data(dev, np); config->init_data = of_get_regulator_init_data(dev, np, desc);
if (!config->init_data) if (!config->init_data)
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
@ -243,17 +244,18 @@ static int gpio_regulator_probe(struct platform_device *pdev)
struct regulator_config cfg = { }; struct regulator_config cfg = { };
int ptr, ret, state; int ptr, ret, state;
if (np) {
config = of_get_gpio_regulator_config(&pdev->dev, np);
if (IS_ERR(config))
return PTR_ERR(config);
}
drvdata = devm_kzalloc(&pdev->dev, sizeof(struct gpio_regulator_data), drvdata = devm_kzalloc(&pdev->dev, sizeof(struct gpio_regulator_data),
GFP_KERNEL); GFP_KERNEL);
if (drvdata == NULL) if (drvdata == NULL)
return -ENOMEM; return -ENOMEM;
if (np) {
config = of_get_gpio_regulator_config(&pdev->dev, np,
&drvdata->desc);
if (IS_ERR(config))
return PTR_ERR(config);
}
drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL); drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL);
if (drvdata->desc.name == NULL) { if (drvdata->desc.name == NULL) {
dev_err(&pdev->dev, "Failed to allocate supply name\n"); dev_err(&pdev->dev, "Failed to allocate supply name\n");

2
drivers/regulator/max8952.c
View File

@ -174,7 +174,7 @@ static struct max8952_platform_data *max8952_parse_dt(struct device *dev)
if (of_property_read_u32(np, "max8952,ramp-speed", &pd->ramp_speed)) if (of_property_read_u32(np, "max8952,ramp-speed", &pd->ramp_speed))
dev_warn(dev, "max8952,ramp-speed property not specified, defaulting to 32mV/us\n"); dev_warn(dev, "max8952,ramp-speed property not specified, defaulting to 32mV/us\n");
pd->reg_data = of_get_regulator_init_data(dev, np); pd->reg_data = of_get_regulator_init_data(dev, np, &regulator);
if (!pd->reg_data) { if (!pd->reg_data) {
dev_err(dev, "Failed to parse regulator init data\n"); dev_err(dev, "Failed to parse regulator init data\n");
return NULL; return NULL;

3
drivers/regulator/max8973-regulator.c
View File

@ -458,7 +458,8 @@ static int max8973_probe(struct i2c_client *client,
config.dev = &client->dev; config.dev = &client->dev;
config.init_data = pdata ? pdata->reg_init_data : config.init_data = pdata ? pdata->reg_init_data :
of_get_regulator_init_data(&client->dev, client->dev.of_node); of_get_regulator_init_data(&client->dev, client->dev.of_node,
&max->desc);
config.driver_data = max; config.driver_data = max;
config.of_node = client->dev.of_node; config.of_node = client->dev.of_node;
config.regmap = max->regmap; config.regmap = max->regmap;

3
drivers/regulator/max8997.c
View File

@ -953,7 +953,8 @@ static int max8997_pmic_dt_parse_pdata(struct platform_device *pdev,
rdata->id = i; rdata->id = i;
rdata->initdata = of_get_regulator_init_data(&pdev->dev, rdata->initdata = of_get_regulator_init_data(&pdev->dev,
reg_np); reg_np,
&regulators[i]);
rdata->reg_node = reg_np; rdata->reg_node = reg_np;
rdata++; rdata++;
} }

5
drivers/regulator/max8998.c
View File

@ -686,8 +686,9 @@ static int max8998_pmic_dt_parse_pdata(struct max8998_dev *iodev,
continue; continue;
rdata->id = regulators[i].id; rdata->id = regulators[i].id;
rdata->initdata = of_get_regulator_init_data( rdata->initdata = of_get_regulator_init_data(iodev->dev,
iodev->dev, reg_np); reg_np,
&regulators[i]);
rdata->reg_node = reg_np; rdata->reg_node = reg_np;
++rdata; ++rdata;
} }

3
drivers/regulator/mc13xxx-regulator-core.c
View File

@ -194,7 +194,8 @@ struct mc13xxx_regulator_init_data *mc13xxx_parse_regulators_dt(
regulators[i].desc.name)) { regulators[i].desc.name)) {
p->id = i; p->id = i;
p->init_data = of_get_regulator_init_data( p->init_data = of_get_regulator_init_data(
&pdev->dev, child); &pdev->dev, child,
&regulators[i].desc);
p->node = child; p->node = child;
p++; p++;

9
drivers/regulator/of_regulator.c
View File

@ -120,13 +120,16 @@ static void of_get_regulation_constraints(struct device_node *np,
/** /**
* of_get_regulator_init_data - extract regulator_init_data structure info * of_get_regulator_init_data - extract regulator_init_data structure info
* @dev: device requesting for regulator_init_data * @dev: device requesting for regulator_init_data
* @node: regulator device node
* @desc: regulator description
* *
* Populates regulator_init_data structure by extracting data from device * Populates regulator_init_data structure by extracting data from device
* tree node, returns a pointer to the populated struture or NULL if memory * tree node, returns a pointer to the populated struture or NULL if memory
* alloc fails. * alloc fails.
*/ */
struct regulator_init_data *of_get_regulator_init_data(struct device *dev, struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
struct device_node *node) struct device_node *node,
const struct regulator_desc *desc)
{ {
struct regulator_init_data *init_data; struct regulator_init_data *init_data;
@ -218,7 +221,7 @@ int of_regulator_match(struct device *dev, struct device_node *node,
continue; continue;
match->init_data = match->init_data =
of_get_regulator_init_data(dev, child); of_get_regulator_init_data(dev, child, NULL);
if (!match->init_data) { if (!match->init_data) {
dev_err(dev, dev_err(dev,
"failed to parse DT for regulator %s\n", "failed to parse DT for regulator %s\n",
@ -265,7 +268,7 @@ struct regulator_init_data *regulator_of_get_init_data(struct device *dev,
if (strcmp(desc->of_match, name)) if (strcmp(desc->of_match, name))
continue; continue;
init_data = of_get_regulator_init_data(dev, child); init_data = of_get_regulator_init_data(dev, child, desc);
if (!init_data) { if (!init_data) {
dev_err(dev, dev_err(dev,
"failed to parse DT for regulator %s\n", "failed to parse DT for regulator %s\n",

3
drivers/regulator/pwm-regulator.c
View File

@ -149,7 +149,8 @@ static int pwm_regulator_probe(struct platform_device *pdev)
return ret; return ret;
} }
config.init_data = of_get_regulator_init_data(&pdev->dev, np); config.init_data = of_get_regulator_init_data(&pdev->dev, np,
&drvdata->desc);
if (!config.init_data) if (!config.init_data)
return -ENOMEM; return -ENOMEM;

9
drivers/regulator/qcom_rpm-regulator.c
View File

@ -643,10 +643,6 @@ static int rpm_reg_probe(struct platform_device *pdev)
match = of_match_device(rpm_of_match, &pdev->dev); match = of_match_device(rpm_of_match, &pdev->dev);
template = match->data; template = match->data;
initdata = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node);
if (!initdata)
return -EINVAL;
vreg = devm_kmalloc(&pdev->dev, sizeof(*vreg), GFP_KERNEL); vreg = devm_kmalloc(&pdev->dev, sizeof(*vreg), GFP_KERNEL);
if (!vreg) { if (!vreg) {
dev_err(&pdev->dev, "failed to allocate vreg\n"); dev_err(&pdev->dev, "failed to allocate vreg\n");
@ -666,6 +662,11 @@ static int rpm_reg_probe(struct platform_device *pdev)
return -ENODEV; return -ENODEV;
} }
initdata = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
&vreg->desc);
if (!initdata)
return -EINVAL;
key = "reg"; key = "reg";
ret = of_property_read_u32(pdev->dev.of_node, key, &val); ret = of_property_read_u32(pdev->dev.of_node, key, &val);
if (ret) { if (ret) {

3
drivers/regulator/s5m8767.c
View File

@ -581,7 +581,8 @@ static int s5m8767_pmic_dt_parse_pdata(struct platform_device *pdev,
rdata->id = i; rdata->id = i;
rdata->initdata = of_get_regulator_init_data( rdata->initdata = of_get_regulator_init_data(
&pdev->dev, reg_np); &pdev->dev, reg_np,
&regulators[i]);
rdata->reg_node = reg_np; rdata->reg_node = reg_np;
rdata++; rdata++;
rmode->id = i; rmode->id = i;

2
drivers/regulator/sky81452-regulator.c
View File

@ -76,7 +76,7 @@ static struct regulator_init_data *sky81452_reg_parse_dt(struct device *dev)
return NULL; return NULL;
} }
init_data = of_get_regulator_init_data(dev, np); init_data = of_get_regulator_init_data(dev, np, &sky81452_reg);
of_node_put(np); of_node_put(np);
return init_data; return init_data;

3
drivers/regulator/stw481x-vmmc.c
View File

@ -72,7 +72,8 @@ static int stw481x_vmmc_regulator_probe(struct platform_device *pdev)
config.regmap = stw481x->map; config.regmap = stw481x->map;
config.of_node = pdev->dev.of_node; config.of_node = pdev->dev.of_node;
config.init_data = of_get_regulator_init_data(&pdev->dev, config.init_data = of_get_regulator_init_data(&pdev->dev,
pdev->dev.of_node); pdev->dev.of_node,
&vmmc_regulator);
stw481x->vmmc_regulator = devm_regulator_register(&pdev->dev, stw481x->vmmc_regulator = devm_regulator_register(&pdev->dev,
&vmmc_regulator, &config); &vmmc_regulator, &config);

3
drivers/regulator/ti-abb-regulator.c
View File

@ -837,7 +837,8 @@ skip_opt:
return -EINVAL; return -EINVAL;
} }
initdata = of_get_regulator_init_data(dev, pdev->dev.of_node); initdata = of_get_regulator_init_data(dev, pdev->dev.of_node,
&abb->rdesc);
if (!initdata) { if (!initdata) {
dev_err(dev, "%s: Unable to alloc regulator init data\n", dev_err(dev, "%s: Unable to alloc regulator init data\n",
__func__); __func__);

43
drivers/regulator/tps51632-regulator.c
View File

@ -221,7 +221,8 @@ static const struct of_device_id tps51632_of_match[] = {
MODULE_DEVICE_TABLE(of, tps51632_of_match); MODULE_DEVICE_TABLE(of, tps51632_of_match);
static struct tps51632_regulator_platform_data * static struct tps51632_regulator_platform_data *
of_get_tps51632_platform_data(struct device *dev) of_get_tps51632_platform_data(struct device *dev,
const struct regulator_desc *desc)
{ {
struct tps51632_regulator_platform_data *pdata; struct tps51632_regulator_platform_data *pdata;
struct device_node *np = dev->of_node; struct device_node *np = dev->of_node;
@ -230,7 +231,8 @@ static struct tps51632_regulator_platform_data *
if (!pdata) if (!pdata)
return NULL; return NULL;
pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node); pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
desc);
if (!pdata->reg_init_data) { if (!pdata->reg_init_data) {
dev_err(dev, "Not able to get OF regulator init data\n"); dev_err(dev, "Not able to get OF regulator init data\n");
return NULL; return NULL;
@ -248,7 +250,8 @@ static struct tps51632_regulator_platform_data *
} }
#else #else
static struct tps51632_regulator_platform_data * static struct tps51632_regulator_platform_data *
of_get_tps51632_platform_data(struct device *dev) of_get_tps51632_platform_data(struct device *dev,
const struct regulator_desc *desc)
{ {
return NULL; return NULL;
} }
@ -273,9 +276,25 @@ static int tps51632_probe(struct i2c_client *client,
} }
} }
tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
if (!tps)
return -ENOMEM;
tps->dev = &client->dev;
tps->desc.name = client->name;
tps->desc.id = 0;
tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
tps->desc.ops = &tps51632_dcdc_ops;
tps->desc.type = REGULATOR_VOLTAGE;
tps->desc.owner = THIS_MODULE;
pdata = dev_get_platdata(&client->dev); pdata = dev_get_platdata(&client->dev);
if (!pdata && client->dev.of_node) if (!pdata && client->dev.of_node)
pdata = of_get_tps51632_platform_data(&client->dev); pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc);
if (!pdata) { if (!pdata) {
dev_err(&client->dev, "No Platform data\n"); dev_err(&client->dev, "No Platform data\n");
return -EINVAL; return -EINVAL;
@ -296,22 +315,6 @@ static int tps51632_probe(struct i2c_client *client,
} }
} }
tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
if (!tps)
return -ENOMEM;
tps->dev = &client->dev;
tps->desc.name = client->name;
tps->desc.id = 0;
tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
tps->desc.ops = &tps51632_dcdc_ops;
tps->desc.type = REGULATOR_VOLTAGE;
tps->desc.owner = THIS_MODULE;
if (pdata->enable_pwm_dvfs) if (pdata->enable_pwm_dvfs)
tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG; tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
else else

31
drivers/regulator/tps62360-regulator.c
View File

@ -293,7 +293,8 @@ static const struct regmap_config tps62360_regmap_config = {
}; };
static struct tps62360_regulator_platform_data * static struct tps62360_regulator_platform_data *
of_get_tps62360_platform_data(struct device *dev) of_get_tps62360_platform_data(struct device *dev,
const struct regulator_desc *desc)
{ {
struct tps62360_regulator_platform_data *pdata; struct tps62360_regulator_platform_data *pdata;
struct device_node *np = dev->of_node; struct device_node *np = dev->of_node;
@ -302,7 +303,8 @@ static struct tps62360_regulator_platform_data *
if (!pdata) if (!pdata)
return NULL; return NULL;
pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node); pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
desc);
if (!pdata->reg_init_data) { if (!pdata->reg_init_data) {
dev_err(dev, "Not able to get OF regulator init data\n"); dev_err(dev, "Not able to get OF regulator init data\n");
return NULL; return NULL;
@ -350,6 +352,17 @@ static int tps62360_probe(struct i2c_client *client,
pdata = dev_get_platdata(&client->dev); pdata = dev_get_platdata(&client->dev);
tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
if (!tps)
return -ENOMEM;
tps->desc.name = client->name;
tps->desc.id = 0;
tps->desc.ops = &tps62360_dcdc_ops;
tps->desc.type = REGULATOR_VOLTAGE;
tps->desc.owner = THIS_MODULE;
tps->desc.uV_step = 10000;
if (client->dev.of_node) { if (client->dev.of_node) {
const struct of_device_id *match; const struct of_device_id *match;
match = of_match_device(of_match_ptr(tps62360_of_match), match = of_match_device(of_match_ptr(tps62360_of_match),
@ -360,7 +373,8 @@ static int tps62360_probe(struct i2c_client *client,
} }
chip_id = (int)(long)match->data; chip_id = (int)(long)match->data;
if (!pdata) if (!pdata)
pdata = of_get_tps62360_platform_data(&client->dev); pdata = of_get_tps62360_platform_data(&client->dev,
&tps->desc);
} else if (id) { } else if (id) {
chip_id = id->driver_data; chip_id = id->driver_data;
} else { } else {
@ -374,10 +388,6 @@ static int tps62360_probe(struct i2c_client *client,
return -EIO; return -EIO;
} }
tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
if (!tps)
return -ENOMEM;
tps->en_discharge = pdata->en_discharge; tps->en_discharge = pdata->en_discharge;
tps->en_internal_pulldn = pdata->en_internal_pulldn; tps->en_internal_pulldn = pdata->en_internal_pulldn;
tps->vsel0_gpio = pdata->vsel0_gpio; tps->vsel0_gpio = pdata->vsel0_gpio;
@ -401,13 +411,6 @@ static int tps62360_probe(struct i2c_client *client,
return -ENODEV; return -ENODEV;
} }
tps->desc.name = client->name;
tps->desc.id = 0;
tps->desc.ops = &tps62360_dcdc_ops;
tps->desc.type = REGULATOR_VOLTAGE;
tps->desc.owner = THIS_MODULE;
tps->desc.uV_step = 10000;
tps->regmap = devm_regmap_init_i2c(client, &tps62360_regmap_config); tps->regmap = devm_regmap_init_i2c(client, &tps62360_regmap_config);
if (IS_ERR(tps->regmap)) { if (IS_ERR(tps->regmap)) {
ret = PTR_ERR(tps->regmap); ret = PTR_ERR(tps->regmap);

3
drivers/regulator/tps65218-regulator.c
View File

@ -231,7 +231,8 @@ static int tps65218_regulator_probe(struct platform_device *pdev)
template = match->data; template = match->data;
id = template->id; id = template->id;
init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node); init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
&regulators[id]);
platform_set_drvdata(pdev, tps); platform_set_drvdata(pdev, tps);

3
drivers/regulator/twl-regulator.c
View File

@ -1104,7 +1104,8 @@ static int twlreg_probe(struct platform_device *pdev)
template = match->data; template = match->data;
id = template->desc.id; id = template->desc.id;
initdata = of_get_regulator_init_data(&pdev->dev, initdata = of_get_regulator_init_data(&pdev->dev,
pdev->dev.of_node); pdev->dev.of_node,
&template->desc);
drvdata = NULL; drvdata = NULL;
} else { } else {
id = pdev->id; id = pdev->id;

3
drivers/regulator/vexpress.c
View File

@ -74,7 +74,8 @@ static int vexpress_regulator_probe(struct platform_device *pdev)
reg->desc.owner = THIS_MODULE; reg->desc.owner = THIS_MODULE;
reg->desc.continuous_voltage_range = true; reg->desc.continuous_voltage_range = true;
init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node); init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
&reg->desc);
if (!init_data) if (!init_data)
return -EINVAL; return -EINVAL;

8
include/linux/regulator/of_regulator.h
View File

@ -6,6 +6,8 @@
#ifndef __LINUX_OF_REG_H #ifndef __LINUX_OF_REG_H
#define __LINUX_OF_REG_H #define __LINUX_OF_REG_H
struct regulator_desc;
struct of_regulator_match { struct of_regulator_match {
const char *name; const char *name;
void *driver_data; void *driver_data;
@ -16,14 +18,16 @@ struct of_regulator_match {
#if defined(CONFIG_OF) #if defined(CONFIG_OF)
extern struct regulator_init_data extern struct regulator_init_data
*of_get_regulator_init_data(struct device *dev, *of_get_regulator_init_data(struct device *dev,
struct device_node *node); struct device_node *node,
const struct regulator_desc *desc);
extern int of_regulator_match(struct device *dev, struct device_node *node, extern int of_regulator_match(struct device *dev, struct device_node *node,
struct of_regulator_match *matches, struct of_regulator_match *matches,
unsigned int num_matches); unsigned int num_matches);
#else #else
static inline struct regulator_init_data static inline struct regulator_init_data
*of_get_regulator_init_data(struct device *dev, *of_get_regulator_init_data(struct device *dev,
struct device_node *node) struct device_node *node,
const struct regulator_desc *desc)
{ {
return NULL; return NULL;
} }