Commit 55576cf1 authored by Mark Brown's avatar Mark Brown

regulator: Defer init completion for a while after late_initcall

The kernel has no way of knowing when we have finished instantiating
drivers, between deferred probe and systems that build key drivers as
modules we might be doing this long after userspace has booted. This has
always been a bit of an issue with regulator_init_complete since it can
power off hardware that's not had it's driver loaded which can result in
user visible effects, the main case is powering off displays. Practically
speaking it's not been an issue in real systems since most systems that
use the regulator API are embedded and build in key drivers anyway but
with Arm laptops coming on the market it's becoming more of an issue so
let's do something about it.

In the absence of any better idea just defer the powering off for 30s
after late_initcall(), this is obviously a hack but it should mask the
issue for now and it's no more arbitrary than late_initcall() itself.
Ideally we'd have some heuristics to detect if we're on an affected
system and tune or skip the delay appropriately, and there may be some
need for a command line option to be added.

Link: https://lore.kernel.org/r/20190904124250.25844-1-broonie@kernel.orgSigned-off-by: default avatarMark Brown <broonie@kernel.org>
Tested-by: default avatarLee Jones <lee.jones@linaro.org>
Cc: stable@vger.kernel.org
parent d072cb26
...@@ -5644,7 +5644,7 @@ static int __init regulator_init(void) ...@@ -5644,7 +5644,7 @@ static int __init regulator_init(void)
/* init early to allow our consumers to complete system booting */ /* init early to allow our consumers to complete system booting */
core_initcall(regulator_init); core_initcall(regulator_init);
static int __init regulator_late_cleanup(struct device *dev, void *data) static int regulator_late_cleanup(struct device *dev, void *data)
{ {
struct regulator_dev *rdev = dev_to_rdev(dev); struct regulator_dev *rdev = dev_to_rdev(dev);
const struct regulator_ops *ops = rdev->desc->ops; const struct regulator_ops *ops = rdev->desc->ops;
...@@ -5693,17 +5693,8 @@ static int __init regulator_late_cleanup(struct device *dev, void *data) ...@@ -5693,17 +5693,8 @@ static int __init regulator_late_cleanup(struct device *dev, void *data)
return 0; return 0;
} }
static int __init regulator_init_complete(void) static void regulator_init_complete_work_function(struct work_struct *work)
{ {
/*
* Since DT doesn't provide an idiomatic mechanism for
* enabling full constraints and since it's much more natural
* with DT to provide them just assume that a DT enabled
* system has full constraints.
*/
if (of_have_populated_dt())
has_full_constraints = true;
/* /*
* Regulators may had failed to resolve their input supplies * Regulators may had failed to resolve their input supplies
* when were registered, either because the input supply was * when were registered, either because the input supply was
...@@ -5721,6 +5712,35 @@ static int __init regulator_init_complete(void) ...@@ -5721,6 +5712,35 @@ static int __init regulator_init_complete(void)
*/ */
class_for_each_device(&regulator_class, NULL, NULL, class_for_each_device(&regulator_class, NULL, NULL,
regulator_late_cleanup); regulator_late_cleanup);
}
static DECLARE_DELAYED_WORK(regulator_init_complete_work,
regulator_init_complete_work_function);
static int __init regulator_init_complete(void)
{
/*
* Since DT doesn't provide an idiomatic mechanism for
* enabling full constraints and since it's much more natural
* with DT to provide them just assume that a DT enabled
* system has full constraints.
*/
if (of_have_populated_dt())
has_full_constraints = true;
/*
* We punt completion for an arbitrary amount of time since
* systems like distros will load many drivers from userspace
* so consumers might not always be ready yet, this is
* particularly an issue with laptops where this might bounce
* the display off then on. Ideally we'd get a notification
* from userspace when this happens but we don't so just wait
* a bit and hope we waited long enough. It'd be better if
* we'd only do this on systems that need it, and a kernel
* command line option might be useful.
*/
schedule_delayed_work(&regulator_init_complete_work,
msecs_to_jiffies(30000));
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