static int axp20x_regulator_parse_dt(struct platform_device *pdev)
{
struct device_node *np, *regulators;
int ret;
u32 dcdcfreq;
np = of_node_get(pdev->dev.parent->of_node);
if (!np)
return 0;
regulators = of_get_child_by_name(np, "regulators");
if (!regulators) {
dev_warn(&pdev->dev, "regulators node not found\n");
} else {
ret = of_regulator_match(&pdev->dev, regulators, axp20x_matches,
ARRAY_SIZE(axp20x_matches));
if (ret < 0) {
dev_err(&pdev->dev, "Error parsing regulator init data: %d\n", ret);
return ret;
}
dcdcfreq = 1500;
of_property_read_u32(regulators, "x-powers,dcdc-freq", &dcdcfreq);
ret = axp20x_set_dcdc_freq(pdev, dcdcfreq);
if (ret < 0) {
dev_err(&pdev->dev, "Error setting dcdc frequency: %d\n", ret);
return ret;
}
of_node_put(regulators);
}
return 0;
}
static int ricoh619_regulator_dt_init(struct platform_device *pdev,
struct regulator_config *config,
int regidx)
{
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");
if (!np) {
dev_err(&pdev->dev, "failed to find regulators node\n");
return -ENODEV;
}
rcount = of_regulator_match(&pdev->dev, np,
&ricoh619_regulator_matches[regidx], 1);
of_node_put(np);
if (rcount < 0)
return -ENODEV;
config->init_data = ricoh619_regulator_matches[regidx].init_data;
config->of_node = ricoh619_regulator_matches[regidx].of_node;
return 0;
}
static struct tps65217_board *tps65217_parse_dt(struct platform_device *pdev)
{
struct tps65217 *tps = dev_get_drvdata(pdev->dev.parent);
struct device_node *node = tps->dev->of_node;
struct tps65217_board *pdata;
struct device_node *regs;
int i, count;
regs = of_get_child_by_name(node, "regulators");
if (!regs)
return NULL;
count = of_regulator_match(&pdev->dev, regs, reg_matches,
TPS65217_NUM_REGULATOR);
of_node_put(regs);
if ((count < 0) || (count > TPS65217_NUM_REGULATOR))
return NULL;
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return NULL;
for (i = 0; i < count; i++) {
if (!reg_matches[i].of_node)
continue;
pdata->tps65217_init_data[i] = reg_matches[i].init_data;
pdata->of_node[i] = reg_matches[i].of_node;
}
return pdata;
}
static int pm800_regulator_dt_init(struct platform_device *pdev,
struct of_regulator_match **regulator_matches, int *range)
{
struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent);
struct device_node *np = pdev->dev.of_node;
switch (chip->type) {
case CHIP_PM800:
*regulator_matches = pm800_regulator_matches;
*range = PM800_ID_RG_MAX;
break;
case CHIP_PM822:
*regulator_matches = pm822_regulator_matches;
*range = PM822_ID_RG_MAX;
break;
case CHIP_PM86X:
*regulator_matches = pm86x_regulator_matches;
*range = PM86X_ID_RG_MAX;
break;
default:
return -ENODEV;
}
return of_regulator_match(&pdev->dev, np, *regulator_matches, *range);
}
static int as3711_regulator_parse_dt(struct device *dev,
struct device_node **of_node, const int count)
{
struct as3711_regulator_pdata *pdata = dev_get_platdata(dev);
struct device_node *regulators =
of_find_node_by_name(dev->parent->of_node, "regulators");
struct of_regulator_match *match;
int ret, i;
if (!regulators) {
dev_err(dev, "regulator node not found\n");
return -ENODEV;
}
ret = of_regulator_match(dev->parent, regulators,
as3711_regulator_matches, count);
of_node_put(regulators);
if (ret < 0) {
dev_err(dev, "Error parsing regulator init data: %d\n", ret);
return ret;
}
for (i = 0, match = as3711_regulator_matches; i < count; i++, match++)
if (match->of_node) {
pdata->init_data[i] = match->init_data;
of_node[i] = match->of_node;
}
return 0;
}
static struct syr82x_board *syr82x_parse_dt(struct syr82x *syr82x)
{
struct syr82x_board *pdata;
struct device_node *regs;
struct device_node *syr82x_np;
int count;
DBG("%s,line=%d\n", __func__,__LINE__);
syr82x_np = of_node_get(syr82x->dev->of_node);
if (!syr82x_np) {
printk("could not find pmic sub-node\n");
return NULL;
}
regs = of_find_node_by_name(syr82x_np, "regulators");
if (!regs)
return NULL;
count = of_regulator_match(syr82x->dev, regs, syr82x_reg_matches,
syr82x_NUM_REGULATORS);
of_node_put(regs);
pdata = devm_kzalloc(syr82x->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return NULL;
pdata->syr82x_init_data[0] = syr82x_reg_matches[0].init_data;
pdata->of_node[0] = syr82x_reg_matches[0].of_node;
return pdata;
}
static struct lp872x_platform_data
*lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which)
{
struct device_node *np = dev->of_node;
struct lp872x_platform_data *pdata;
struct of_regulator_match *match;
int num_matches;
int count;
int i;
u8 dvs_state;
pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return ERR_PTR(-ENOMEM);
of_property_read_u8(np, "ti,general-config", &pdata->general_config);
if (of_find_property(np, "ti,update-config", NULL))
pdata->update_config = true;
pdata->dvs = devm_kzalloc(dev, sizeof(struct lp872x_dvs), GFP_KERNEL);
if (!pdata->dvs)
return ERR_PTR(-ENOMEM);
pdata->dvs->gpio = of_get_named_gpio(np, "ti,dvs-gpio", 0);
of_property_read_u8(np, "ti,dvs-vsel", (u8 *)&pdata->dvs->vsel);
of_property_read_u8(np, "ti,dvs-state", &dvs_state);
pdata->dvs->init_state = dvs_state ? DVS_HIGH : DVS_LOW;
pdata->enable_gpio = of_get_named_gpio(np, "enable-gpios", 0);
if (of_get_child_count(np) == 0)
goto out;
switch (which) {
case LP8720:
match = lp8720_matches;
num_matches = ARRAY_SIZE(lp8720_matches);
break;
case LP8725:
match = lp8725_matches;
num_matches = ARRAY_SIZE(lp8725_matches);
break;
default:
goto out;
}
count = of_regulator_match(dev, np, match, num_matches);
if (count <= 0)
goto out;
for (i = 0; i < num_matches; i++) {
pdata->regulator_data[i].id =
(enum lp872x_regulator_id)match[i].driver_data;
pdata->regulator_data[i].init_data = match[i].init_data;
}
out:
return pdata;
}
static int hi655x_regulator_probe(struct platform_device *pdev)
{
unsigned int i;
int ret;
struct hi655x_regulator *regulator;
struct hi655x_pmic *pmic;
struct regulator_config config = { };
struct device *dev = &pdev->dev;
struct regulator_dev *rdev;
struct device_node *np;
np = of_get_child_by_name(dev->parent->of_node, "regulators");
if (!np)
return -ENODEV;
ret = of_regulator_match(dev, np,
hi655x_regulator_match,
ARRAY_SIZE(hi655x_regulator_match));
of_node_put(np);
if (ret < 0) {
dev_err(dev, "Error parsing regulator init data: %d\n", ret);
return ret;
}
pmic = dev_get_drvdata(pdev->dev.parent);
if (!pmic) {
dev_err(dev, "no pmic in the regulator parent node\n");
return -ENODEV;
}
regulator = devm_kzalloc(dev, sizeof(*regulator), GFP_KERNEL);
if (!regulator)
return -ENOMEM;
platform_set_drvdata(pdev, regulator);
for (i = 0; i < ARRAY_SIZE(regulators); i++) {
config.dev = &pdev->dev;
config.driver_data = regulator;
config.regmap = pmic->regmap;
config.of_node = hi655x_regulator_match[i].of_node;
config.init_data = hi655x_regulator_match[i].init_data;
/* register regulator with framework */
rdev = devm_regulator_register(&pdev->dev,
®ulators[i].rdesc,
&config);
if (IS_ERR(rdev)) {
dev_err(&pdev->dev, "failed to register regulator %s\n",
regulator->rdesc.name);
return PTR_ERR(rdev);
}
}
return 0;
}
static int of_get_max1586_platform_data(struct device *dev,
struct max1586_platform_data *pdata)
{
struct max1586_subdev_data *sub;
struct of_regulator_match rmatch[ARRAY_SIZE(max1586_reg)] = { };
struct device_node *np = dev->of_node;
int i, matched;
if (of_property_read_u32(np, "v3-gain",
&pdata->v3_gain) < 0) {
dev_err(dev, "%pOF has no 'v3-gain' property\n", np);
return -EINVAL;
}
np = of_get_child_by_name(np, "regulators");
if (!np) {
dev_err(dev, "missing 'regulators' subnode in DT\n");
return -EINVAL;
}
for (i = 0; i < ARRAY_SIZE(rmatch); i++)
rmatch[i].name = max1586_reg[i].name;
matched = of_regulator_match(dev, np, rmatch, ARRAY_SIZE(rmatch));
of_node_put(np);
/*
* If matched is 0, ie. neither Output_V3 nor Output_V6 have been found,
* return 0, which signals the normal situation where no subregulator is
* available. This is normal because the max1586 doesn't provide any
* readback support, so the subregulators can't report any status
* anyway. If matched < 0, return the error.
*/
if (matched <= 0)
return matched;
pdata->subdevs = devm_kcalloc(dev,
matched,
sizeof(struct max1586_subdev_data),
GFP_KERNEL);
if (!pdata->subdevs)
return -ENOMEM;
pdata->num_subdevs = matched;
sub = pdata->subdevs;
for (i = 0; i < matched; i++) {
sub->id = i;
sub->name = rmatch[i].of_node->name;
sub->platform_data = rmatch[i].init_data;
sub++;
}
return 0;
}
static int pm800_regulator_dt_init(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
int ret;
ret = of_regulator_match(&pdev->dev, np,
pm800_regulator_matches,
ARRAY_SIZE(pm800_regulator_matches));
if (ret < 0)
return ret;
return 0;
}
static struct act8931_board *act8931_parse_dt(struct act8931 *act8931)
{
struct act8931_board *pdata;
struct device_node *regs;
struct device_node *node;
int i, count;
node = of_node_get(act8931->dev->of_node);
if (!node) {
pr_err("%s: could not find pmic node\n", __func__);
return NULL;
}
regs = of_get_child_by_name(node, "regulators");
if (!regs)
return NULL;
count = of_regulator_match(act8931->dev, regs, act8931_reg_matches,
ACT8931_NUM_REGULATORS);
of_node_put(regs);
if ((count < 0) || (count > ACT8931_NUM_REGULATORS))
return NULL;
pdata = devm_kzalloc(act8931->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return NULL;
for (i = 0; i < count; i++) {
pdata->act8931_init_data[i] = act8931_reg_matches[i].init_data;
pdata->of_node[i] = act8931_reg_matches[i].of_node;
}
pdata->irq_gpio = of_get_named_gpio(node, "gpios", 0);
if (!gpio_is_valid(pdata->irq_gpio)) {
pr_err("%s: invalid gpio: %d\n", __func__, pdata->irq_gpio);
return NULL;
}
pdata->pwr_hold_gpio = of_get_named_gpio(node, "gpios", 1);
if (!gpio_is_valid(pdata->pwr_hold_gpio)) {
pr_err("%s: invalid gpio: %d\n", __func__,
pdata->pwr_hold_gpio);
return NULL;
}
pdata->pm_off = of_property_read_bool(node,
"act8931,system-power-controller");
return pdata;
}
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 struct da9063_regulators_pdata *da9063_parse_regulators_dt(
struct platform_device *pdev,
struct of_regulator_match **da9063_reg_matches)
{
struct da9063_regulators_pdata *pdata;
struct da9063_regulator_data *rdata;
struct device_node *node;
int i, n, num;
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);
}
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);
}
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return ERR_PTR(-ENOMEM);
pdata->regulator_data = devm_kzalloc(&pdev->dev,
num * sizeof(*pdata->regulator_data),
GFP_KERNEL);
if (!pdata->regulator_data)
return ERR_PTR(-ENOMEM);
pdata->n_regulators = num;
n = 0;
for (i = 0; i < ARRAY_SIZE(da9063_matches); i++) {
if (!da9063_matches[i].init_data)
continue;
rdata = &pdata->regulator_data[n];
rdata->id = i;
rdata->initdata = da9063_matches[i].init_data;
n++;
}
*da9063_reg_matches = da9063_matches;
return pdata;
}
static int tps65132_get_regulator_dt_data(struct device *dev,
struct tps65132_regulator *tps65132_regs)
{
struct tps65132_regulator_pdata *rpdata;
struct device_node *rnode;
int id;
int ret;
ret = of_regulator_match(dev, dev->of_node, tps65132_regulator_matches,
ARRAY_SIZE(tps65132_regulator_matches));
if (ret < 0) {
dev_err(dev, "node parsing for regulator failed: %d\n", ret);
return ret;
}
for (id = 0; id < ARRAY_SIZE(tps65132_regulator_matches); ++id) {
rpdata = &tps65132_regs->reg_pdata[id];
rnode = tps65132_regulator_matches[id].of_node;
if (!rnode)
continue;
rpdata->ridata = tps65132_regulator_matches[id].init_data;
rpdata->enable_gpio = of_get_named_gpio(rnode,
"ti,enable-gpio", 0);
if (rpdata->enable_gpio == -EPROBE_DEFER)
return -EPROBE_DEFER;
rpdata->disable_active_discharge = of_property_read_bool(rnode,
"ti,disable-active-discharge");
rpdata->active_discharge_gpio = of_get_named_gpio(rnode,
"ti,active-discharge-gpio", 0);
if (rpdata->active_discharge_gpio == -EPROBE_DEFER) {
return -EPROBE_DEFER;
} else if (gpio_is_valid(rpdata->active_discharge_gpio)) {
ret = of_property_read_u32(rnode,
"ti,active-discharge-time",
&rpdata->active_discharge_time);
if (ret < 0) {
dev_err(dev, "Discharge time read failed: %d\n",
ret);
return ret;
}
}
}
return 0;
}
static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
struct platform_device *pdev,
struct of_regulator_match **tps6586x_reg_matches)
{
const unsigned int num = ARRAY_SIZE(tps6586x_matches);
struct device_node *np = pdev->dev.parent->of_node;
struct device_node *regs;
const char *sys_rail = NULL;
unsigned int i;
struct tps6586x_platform_data *pdata;
int err;
regs = of_find_node_by_name(np, "regulators");
if (!regs) {
dev_err(&pdev->dev, "regulator node not found\n");
return NULL;
}
err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
of_node_put(regs);
if (err < 0) {
dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
return NULL;
}
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata) {
dev_err(&pdev->dev, "Memory alloction failed\n");
return NULL;
}
for (i = 0; i < num; i++) {
int id;
if (!tps6586x_matches[i].init_data)
continue;
pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
id = (int)tps6586x_matches[i].driver_data;
if (id == TPS6586X_ID_SYS)
sys_rail = pdata->reg_init_data[i]->constraints.name;
if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
pdata->reg_init_data[i]->supply_regulator = sys_rail;
}
*tps6586x_reg_matches = tps6586x_matches;
return pdata;
}
static int s2mps11_pmic_dt_parse(struct platform_device *pdev,
struct of_regulator_match *rdata, struct s2mps11_info *s2mps11)
{
struct device_node *reg_np;
reg_np = of_get_child_by_name(pdev->dev.parent->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, s2mps11->rdev_num);
if (s2mps11->dev_type == S2MPS14X)
s2mps14_pmic_dt_parse_ext_control_gpio(pdev, rdata, s2mps11);
of_node_put(reg_np);
return 0;
}
static int rk808_regulator_probe(struct platform_device *pdev)
{
struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent);
struct i2c_client *client = rk808->i2c;
struct device_node *reg_np;
struct regulator_config config = {};
struct regulator_dev *rk808_rdev;
int ret, i;
reg_np = of_get_child_by_name(client->dev.of_node, "regulators");
if (!reg_np)
return -ENXIO;
ret = of_regulator_match(&pdev->dev, reg_np, rk808_reg_matches,
RK808_NUM_REGULATORS);
of_node_put(reg_np);
if (ret < 0)
return ret;
/* Instantiate the regulators */
for (i = 0; i < RK808_NUM_REGULATORS; i++) {
if (!rk808_reg_matches[i].init_data ||
!rk808_reg_matches[i].of_node)
continue;
config.dev = &client->dev;
config.driver_data = rk808;
config.regmap = rk808->regmap;
config.of_node = rk808_reg_matches[i].of_node;
config.init_data = rk808_reg_matches[i].init_data;
rk808_rdev = devm_regulator_register(&pdev->dev,
&rk808_reg[i], &config);
if (IS_ERR(rk808_rdev)) {
dev_err(&client->dev,
"failed to register %d regulator\n", i);
return PTR_ERR(rk808_rdev);
}
}
return 0;
}
static int max77693_pmic_dt_parse_rdata(struct device *dev,
struct max77693_regulator_data **rdata)
{
struct device_node *np;
struct of_regulator_match *rmatch;
struct max77693_regulator_data *tmp;
int i, matched = 0;
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) {
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);
if (!(*rdata))
return -ENOMEM;
tmp = *rdata;
for (i = 0; i < matched; i++) {
tmp->initdata = rmatch[i].init_data;
tmp->of_node = rmatch[i].of_node;
tmp->id = regulators[i].id;
tmp++;
}
return matched;
}
static int hi6421_regulator_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *np;
struct hi6421_pmic *pmic;
struct hi6421_regulator_pdata *pdata;
int i, ret = 0;
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return -ENOMEM;
mutex_init(&pdata->lock);
platform_set_drvdata(pdev, pdata);
np = of_get_child_by_name(dev->parent->of_node, "regulators");
if (!np)
return -ENODEV;
ret = of_regulator_match(dev, np,
hi6421_regulator_match,
ARRAY_SIZE(hi6421_regulator_match));
of_node_put(np);
if (ret < 0) {
dev_err(dev, "Error parsing regulator init data: %d\n", ret);
return ret;
}
pmic = dev_get_drvdata(dev->parent);
for (i = 0; i < ARRAY_SIZE(hi6421_regulator_info); i++) {
ret = hi6421_regulator_register(pdev, pmic->regmap,
hi6421_regulator_match[i].init_data, i,
hi6421_regulator_match[i].of_node);
if (ret)
return ret;
}
return 0;
}
static int max77686_pmic_dt_parse_pdata(struct platform_device *pdev,
struct max77686_platform_data *pdata)
{
struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
struct device_node *pmic_np, *regulators_np;
struct max77686_regulator_data *rdata;
struct of_regulator_match rmatch;
unsigned int i;
pmic_np = iodev->dev->of_node;
regulators_np = of_find_node_by_name(pmic_np, "voltage-regulators");
if (!regulators_np) {
dev_err(&pdev->dev, "could not find regulators sub-node\n");
return -EINVAL;
}
pdata->num_regulators = ARRAY_SIZE(regulators);
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");
return -ENOMEM;
}
for (i = 0; i < pdata->num_regulators; i++) {
rmatch.name = regulators[i].name;
rmatch.init_data = NULL;
rmatch.of_node = NULL;
of_regulator_match(&pdev->dev, regulators_np, &rmatch, 1);
rdata[i].initdata = rmatch.init_data;
rdata[i].of_node = rmatch.of_node;
}
pdata->regulators = rdata;
return 0;
}
static int db8500_regulator_probe(struct platform_device *pdev)
{
struct regulator_init_data *db8500_init_data =
dev_get_platdata(&pdev->dev);
struct device_node *np = pdev->dev.of_node;
int i, err;
/* register all regulators */
if (np) {
err = of_regulator_match(&pdev->dev, np,
db8500_regulator_matches,
ARRAY_SIZE(db8500_regulator_matches));
if (err < 0) {
dev_err(&pdev->dev,
"Error parsing regulator init data: %d\n", err);
return err;
}
err = db8500_regulator_of_probe(pdev, np);
if (err)
return err;
} else {
for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
err = db8500_regulator_register(pdev,
&db8500_init_data[i],
i, NULL);
if (err)
return err;
}
}
err = ux500_regulator_debug_init(pdev,
dbx500_regulator_info,
ARRAY_SIZE(dbx500_regulator_info));
return 0;
}
static int ab8500_ext_regulator_probe(struct platform_device *pdev)
{
struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
struct ab8500_platform_data *ppdata;
struct ab8500_regulator_platform_data *pdata;
struct device_node *np = pdev->dev.of_node;
struct regulator_config config = { };
int i, err;
if (np) {
err = of_regulator_match(&pdev->dev, np,
ab8500_ext_regulator_match,
ARRAY_SIZE(ab8500_ext_regulator_match));
if (err < 0) {
dev_err(&pdev->dev,
"Error parsing regulator init data: %d\n", err);
return err;
}
}
if (!ab8500) {
dev_err(&pdev->dev, "null mfd parent\n");
return -EINVAL;
}
ppdata = dev_get_platdata(ab8500->dev);
if (!ppdata) {
dev_err(&pdev->dev, "null parent pdata\n");
return -EINVAL;
}
pdata = ppdata->regulator;
if (!pdata) {
dev_err(&pdev->dev, "null pdata\n");
return -EINVAL;
}
/* make sure the platform data has the correct size */
if (pdata->num_ext_regulator != ARRAY_SIZE(ab8500_ext_regulator_info)) {
dev_err(&pdev->dev, "Configuration error: size mismatch.\n");
return -EINVAL;
}
/* check for AB8500 2.x */
if (is_ab8500_2p0_or_earlier(ab8500)) {
struct ab8500_ext_regulator_info *info;
/* VextSupply3LPn is inverted on AB8500 2.x */
info = &ab8500_ext_regulator_info[AB8500_EXT_SUPPLY3];
info->update_val = 0x30;
info->update_val_hp = 0x30;
info->update_val_lp = 0x10;
}
/* register all regulators */
for (i = 0; i < ARRAY_SIZE(ab8500_ext_regulator_info); i++) {
struct ab8500_ext_regulator_info *info = NULL;
/* assign per-regulator data */
info = &ab8500_ext_regulator_info[i];
info->dev = &pdev->dev;
info->cfg = (struct ab8500_ext_regulator_cfg *)
pdata->ext_regulator[i].driver_data;
config.dev = &pdev->dev;
config.driver_data = info;
config.of_node = ab8500_ext_regulator_match[i].of_node;
config.init_data = (np) ?
ab8500_ext_regulator_match[i].init_data :
&pdata->ext_regulator[i];
/* register regulator with framework */
info->rdev = devm_regulator_register(&pdev->dev, &info->desc,
&config);
if (IS_ERR(info->rdev)) {
err = PTR_ERR(info->rdev);
dev_err(&pdev->dev, "failed to register regulator %s\n",
info->desc.name);
return err;
}
dev_dbg(rdev_get_dev(info->rdev),
"%s-probed\n", info->desc.name);
}
return 0;
}
static struct pwm_regulator_board *pwm_regulator_parse_dt(
struct platform_device *pdev,
struct of_regulator_match **pwm_reg_matches)
{
struct pwm_regulator_board *pwm_plat_data;
struct device_node *np, *regulators;
struct of_regulator_match *matches;
int idx = 0, ret, count;
struct property *prop;
int length;
const __be32 *init_vol, *max_vol, *min_vol, *suspend_vol, *coefficient, *id;
DBG("%s,line=%d\n", __func__, __LINE__);
pwm_plat_data = devm_kzalloc(&pdev->dev, sizeof(*pwm_plat_data),
GFP_KERNEL);
if (!pwm_plat_data) {
dev_err(&pdev->dev, "Failure to alloc pdata for regulators.\n");
return NULL;
}
np = of_node_get(pdev->dev.of_node);
regulators = of_find_node_by_name(np, "regulators");
if (!regulators) {
dev_err(&pdev->dev, "regulator node not found\n");
return NULL;
}
count = ARRAY_SIZE(pwm_matches);
matches = pwm_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);
return NULL;
}
pwm_plat_data->num_regulators = count;
*pwm_reg_matches = matches;
for (idx = 0; idx < count; idx++) {
if (!matches[idx].init_data || !matches[idx].of_node)
continue;
pwm_plat_data->pwm_init_data[idx] = matches[idx].init_data;
pwm_plat_data->of_node[idx] = matches[idx].of_node;
}
init_vol = of_get_property(np, "rockchip,pwm_voltage", NULL);
if (init_vol)
pwm_plat_data->pwm_init_vol = be32_to_cpu(*init_vol);
max_vol = of_get_property(np, "rockchip,pwm_max_voltage", NULL);
if (max_vol)
pwm_plat_data->pwm_max_vol = be32_to_cpu(*max_vol);
min_vol = of_get_property(np, "rockchip,pwm_min_voltage", NULL);
if (min_vol)
pwm_plat_data->pwm_min_vol = be32_to_cpu(*min_vol);
suspend_vol = of_get_property(np, "rockchip,pwm_suspend_voltage", NULL);
if (suspend_vol)
pwm_plat_data->pwm_suspend_vol = be32_to_cpu(*suspend_vol);
coefficient = of_get_property(np, "rockchip,pwm_coefficient", NULL);
if (coefficient)
pwm_plat_data->pwm_coefficient = be32_to_cpu(*coefficient);
id = of_get_property(np, "rockchip,pwm_id", NULL);
if (id)
pwm_plat_data->pwm_id = be32_to_cpu(*id);
prop = of_find_property(np, "rockchip,pwm_voltage_map", &length);
if (!prop)
return NULL;
pwm_plat_data->pwm_vol_map_count = length / sizeof(u32);
if (pwm_plat_data->pwm_vol_map_count > 0) {
size_t size = sizeof(*pwm_plat_data->pwm_voltage_map) * pwm_plat_data->pwm_vol_map_count;
pwm_plat_data->pwm_voltage_map = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
if (!pwm_plat_data->pwm_voltage_map)
return NULL;
ret = of_property_read_u32_array(np, "rockchip,pwm_voltage_map",
pwm_plat_data->pwm_voltage_map, pwm_plat_data->pwm_vol_map_count);
if (ret < 0)
printk("pwm voltage map not specified\n");
}
return pwm_plat_data;
}
static void palmas_dt_to_pdata(struct device *dev,
struct device_node *node,
struct palmas_pmic_platform_data *pdata,
struct palmas_pmic_driver_data *ddata)
{
struct device_node *regulators;
u32 prop;
int idx, ret;
regulators = of_get_child_by_name(node, "regulators");
if (!regulators) {
dev_info(dev, "regulator node not found\n");
return;
}
ret = of_regulator_match(dev, regulators, ddata->palmas_matches,
ddata->max_reg);
of_node_put(regulators);
if (ret < 0) {
dev_err(dev, "Error parsing regulator init data: %d\n", ret);
return;
}
for (idx = 0; idx < ddata->max_reg; idx++) {
if (!ddata->palmas_matches[idx].init_data ||
!ddata->palmas_matches[idx].of_node)
continue;
pdata->reg_data[idx] = ddata->palmas_matches[idx].init_data;
pdata->reg_init[idx] = devm_kzalloc(dev,
sizeof(struct palmas_reg_init), GFP_KERNEL);
pdata->reg_init[idx]->warm_reset =
of_property_read_bool(ddata->palmas_matches[idx].of_node,
"ti,warm-reset");
ret = of_property_read_u32(ddata->palmas_matches[idx].of_node,
"ti,roof-floor", &prop);
/* EINVAL: Property not found */
if (ret != -EINVAL) {
int econtrol;
/* use default value, when no value is specified */
econtrol = PALMAS_EXT_CONTROL_NSLEEP;
if (!ret) {
switch (prop) {
case 1:
econtrol = PALMAS_EXT_CONTROL_ENABLE1;
break;
case 2:
econtrol = PALMAS_EXT_CONTROL_ENABLE2;
break;
case 3:
econtrol = PALMAS_EXT_CONTROL_NSLEEP;
break;
default:
WARN_ON(1);
dev_warn(dev,
"%s: Invalid roof-floor option: %u\n",
palmas_matches[idx].name, prop);
break;
}
}
pdata->reg_init[idx]->roof_floor = econtrol;
}
ret = of_property_read_u32(ddata->palmas_matches[idx].of_node,
"ti,mode-sleep", &prop);
if (!ret)
pdata->reg_init[idx]->mode_sleep = prop;
ret = of_property_read_bool(ddata->palmas_matches[idx].of_node,
"ti,smps-range");
if (ret)
pdata->reg_init[idx]->vsel =
PALMAS_SMPS12_VOLTAGE_RANGE;
if (idx == PALMAS_REG_LDO8)
pdata->enable_ldo8_tracking = of_property_read_bool(
ddata->palmas_matches[idx].of_node,
"ti,enable-ldo8-tracking");
}
pdata->ldo6_vibrator = of_property_read_bool(node, "ti,ldo6-vibrator");
}
static struct act8846_board *act8846_parse_dt(struct act8846 *act8846)
{
// struct act8846 *act8846 = i2c->dev.parent;
struct act8846_board *pdata;
struct device_node *regs;
struct device_node *act8846_pmic_np;
int i, count;
int gpio;
printk("%s,line=%d\n", __func__,__LINE__);
act8846_pmic_np = of_node_get(act8846->dev->of_node);
if (!act8846_pmic_np) {
printk("could not find pmic sub-node\n");
return NULL;
}
regs = of_find_node_by_name(act8846_pmic_np, "regulators");
if (!regs)
return NULL;
count = of_regulator_match(act8846->dev, regs, act8846_reg_matches,act8846_NUM_REGULATORS);
of_node_put(regs);
if ((count < 0) || (count > act8846_NUM_REGULATORS))
return NULL;
pdata = devm_kzalloc(act8846->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return NULL;
for (i = 0; i < count; i++) {
if (!act8846_reg_matches[i].init_data || !act8846_reg_matches[i].of_node)
continue;
pdata->act8846_init_data[i] = act8846_reg_matches[i].init_data;
pdata->of_node[i] = act8846_reg_matches[i].of_node;
}
pdata->irq = act8846->chip_irq;
pdata->irq_base = -1;
gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 0);
if (!gpio_is_valid(gpio))
printk("invalid gpio: %d\n",gpio);
pdata->pmic_sleep_gpio = gpio;
pdata->pmic_sleep = true;
gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 1);
if (!gpio_is_valid(gpio))
printk("invalid gpio: %d\n",gpio);
pdata->pmic_hold_gpio = gpio;
pdata->pm_off = of_property_read_bool(act8846_pmic_np,"act8846,system-power-controller");
gpio = of_get_named_gpio(act8846_pmic_np,"cpu_det_gpio", 0);
if (!gpio_is_valid(gpio))
printk("invalid gpio: %d\n",gpio);
pdata->pmic_cpu_det_gpio = gpio;
gpio = of_get_named_gpio(act8846_pmic_np,"usb_hub_reset_gpio", 0);
if (!gpio_is_valid(gpio))
printk("lhm invalid gpio: %d\n",gpio);
pdata->pmic_usb_hub_reset_gpio = gpio;
return pdata;
}
