redonkable/remarkable-linux
redonkable/remarkable-linux
1
0
Fork 0
Code Releases Activity

regulator: Revert coupled regulator support again

Browse source 
Revert the last two commits of the voltage coupling mechanism patch set:

456e7cdf3b regulator: core: Change voltage setting path
696861761a regulator: core: Add voltage balancing mechanism

as they broke boot on OMAP again.

Reported-by: Tony Lindgren <tony@atomide.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Mark Brown 2018-05-30 15:20:03 +01:00
parent ab4d11e2c2
commit 38de19fa71
No known key found for this signature in database
GPG key ID: 24D68B725D5487D0
1 changed files with 41 additions and 288 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

329
drivers/regulator/core.c
View file

@ -105,11 +105,6 @@ static int _notifier_call_chain(struct regulator_dev *rdev,
unsigned long event, void *data);
static int _regulator_do_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV);
static int regulator_balance_voltage(struct regulator_dev *rdev,
suspend_state_t state);
static int regulator_set_voltage_rdev(struct regulator_dev *rdev,
int min_uV, int max_uV,
suspend_state_t state);
static struct regulator *create_regulator(struct regulator_dev *rdev,
struct device *dev,
const char *supply_name);
@ -201,66 +196,37 @@ static void regulator_unlock(struct regulator_dev *rdev)
}
}
static int regulator_lock_recursive(struct regulator_dev *rdev,
unsigned int subclass)
/**
* regulator_lock_supply - lock a regulator and its supplies
* @rdev: regulator source
*/
static void regulator_lock_supply(struct regulator_dev *rdev)
{
struct regulator_dev *c_rdev;
int i;
for (i = 0; i < rdev->coupling_desc.n_coupled; i++) {
c_rdev = rdev->coupling_desc.coupled_rdevs[i];
if (!c_rdev)
continue;
regulator_lock_nested(c_rdev, subclass++);
if (c_rdev->supply)
subclass =
regulator_lock_recursive(c_rdev->supply->rdev,
subclass);
}
return subclass;
for (i = 0; rdev; rdev = rdev_get_supply(rdev), i++)
regulator_lock_nested(rdev, i);
}
/**
* regulator_unlock_dependent - unlock regulator's suppliers and coupled
* regulators
* @rdev: regulator source
*
* Unlock all regulators related with rdev by coupling or suppling.
* regulator_unlock_supply - unlock a regulator and its supplies
* @rdev: regulator source
*/
static void regulator_unlock_dependent(struct regulator_dev *rdev)
static void regulator_unlock_supply(struct regulator_dev *rdev)
{
struct regulator_dev *c_rdev;
int i;
struct regulator *supply;
for (i = 0; i < rdev->coupling_desc.n_coupled; i++) {
c_rdev = rdev->coupling_desc.coupled_rdevs[i];
while (1) {
regulator_unlock(rdev);
supply = rdev->supply;
if (!c_rdev)
continue;
if (!rdev->supply)
return;
regulator_unlock(c_rdev);
if (c_rdev->supply)
regulator_unlock_dependent(c_rdev->supply->rdev);
rdev = supply->rdev;
}
}
/**
* regulator_lock_dependent - lock regulator's suppliers and coupled regulators
* @rdev: regulator source
*
* This function as a wrapper on regulator_lock_recursive(), which locks
* all regulators related with rdev by coupling or suppling.
*/
static inline void regulator_lock_dependent(struct regulator_dev *rdev)
{
regulator_lock_recursive(rdev, 0);
}
/**
* of_get_regulator - get a regulator device node based on supply name
* @dev: Device pointer for the consumer (of regulator) device
@ -2293,11 +2259,6 @@ int regulator_enable(struct regulator *regulator)
struct regulator_dev *rdev = regulator->rdev;
int ret = 0;
if (rdev->coupling_desc.n_resolved != rdev->coupling_desc.n_coupled) {
rdev_err(rdev, "not all coupled regulators registered\n");
return -EPERM;
}
if (regulator->always_on)
return 0;
@ -2307,12 +2268,9 @@ int regulator_enable(struct regulator *regulator)
return ret;
}
regulator_lock_dependent(rdev);
mutex_lock(&rdev->mutex);
ret = _regulator_enable(rdev);
/* balance only if there are regulators coupled */
if (rdev->coupling_desc.n_coupled > 1)
regulator_balance_voltage(rdev, PM_SUSPEND_ON);
regulator_unlock_dependent(rdev);
mutex_unlock(&rdev->mutex);
if (ret != 0 && rdev->supply)
regulator_disable(rdev->supply);
@ -2418,11 +2376,9 @@ int regulator_disable(struct regulator *regulator)
if (regulator->always_on)
return 0;
regulator_lock_dependent(rdev);
mutex_lock(&rdev->mutex);
ret = _regulator_disable(rdev);
if (rdev->coupling_desc.n_coupled > 1)
regulator_balance_voltage(rdev, PM_SUSPEND_ON);
regulator_unlock_dependent(rdev);
mutex_unlock(&rdev->mutex);
if (ret == 0 && rdev->supply)
regulator_disable(rdev->supply);
@ -2471,12 +2427,10 @@ int regulator_force_disable(struct regulator *regulator)
struct regulator_dev *rdev = regulator->rdev;
int ret;
regulator_lock_dependent(rdev);
mutex_lock(&rdev->mutex);
regulator->uA_load = 0;
ret = _regulator_force_disable(regulator->rdev);
if (rdev->coupling_desc.n_coupled > 1)
regulator_balance_voltage(rdev, PM_SUSPEND_ON);
regulator_unlock_dependent(rdev);
mutex_unlock(&rdev->mutex);
if (rdev->supply)
while (rdev->open_count--)
@ -2624,9 +2578,9 @@ int regulator_is_enabled(struct regulator *regulator)
if (regulator->always_on)
return 1;
regulator_lock_dependent(regulator->rdev);
mutex_lock(&regulator->rdev->mutex);
ret = _regulator_is_enabled(regulator->rdev);
regulator_unlock_dependent(regulator->rdev);
mutex_unlock(&regulator->rdev->mutex);
return ret;
}
@ -3035,12 +2989,8 @@ static int regulator_set_voltage_unlocked(struct regulator *regulator,
int ret = 0;
int old_min_uV, old_max_uV;
int current_uV;
if (rdev->coupling_desc.n_resolved != rdev->coupling_desc.n_coupled) {
rdev_err(rdev, "not all coupled regulators registered\n");
ret = -EPERM;
goto out;
}
int best_supply_uV = 0;
int supply_change_uV = 0;
/* If we're setting the same range as last time the change
* should be a noop (some cpufreq implementations use the same
@ -3084,27 +3034,6 @@ static int regulator_set_voltage_unlocked(struct regulator *regulator,
if (ret < 0)
goto out2;
/* for not coupled regulators this will just set the voltage */
ret = regulator_balance_voltage(rdev, state);
if (ret < 0)
goto out2;
out:
return 0;
out2:
voltage->min_uV = old_min_uV;
voltage->max_uV = old_max_uV;
return ret;
}
static int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
int max_uV, suspend_state_t state)
{
int best_supply_uV = 0;
int supply_change_uV = 0;
int ret;
if (rdev->supply &&
regulator_ops_is_valid(rdev->supply->rdev,
REGULATOR_CHANGE_VOLTAGE) &&
@ -3116,13 +3045,13 @@ static int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
selector = regulator_map_voltage(rdev, min_uV, max_uV);
if (selector < 0) {
ret = selector;
goto out;
goto out2;
}
best_supply_uV = _regulator_list_voltage(rdev, selector, 0);
if (best_supply_uV < 0) {
ret = best_supply_uV;
goto out;
goto out2;
}
best_supply_uV += rdev->desc->min_dropout_uV;
@ -3130,7 +3059,7 @@ static int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
current_supply_uV = _regulator_get_voltage(rdev->supply->rdev);
if (current_supply_uV < 0) {
ret = current_supply_uV;
goto out;
goto out2;
}
supply_change_uV = best_supply_uV - current_supply_uV;
@ -3142,7 +3071,7 @@ static int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
if (ret) {
dev_err(&rdev->dev, "Failed to increase supply voltage: %d\n",
ret);
goto out;
goto out2;
}
}
@ -3152,7 +3081,7 @@ static int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
ret = _regulator_do_set_suspend_voltage(rdev, min_uV,
max_uV, state);
if (ret < 0)
goto out;
goto out2;
if (supply_change_uV < 0) {
ret = regulator_set_voltage_unlocked(rdev->supply,
@ -3166,186 +3095,10 @@ static int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
out:
return ret;
}
out2:
voltage->min_uV = old_min_uV;
voltage->max_uV = old_max_uV;
static int regulator_get_optimal_voltage(struct regulator_dev *rdev)
{
struct coupling_desc *c_desc = &rdev->coupling_desc;
struct regulator_dev **c_rdevs = c_desc->coupled_rdevs;
int max_spread = rdev->constraints->max_spread;
int n_coupled = c_desc->n_coupled;
int desired_min_uV, desired_max_uV, min_current_uV = INT_MAX;
int max_current_uV = 0, highest_min_uV = 0, target_uV, possible_uV;
int i, ret;
/* If consumers don't provide any demands, set voltage to min_uV */
desired_min_uV = rdev->constraints->min_uV;
desired_max_uV = rdev->constraints->max_uV;
ret = regulator_check_consumers(rdev,
&desired_min_uV,
&desired_max_uV, PM_SUSPEND_ON);
if (ret < 0)
goto out;
/*
* If there are no coupled regulators, simply set the voltage demanded
* by consumers.
*/
if (n_coupled == 1) {
ret = desired_min_uV;
goto out;
}
/* Find highest min desired voltage */
for (i = 0; i < n_coupled; i++) {
int tmp_min = 0;
int tmp_max = INT_MAX;
if (!_regulator_is_enabled(c_rdevs[i]))
continue;
ret = regulator_check_consumers(c_rdevs[i],
&tmp_min,
&tmp_max, PM_SUSPEND_ON);
if (ret < 0)
goto out;
if (tmp_min > highest_min_uV)
highest_min_uV = tmp_min;
}
/*
* Let target_uV be equal to the desired one if possible.
* If not, set it to minimum voltage, allowed by other coupled
* regulators.
*/
target_uV = max(desired_min_uV, highest_min_uV - max_spread);
/*
* Find min and max voltages, which currently aren't
* violating max_spread
*/
for (i = 0; i < n_coupled; i++) {
int tmp_act;
/*
* Don't check the regulator, which is about
* to change voltage
*/
if (c_rdevs[i] == rdev)
continue;
if (!_regulator_is_enabled(c_rdevs[i]))
continue;
tmp_act = _regulator_get_voltage(c_rdevs[i]);
if (tmp_act < 0) {
ret = tmp_act;
goto out;
}
if (tmp_act < min_current_uV)
min_current_uV = tmp_act;
if (tmp_act > max_current_uV)
max_current_uV = tmp_act;
}
/* There aren't any other regulators enabled */
if (max_current_uV == 0) {
possible_uV = target_uV;
} else {
/*
* Correct target voltage, so as it currently isn't
* violating max_spread
*/
possible_uV = max(target_uV, max_current_uV - max_spread);
possible_uV = min(possible_uV, min_current_uV + max_spread);
}
if (possible_uV > desired_max_uV) {
ret = -EINVAL;
goto out;
}
ret = possible_uV;
out:
return ret;
}
static int regulator_balance_voltage(struct regulator_dev *rdev,
suspend_state_t state)
{
struct regulator_dev **c_rdevs;
struct regulator_dev *best_rdev;
struct coupling_desc *c_desc = &rdev->coupling_desc;
int n_coupled;
int i, best_delta, best_uV, ret = 1;
c_rdevs = c_desc->coupled_rdevs;
n_coupled = c_desc->n_coupled;
/*
* if system is in a state other than PM_SUSPEND_ON, don't check
* other coupled regulators
*/
if (state != PM_SUSPEND_ON)
n_coupled = 1;
/*
* Find the best possible voltage change on each loop. Leave the loop
* if there isn't any possible change.
*/
while (1) {
best_delta = 0;
best_uV = 0;
best_rdev = NULL;
/*
* Find highest difference between optimal voltage
* and current voltage.
*/
for (i = 0; i < n_coupled; i++) {
/*
* optimal_uV is the best voltage that can be set for
* i-th regulator at the moment without violating
* max_spread constraint in order to balance
* the coupled voltages.
*/
int optimal_uV, current_uV;
optimal_uV = regulator_get_optimal_voltage(c_rdevs[i]);
if (optimal_uV < 0) {
ret = optimal_uV;
goto out;
}
current_uV = _regulator_get_voltage(c_rdevs[i]);
if (current_uV < 0) {
ret = optimal_uV;
goto out;
}
if (abs(best_delta) < abs(optimal_uV - current_uV)) {
best_delta = optimal_uV - current_uV;
best_rdev = c_rdevs[i];
best_uV = optimal_uV;
}
}
/* Nothing to change, return successfully */
if (!best_rdev) {
ret = 0;
goto out;
}
ret = regulator_set_voltage_rdev(best_rdev, best_uV,
best_uV, state);
if (ret < 0)
goto out;
}
out:
return ret;
}
@ -3371,12 +3124,12 @@ int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
{
int ret = 0;
regulator_lock_dependent(regulator->rdev);
regulator_lock_supply(regulator->rdev);
ret = regulator_set_voltage_unlocked(regulator, min_uV, max_uV,
PM_SUSPEND_ON);
regulator_unlock_dependent(regulator->rdev);
regulator_unlock_supply(regulator->rdev);
return ret;
}
@ -3454,12 +3207,12 @@ int regulator_set_suspend_voltage(struct regulator *regulator, int min_uV,
if (regulator_check_states(state) || state == PM_SUSPEND_ON)
return -EINVAL;
regulator_lock_dependent(regulator->rdev);
regulator_lock_supply(regulator->rdev);
ret = _regulator_set_suspend_voltage(regulator, min_uV,
max_uV, state);
regulator_unlock_dependent(regulator->rdev);
regulator_unlock_supply(regulator->rdev);
return ret;
}
@ -3651,11 +3404,11 @@ int regulator_get_voltage(struct regulator *regulator)
{
int ret;
regulator_lock_dependent(regulator->rdev);
regulator_lock_supply(regulator->rdev);
ret = _regulator_get_voltage(regulator->rdev);
regulator_unlock_dependent(regulator->rdev);
regulator_unlock_supply(regulator->rdev);
return ret;
}