Commit 05f224ca authored by Douglas Anderson's avatar Douglas Anderson Committed by Mark Brown

regulator: core: Clean enabling always-on regulators + their supplies

At the end of regulator_resolve_supply() we have historically turned
on our supply in some cases.  This could be for one of two reasons:

1. If resolving supplies was happening before the call to
   set_machine_constraints() we needed to predict if
   set_machine_constraints() was going to turn the regulator on and we
   needed to preemptively turn the supply on.
2. Maybe set_machine_constraints() happened before we could resolve
   supplies (because we failed the first time to resolve) and thus we
   might need to propagate an enable that already happened up to our
   supply.

Historically regulator_resolve_supply() used _regulator_is_enabled()
to decide whether to turn on the supply.

Let's change things a little bit.  Specifically:

1. Let's try to enable the supply and the regulator in the same place,
   both in set_machine_constraints().  This means that we have exactly
   the same logic for enabling the supply and the regulator.
2. Let's properly set use_count when we enable always-on or boot-on
   regulators even for those that don't have supplies.  The previous
   commit 1fc12b05 ("regulator: core: Avoid propagating to
   supplies when possible") only did this right for regulators with
   supplies.
3. Let's make it clear that the only time we need to enable the supply
   in regulator_resolve_supply() is if the main regulator is currently
   in use.  By using use_count (like the rest of the code) to decide
   if we're going to enable our supply we keep everything consistent.

Overall the new scheme should be cleaner and easier to reason about.
In addition to fixing regulator_summary to be more correct (because of
the more correct use_count), this change also has the effect of no
longer using _regulator_is_enabled() in this code path.
_regulator_is_enabled() could return an error code for some regulators
at bootup (like RPMh) that can't read their initial state.  While one
can argue that the design of those regulators is sub-optimal, the new
logic sidesteps this brokenness.  This fix in particular fixes
observed problems on Qualcomm sdm845 boards which use the
above-mentioned RPMh regulator.  Those problems were made worse by
commit 1fc12b05 ("regulator: core: Avoid propagating to supplies
when possible") because now we'd think at bootup that the SD
regulators were already enabled and we'd never try them again.

Fixes: 1fc12b05 ("regulator: core: Avoid propagating to supplies when possible")
Reported-by: default avatarEvan Green <evgreen@chromium.org>
Signed-off-by: default avatarDouglas Anderson <dianders@chromium.org>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent e6202e82
...@@ -1399,11 +1399,21 @@ static int set_machine_constraints(struct regulator_dev *rdev, ...@@ -1399,11 +1399,21 @@ static int set_machine_constraints(struct regulator_dev *rdev,
* and we have control then make sure it is enabled. * and we have control then make sure it is enabled.
*/ */
if (rdev->constraints->always_on || rdev->constraints->boot_on) { if (rdev->constraints->always_on || rdev->constraints->boot_on) {
if (rdev->supply) {
ret = regulator_enable(rdev->supply);
if (ret < 0) {
_regulator_put(rdev->supply);
rdev->supply = NULL;
return ret;
}
}
ret = _regulator_do_enable(rdev); ret = _regulator_do_enable(rdev);
if (ret < 0 && ret != -EINVAL) { if (ret < 0 && ret != -EINVAL) {
rdev_err(rdev, "failed to enable\n"); rdev_err(rdev, "failed to enable\n");
return ret; return ret;
} }
rdev->use_count++;
} }
print_constraints(rdev); print_constraints(rdev);
...@@ -1820,15 +1830,18 @@ static int regulator_resolve_supply(struct regulator_dev *rdev) ...@@ -1820,15 +1830,18 @@ static int regulator_resolve_supply(struct regulator_dev *rdev)
return ret; return ret;
} }
/* Cascade always-on state to supply */ /*
if (_regulator_is_enabled(rdev)) { * In set_machine_constraints() we may have turned this regulator on
* but we couldn't propagate to the supply if it hadn't been resolved
* yet. Do it now.
*/
if (rdev->use_count) {
ret = regulator_enable(rdev->supply); ret = regulator_enable(rdev->supply);
if (ret < 0) { if (ret < 0) {
_regulator_put(rdev->supply); _regulator_put(rdev->supply);
rdev->supply = NULL; rdev->supply = NULL;
return ret; return ret;
} }
rdev->use_count = 1;
} }
return 0; return 0;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment