iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

regulator: empty the old suspend functions

Browse Source 
Regualtor suspend/resume functions should only be called by PM suspend
core via registering dev_pm_ops, and regulator devices should implement
the callback functions.  Thus, any regulator consumer shouldn't call
the regulator suspend/resume functions directly.

In order to avoid compile errors, two empty functions with the same name
still be left for the time being.

Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Chunyan Zhang 2018-01-26 21:08:46 +08:00 committed by Mark Brown
parent 72069f9957
commit aa27bbc6c6
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
2 changed files with 2 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
drivers/regulator/core.c
View File

@ -4179,80 +4179,6 @@ void regulator_unregister(struct regulator_dev *rdev)
}
EXPORT_SYMBOL_GPL(regulator_unregister);
static int _regulator_suspend_prepare(struct device *dev, void *data)
{
struct regulator_dev *rdev = dev_to_rdev(dev);
const suspend_state_t *state = data;
int ret;
mutex_lock(&rdev->mutex);
ret = suspend_prepare(rdev, *state);
mutex_unlock(&rdev->mutex);
return ret;
}
/**
* regulator_suspend_prepare - prepare regulators for system wide suspend
* @state: system suspend state
*
* Configure each regulator with it's suspend operating parameters for state.
* This will usually be called by machine suspend code prior to supending.
*/
int regulator_suspend_prepare(suspend_state_t state)
{
/* ON is handled by regulator active state */
if (state == PM_SUSPEND_ON)
return -EINVAL;
return class_for_each_device(&regulator_class, NULL, &state,
_regulator_suspend_prepare);
}
EXPORT_SYMBOL_GPL(regulator_suspend_prepare);
static int _regulator_suspend_finish(struct device *dev, void *data)
{
struct regulator_dev *rdev = dev_to_rdev(dev);
int ret;
mutex_lock(&rdev->mutex);
if (rdev->use_count > 0 || rdev->constraints->always_on) {
if (!_regulator_is_enabled(rdev)) {
ret = _regulator_do_enable(rdev);
if (ret)
dev_err(dev,
"Failed to resume regulator %d\n",
ret);
}
} else {
if (!have_full_constraints())
goto unlock;
if (!_regulator_is_enabled(rdev))
goto unlock;
ret = _regulator_do_disable(rdev);
if (ret)
dev_err(dev, "Failed to suspend regulator %d\n", ret);
}
unlock:
mutex_unlock(&rdev->mutex);
/* Keep processing regulators in spite of any errors */
return 0;
}
/**
* regulator_suspend_finish - resume regulators from system wide suspend
*
* Turn on regulators that might be turned off by regulator_suspend_prepare
* and that should be turned on according to the regulators properties.
*/
int regulator_suspend_finish(void)
{
return class_for_each_device(&regulator_class, NULL, NULL,
_regulator_suspend_finish);
}
EXPORT_SYMBOL_GPL(regulator_suspend_finish);
/**
* regulator_has_full_constraints - the system has fully specified constraints

5
include/linux/regulator/machine.h
View File

@ -236,12 +236,12 @@ struct regulator_init_data {
#ifdef CONFIG_REGULATOR
void regulator_has_full_constraints(void);
int regulator_suspend_prepare(suspend_state_t state);
int regulator_suspend_finish(void);
#else
static inline void regulator_has_full_constraints(void)
{
}
#endif
static inline int regulator_suspend_prepare(suspend_state_t state)
{
return 0;
@ -250,6 +250,5 @@ static inline int regulator_suspend_finish(void)
{
return 0;
}
#endif
#endif