AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2025-01-18 12:16:19 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

regulator: core: Resolve coupled regulators

Browse Source 
On Odroid XU3/4 and other Exynos5422 based boards there is a case, that
different devices on the board are supplied by different regulators
with non-fixed voltages. If one of these devices temporarily requires
higher voltage, there might occur a situation that the spread between
two devices' voltages is so high, that there is a risk of changing
'high' and 'low' states on the interconnection between devices powered
by those regulators.

Fill coupling descriptor with data obtained from DTS using previously
defined of_functions. Fail to register a regulator, if some data
inconsistency occurs. If some coupled regulators are not yet registered,
don't fail to register, but try to resolve them in late init call.

Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Maciej Purski 2018-04-23 16:33:40 +02:00 committed by Mark Brown
parent a085a31af5
commit d3d64537c3
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
1 changed files with 100 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
drivers/regulator/core.c
View File

@ -4129,6 +4129,96 @@ static int regulator_register_resolve_supply(struct device *dev, void *data)
return 0;
}
static int regulator_fill_coupling_array(struct regulator_dev *rdev)
{
struct coupling_desc *c_desc = &rdev->coupling_desc;
int n_coupled = c_desc->n_coupled;
struct regulator_dev *c_rdev;
int i;
for (i = 1; i < n_coupled; i++) {
/* already resolved */
if (c_desc->coupled_rdevs[i])
continue;
c_rdev = of_parse_coupled_regulator(rdev, i - 1);
if (c_rdev) {
c_desc->coupled_rdevs[i] = c_rdev;
c_desc->n_resolved++;
}
}
if (rdev->coupling_desc.n_resolved < n_coupled)
return -1;
else
return 0;
}
static int regulator_register_fill_coupling_array(struct device *dev,
void *data)
{
struct regulator_dev *rdev = dev_to_rdev(dev);
if (!IS_ENABLED(CONFIG_OF))
return 0;
if (regulator_fill_coupling_array(rdev))
rdev_dbg(rdev, "unable to resolve coupling\n");
return 0;
}
static int regulator_resolve_coupling(struct regulator_dev *rdev)
{
int n_phandles;
if (!IS_ENABLED(CONFIG_OF))
n_phandles = 0;
else
n_phandles = of_get_n_coupled(rdev);
if (n_phandles + 1 > MAX_COUPLED) {
rdev_err(rdev, "too many regulators coupled\n");
return -EPERM;
}
/*
* Every regulator should always have coupling descriptor filled with
* at least pointer to itself.
*/
rdev->coupling_desc.coupled_rdevs[0] = rdev;
rdev->coupling_desc.n_coupled = n_phandles + 1;
rdev->coupling_desc.n_resolved++;
/* regulator isn't coupled */
if (n_phandles == 0)
return 0;
/* regulator, which can't change its voltage, can't be coupled */
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
rdev_err(rdev, "voltage operation not allowed\n");
return -EPERM;
}
if (rdev->constraints->max_spread <= 0) {
rdev_err(rdev, "wrong max_spread value\n");
return -EPERM;
}
if (!of_check_coupling_data(rdev))
return -EPERM;
/*
* After everything has been checked, try to fill rdevs array
* with pointers to regulators parsed from device tree. If some
* regulators are not registered yet, retry in late init call
*/
regulator_fill_coupling_array(rdev);
return 0;
}
/**
* regulator_register - register regulator
* @regulator_desc: regulator to register
@ -4262,6 +4352,13 @@ regulator_register(const struct regulator_desc *regulator_desc,
if (ret < 0)
goto wash;
mutex_lock(&regulator_list_mutex);
ret = regulator_resolve_coupling(rdev);
mutex_unlock(&regulator_list_mutex);
if (ret != 0)
goto wash;
/* add consumers devices */
if (init_data) {
mutex_lock(&regulator_list_mutex);
@ -4756,6 +4853,9 @@ static int __init regulator_init_complete(void)
class_for_each_device(&regulator_class, NULL, NULL,
regulator_late_cleanup);
class_for_each_device(&regulator_class, NULL, NULL,
regulator_register_fill_coupling_array);
return 0;
}
late_initcall_sync(regulator_init_complete);